TODO

   1 [sorry for the parts in french :]
   2
   3 ###
   4 ### Avant 0.5
   5 ###
   6
   7 - tcp->incoming_socks
   8   sock specific tcp (buffsize) inutile
   9
  10 ###
  11 ### Avant 1.0
  12 ###
  13
  14 - gras_os_getload
  15
  16 - gras_datadesc_import_nws
  17
  18 - rawsock
  19   Verifier que les messages vont pas sur des sock raw
  20
  21 - Documentation (en particulier DD et Msg)
  22
  23 - gras_datadesc_cpy -> donne la taille prise pour donner un poids aux messages
  24
  25 - callback en reception ?? (remettre les pointeurs sur fonction etc)
  26
  27 - Virer cat ignored
  28   gras_ddt_new_ignored : Pas portable (taille) => virer cat?
  29   Necessaire aux pointeurs sur fonction? Renomer 'void'
  30
  31 ###
  32 ### Apres
  33 ###
  34
  35 - Adaptative timeout
  36 - datadesc_set_cste: Donne la valeur par defaut en reception
  37   plus de transfert, ce qui est utile pour les pointeurs sur fct
  38
  39 ============================================================================
  40
  41 * while (1) { fork; exec the child, wait in father }
  42 * message forwarding
  43
  44  - core ok (errors, logs ; dynars, dicts, hooks, pools; config, rrdb)
  45  - virtualize (linux, solaris, SG) & conditions
  46  - binary representation: any type, SNWF (Sender Native Wire Format)
  47  - modules (logs, manage, token ring, bw)
  48  - cleanups, documentation
  49
  50 [autoconf]
  51   Check in autoconf that no datatype is bigger than 64, or dynar_map will
  52     get into trouble...
  53
  54 [portability layer]
  55   Dynar of type, such as ref of type
  56   Generate convertors in assembler ?
  57   Mallocators
  58
  59 [Messaging]
  60   Message forwarding
  61   Message priority
  62   Message declarations in a tree manner
  63
  64 [errors]
  65   Better split casual errors from programing errors.
  66     The first ones should be repported to the user, the second should kill
  67     the program (or, yet better, only the msg handler)
  68   Allows the use of an error handler depending on the current module (ie,
  69    the same philosophy than log4c using GSL's error functions)
  70   Rethink the error codes. Source of inspirations are:
  71    - comerr (common error reporting from ext2)
  72    - libgpg-error
  73
  74 [logs]
  75   Several appenders; fix the setting stuff to change the appender
  76   Hijack message from a given category to another for a while (to mask
  77     initializations, and more)
  78   Allow each process in simulation to have its own setting
  79
  80 [dict]
  81   dichotomie in search
  82   speed up the cursors, for example using the contexts when available
  83   fix multi levels dicts
  84
  85 [datadesc]
  86   Error handling in cbps
  87   Regression tests of cbps
  88
  89 *********
  90 * GRAS1 * Integrer grassouillet a gras; multiplexage XML; module de comm
  91 *********
  92
  93 [simuler le select sur les sockets avec des threads]
  94   Le plan, c'est qu'a l'ouverture d'une socket server, on cree un thread
  95     charge de faire du pool blocant dessus, et des que ce thread se debloque
  96     car il commence a lire qqch, il passe la main a un thread de
  97     communication charge de faire la lecture.
  98   Quand la lecture est finie, le thread de comm passe la main aux threads
  99     d'execution (un par couleur).
 100
 101   Voici comment faire le coeur du truc [dixit Olivier]:
 102     Une liste est utilisee pour stocker ce que le thread de comm a le droit
 103       de lire. Elle est protegee par mutex pour eviter les acces concurents.
 104       c'est la "liste de lecture"
 105     Une semaphore "de lecture" est utilisee pour permettre aux threads
 106       servants des sockets de prevenir le thread de comm qu'ils ont qqch
 107       pour lui
 108     Dans la liste de lecture, on place les messages en cours de creation, et
 109       un ptit mutex pour que le thread de comm dise aux threads servants de
 110       retourner ecouter la socket car il a fini
 111     Chaque couleur a sa file de callback a appeller, proteger par semaphore
 112       et un mutex comme pour la file de lecture
 113
 114     Init:
 115      initialisation de toutes les semaphore a 0
 116      comm: sem_P(semaphore lecture)
 117      couleur: sem_P(semaphore de la couleur correspondante)
 118      servant: read (1) sur la socket
 119
 120     Arrive d'un message
 121      servant:
 122      1) le read debloque (c'est la version de gras, utilisee pour multiplexe
 123         sur le XML, ou sur les differentes versions de gras/de pilote reseau)
 124      2) Allocation du message vide pour contenir ce qui s'annonce
 125      3) initialisation du mutex du message_instance a 0 (verrouille)
 126      4) placement du message instance dans la file (prise de mutex,
 127         placement, lachage de mutex)
 128      5) sem_V(sempahore)
 129      6) mutex_lock sur le mutex_verrouille
 130      sleep
 131      7) quand on revient, on rebloque un read(1), et on recommence
 132
 133      comm:
 134      1) on se reveille quand la semaphore se libere (etape 6 des servants)
 135      2) prise d'une tache dans la file (protegee par semaphore)
 136      3) lecture de l'instance de message
 137      4) lache le mutex dans l'instance pour liberer le servant
 138      5) pose le message pret dans la file de la couleur correpondant au
 139         premier callback de la pile pour ces {messageID x version} et
 140         augmente le semaphore correspondant.
 141      6) se rebloque sur le semaphore de lecture et recommence
 142
 143      couleur:
 144      1) on se reveille quand quelqu'un a pose qqch dans sa file des messages
 145         prets
 146      2) on le retire de la file
 147      3) on acquiere le mutex d'execution de sa couleur (pour les callbacks
 148         cameleon)
 149      4) on execute le callback qu'il faut
 150      5) on lache le mutex de sa couleur
 151      Si le callback annonce avoir mange le message
 152        a) on libere le message (le payload doit avoir ete libere par
 153           l'utilisateur)
 154        b) on decremente le TTL du callback, et on le vire si c'etait pas un
 155           callback infini et qu'il arrive en fin de vie
 156      Sinon
 157        a) on place le message dans la liste des messages de la couleur du
 158           suivant dans la pile des callback
 159      6) On se rendort sur le semaphore de sa couleur et recommence
 160
 161     Emission d'un message:
 162      A faire. Le thread de comm peut faire ceci, ou on peut faire un nouveau
 163       thread de comm pour cela.
 164
 165     Fermeture d'une socket client:
 166      Probleme: faut tuer le thread servant.
 167      Solution pour l'instant: fermer la socket depuis ailleurs.
 168      Solution si ca marche pas (ou pas partout): Les servants font des
 169       selects sur un pool {leur socket x un pipe fait pour}
 170       Quand qqch arrive sur le pipe, c'est le signal du suicide.
 171
 172 [Conversions inter-architectures]
 173  Convert in the same buffer when size increase
 174  Exchange structures in one shoot.
 175  Port to really exotic platforms (Cray is not IEEE ;)
 176  Generate the convertion functions in assembly, since we have a plenty of
 177    time to waste.
 178
 179 [XML]
 180  Do what is written in the paper
 181
 182 [Macro parseuse]
 183  Gerer les typedefs (necessite de l'aide de grassouillet)
 184  Gerer les pointeurs.
 185    Faut des annotations pour dire si c'est :
 186     - un AZT
 187     - un tableau dont la longueur est ailleurs dans la struct
 188     - une ref
 189    Ca peut se faire soit avec des commentaires, soit avec des macros se
 190      reecrivant a rien dans la vraie vie, et parsee. Mais le risque est que
 191      ces macros soient reecrites avant d'etre passee a mon bordel, selon les
 192      cpp.
 193  Gerer les unions => specifier des annotations, mais j'y crois pas
 194  Gerer les enum
 195  Gerer les long long
 196  Gerer les types struct, union et enum anonymes au milieu d'un autre bloc de
 197   donnees.
 198  Verifier que "char"="signed char" sur toutes les archis
 199
 200  Renomer gs_parse_tok_num en gs_parse_token
 201  Check short a, b;
 202  Check short ***
 203  Check struct { struct { int a } b; }
 204
 205 [Grassouillet]
 206  Gerer les typedefs pour aliaser un type sur un autre
 207  Merger gs_type_union_append_field et gs_type_struc_append_field si possible.
 208  Gerer les enum ?
 209  gs_type_copy/gs_type_free
 210  A quoi sert le champ name de gs_type_struct_append_field ?
 211  Ca plante bizarement si on met une structure n'existant pas dans le
 212    message (a l'usage)
 213  gs_type_dump, nardin, comment voir ce qui se passe sinon ??
 214
 215 [Autres]
 216  Faire toutes les modifs aux Utils listees plus haut
 217  Simplifier l'envoi de dynar et dico
 218  Mettre les mutex et semaphores dans les dynar directement
 219  Tenter (politiquement) le passage a GPL, pour voler du code.
 220
 221
 222 ************
 223 * La suite *
 224 ************
 225 GRAS double (ou encore "GRAS too" ou "too GRAS"):
 226  - Priorite des messages
 227  - Outils de visu pour ce qui se passe dans le simulo
 228  - Outils de visu/deployement/management pour RL
 229
 230 GRAS (très):
 231  - outils mathematiques pour dire des choses sur la validite du protocole
 232