TODO

   1 ###
   2 ### Ongoing stuff
   3 ###
   4
   5 Document the fact that gras processes display the backtrace on sigusr and sigint
   6 Document XBT_LOG_EXTERNAL_DEFAULT_CATEGORY
   7 Document host module
   8
   9 /* FIXME: better place? */
  10 int vasprintf  (char **ptr, const char *fmt, va_list ap);
  11 char *bprintf(const char*fmt, ...) _XBT_GNUC_PRINTF(1,2);
  12
  13 Module renamings:
  14  - rename SWAG to RING?
  15  - Rename cursor to iterator
  16
  17 log.h still contains @name which break doxygen:
  18 xbt/log.h:/** \name DEBUG
  19 xbt/log.h:/** \name VERB
  20 xbt/log.h:/** \name INFO
  21 xbt/log.h:/** \name WARN
  22 xbt/log.h:/** \name ERROR
  23 xbt/log.h:/** \name CRITICAL
  24
  25 gras_socket_close should be blocking until all the data sent have been
  26 received by the other side (implemented with an ACK mechanism).
  27
  28 ###
  29 ### Planned
  30 ###
  31
  32 *
  33 * Infrastructure
  34 ****************
  35
  36 [autoconf]
  37   * Check the gcc version on powerpc. We disabled -floop-optimize on powerpc,
  38     but versions above 3.4.0 should be ok.
  39   * check whether we have better than jmp_buf to implement exceptions, and
  40     use it (may need to generate a public .h, as glib does)
  41
  42 *
  43 * XBT
  44 *****
  45
  46 [doc]
  47   * graphic showing:
  48     (errors, logs ; dynars, dicts, hooks, pools; config, rrdb)
  49
  50 [portability layer]
  51   * Mallocators and/or memory pool so that we can cleanly kill an actor
  52
  53 [errors/exception]
  54   * Better split casual errors from programing errors.
  55     The first ones should be repported to the user, the second should kill
  56     the program (or, yet better, only the msg handler)
  57   * Allows the use of an error handler depending on the current module (ie,
  58     the same philosophy as log4c using GSL's error functions)
  59
  60 [logs]
  61   * Hijack message from a given category to another for a while (to mask
  62     initializations, and more)
  63   * Allow each actor to have its own setting
  64   * a init/exit mecanism for logging appender
  65   * Several appenders; fix the setting stuff to change the appender
  66   * more logging appenders (take those from Ralf in l2)
  67
  68 [dict]
  69   * speed up the cursors, for example using the contexts when available
  70
  71 [modules]
  72   * better formalisation of what modules are (amok deeply needs it)
  73     configuration + init() + join() + exit() + leave() + dependencies
  74     init and exit are run only once
  75     join and leave are run for each process.
  76   * allow to load them at runtime
  77     check in erlang how they upgrade them without downtime
  78
  79 [other modules]
  80   * we may need a round-robin database module, and a statistical one
  81   * a hook module *may* help cleaning up some parts. Not sure yet.
  82   * Some of the datacontainer modules seem to overlap. Kill some of them?
  83     - replace fifo with dynars
  84     - replace set with SWAG
  85
  86 *
  87 * GRAS
  88 ******
  89
  90 [doc]
  91   * implement the P2P protocols that macedon does. They constitute great
  92     examples, too
  93
  94 [transport]
  95   * Spawn threads handling the communication
  96     - Data sending cannot be delegated if we want to be kept informed
  97       (*easily*) of errors here.
  98       - Actor execution flow shouldn't be interrupted
  99       - It should be allowed to access (both in read and write access)
 100         any data available (ie, referenced) from the actor without
 101         requesting to check for a condition before.
 102         (in other word, no mutex or assimilated)
 103       - I know that enforcing those rules prevent the implementation of
 104         really cleaver stuff. Keeping the stuff simple for the users is more
 105         important to me than allowing them to do cleaver tricks. Black magic
 106         should be done *within* gras to reach a good performance level.
 107
 108     - Data receiving can be delegated (and should)
 109       The first step here is a "simple" mailbox mecanism, with a fifo of
 110         messages protected by semaphore.
 111       The rest is rather straightforward too.
 112
 113   * use poll(2) instead of select(2) when available. (first need to check
 114     the advantage of doing so ;)
 115
 116     Another idea we spoke about was to simulate this feature with a bunch of
 117     threads blocked in a read(1) on each incomming socket. The latency is
 118     reduced by the cost of a syscall, but the more I think about it, the
 119     less I find the idea adapted to our context.
 120
 121   * timeout the send/recv too (hard to do in RL)
 122   * Adaptative timeout
 123   * multiplex on incoming SOAP over HTTP (once datadesc can deal with it)
 124
 125   * The module syntax/API is too complex.
 126     - Everybody opens a server socket (or almost), and nobody open two of
 127       them. This should be done automatically without user intervention.
 128     - I'd like to offer the possibility to speak to someone, not to speak on
 129       a socket. Users shouldn't care about such technical details.
 130     - the idea of host_cookie in NWS seem to match my needs, but we still
 131       need a proper name ;)
 132     - this would allow to exchange a "socket" between peer :)
 133     - the creation needs to identify the peer actor within the process
 134
 135   * when a send failed because the socket was closed on the other side,
 136     try to reopen it seamlessly. Needs exceptions or another way to
 137     differentiate between the several system_error.
 138   * cache accepted sockets and close the old ones after a while.
 139     Depends on the previous item; difficult to achieve with firewalls
 140
 141 [datadesc]
 142   * Implement gras_datadesc_cpy to speedup things in the simulator
 143     (and allow to have several "actors" within the same unix process).
 144     For now, we mimick closely the RL even in SG. It was easier to do
 145       since the datadesc layer is unchanged, but it is not needed and
 146       hinders performance.
 147     gras_datadesc_cpy needs to provide the size of the corresponding messages, so
 148      that we can report it into the simulator.
 149   * Add a XML wire protocol alongside to the binary one (for SOAP/HTTP)
 150   * cbps:
 151     - Error handling
 152     - Regression tests
 153   * Inter-arch conversions
 154     - Port to ARM
 155     - Convert in the same buffer when size increase
 156     - Exchange (on net) structures in one shoot when possible.
 157     - Port to really exotic platforms (Cray is not IEEE ;)
 158   * datadesc_set_cste: give the value by default when receiving.
 159     - It's not transfered anymore, which is good for functions pointer.
 160   * Parsing macro
 161     - Cleanup the code (bison?)
 162     - Factorize code in union/struct field adding
 163     - Handle typedefs (needs love from DataDesc/)
 164     - Handle unions with annotate
 165     - Handle enum
 166     - Handle long long and long double
 167     - Forbid "char", allow "signed char" and "unsigned char", or user code won't be
 168       portable to ARM, at least.
 169     - Handle struct/union/enum embeeded within another container
 170       (needs modifications in DataDesc, too)
 171
 172     - Check short a, b;
 173     - Check short ***
 174     - Check struct { struct { int a } b; }
 175
 176   * gras_datadesc_import_nws?
 177
 178 [Messaging]
 179   * Other message types than oneway & RPC are possible:
 180      - forwarding request, group communication
 181   * Message priority
 182   * Message forwarding
 183   * Group communication
 184   * Message declarations in a tree manner (such as log channels)?
 185
 186 [GRASPE] (platform expender)
 187   * Tool to visualize/deploy and manage in RL
 188   * pull method of source diffusion in graspe-slave
 189
 190 [Actors] (parallelism in GRAS)
 191   * An actor is a user process.
 192     It has a highly sequential control flow from its birth until its death.
 193     The timers won't stop the current execution to branch elsewhere, they
 194     will be delayed until the actor is ready to listen. Likewise, no signal
 195     delivery. The goal is to KISS for users.
 196   * You can fork a new actor, even on remote hosts.
 197   * They are implemented as threads in RL, but this is still a distributed
 198     memory *model*. If you want to share data with another actor, send it
 199     using the message interface to explicit who's responsible of this data.
 200   * data exchange between actors placed within the same UNIX process is
 201     *implemented* by memcopy, but that's an implementation detail.
 202
 203 [Other, more general issues]
 204   * watchdog in RL (ie, while (1) { fork; exec the child, wait in father })
 205   * Allow [homogeneous] dico to be sent
 206   * Make GRAS thread safe by mutexing what needs to be
 207
 208 *
 209 * AMOK
 210 ******
 211
 212 [bandwidth]
 213   * finish this module (still missing the saturate part)
 214   * add a version guessing the appropriate datasizes automatically
 215 [other modules]
 216   * provide a way to retrieve the host load as in NWS
 217   * log control, management, dynamic token ring
 218   * a way using SSH to ask a remote host to open a socket back on me
 219