TODO

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