====================
= DGAS-Sim - To do =
====================

- implement budget constraints (maximum cost for jobs), analogue to
  CPU requirements.

- consider different CE classes (e.g. differenciated by Operating System)
  and jobs that can run only on one or more specific classes.
  For now we differenciate CE performance and queue classes.

- Have jobs submitted with some kind of distribution. For now, all
  job types specified in the configuration file have equal possibilities
  of beeing submitted to the resource broker (simple random selection).

- Model different kinds of jobs, for example Monte-Carlo jobs.
  (allow job to personalize the brokering strategy, implement
  utility function that takes parameters for priority on
  computing power, low prices, data location, etc.)
  For now jobs have only a minimum CPU performance requirement and
  requirements concerning the queue type to be submitted to.

- Add further utilify modules/functions.

- model ComputingElements as extensions of a GridResource base class, such
  that DGAS-Sim becomes more extendable and may include storage and network
  resources.

- consider memory latency by adding memory requirements to Job and phyiscal
  and virtual memory to ComputingElement (simulate page faults)?

- include The Home Location Registers (responsible for accounting) into the
  simultation framework, this will allow the simultation of users with
  budget constraints.

- model Virtual Organizations: User extends Thread (having a maximum budget
  and a job submission pattern; users are associated with a specific site),
  ResourceBroker extends Thread (until now this was not necessary),
  VirtualOrganization extends Thread (groups Users and ComputingElements and
  periodically redistributes the credits earned by the ComputingElements to
  the VOs Users, using a RedistributionModel, which may be different for each
  VO, thus respecting different policies of different administrative domains).

- model local scheduling systems (FCFS, backfilling, etc.) as Queue class
  used by ComputingElements (the current implementation is a simple FCFS, that
  doesn't even keep track of the single jobs that are in queue, but just
  decreases the total queue wait time of all jobs in the queue).
  This requires also to improve the ComputingElement model in order to
  include SMPs (at the moment CEs are modeled as single-processor machines)
  and clusters.

- model the diurnal user behavior that is typical in large-scale computational
  settings

- add automatic calculation of performance metrics: average response time
  (= average QWT), average time till completion for the different job types
  (it wouldn't make much sense to compare two jobs of substantially different
  consumption of computational energy), throughput (no. of jobs completed per
  t.u. or utilized computational energy per t.u.), application failure
  probability (no. jobs not submitted / total no. of jobs).

- add the possibility to add/remove ComputingElements during the simulation
  run in order to simulate splits/network problems.

- improve the Job class and the CE queue, such that single jobs can be traced
  in the queue => use the average job completion time (for the different job
  types) as an indicator for throughput
