From: mquinson Date: Tue, 6 Apr 2004 22:00:22 +0000 (+0000) Subject: ignorable changes (?) X-Git-Tag: v3.3~5280 X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/60c3ee0101748158fb267e81969d322f54e36ee5 ignorable changes (?) git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@66 48e7efb5-ca39-0410-a469-dd3cf9ba447f --- diff --git a/cruft/doc/tmpl/gras-unused.sgml b/cruft/doc/tmpl/gras-unused.sgml index 870fad03a8..0fa4acbfbc 100644 --- a/cruft/doc/tmpl/gras-unused.sgml +++ b/cruft/doc/tmpl/gras-unused.sgml @@ -1,3 +1,141 @@ + +In order to allow GRAS to send data over the network (or simply to +dupplicate it in SG), you have to describe the structure of data attached +with each message. This mecanism is stolen from NWS message passing +interface. + +For each message, you have to declare a structure representing the +data to send as payload with the message. + + + Sending (or receiving) simple structures + Let's imagin you want to declare a STORE_STATE + message, which will send some data to the memory server for inclusion in + the database. Here is the structure we want to send: + + + struct state { + char id[STATE_NAME_SIZE]; + int rec_size; + int rec_count; + double seq_no; + double time_out; + }; + + + And here is the structure description GRAS needs to be able to send + this over the network: + + + const static DataDescriptor stateDescriptor[] = + {SIMPLE_MEMBER(CHAR_TYPE, STATE_NAME_SIZE, offsetof(struct state, id)), + SIMPLE_MEMBER(INT_TYPE, 1, offsetof(struct state, rec_size)), + SIMPLE_MEMBER(INT_TYPE, 1, offsetof(struct state, rec_count)), + SIMPLE_MEMBER(DOUBLE_TYPE, 1, offsetof(struct state, seq_no)), + SIMPLE_MEMBER(DOUBLE_TYPE, 1, offsetof(struct state, time_out))}; + + + Contrary to what one could think when you first see it, it's pretty + easy. A structure descriptor is a list of descriptions, describing each + field of the structure. For example, for the first field, you say that + the base type is CHAR_TYPE, that there is + STATE_NAME_SIZE element of this type and that it's + position in the structure is computed by offsetof(struct state, + id). This leads to two remarks: + + + + it's impossible to send dynamic sized strings that way. It's a + known limitation, but I think we can live with it. + + + Yes, the offsetof(struct state, id) + construction is C ANSI and is portable. + + + + + + Sending (or receiving) complex structure + How to send non-flat structures, do you ask? It's not harder. Let's + imagin you want to send the following structure: + + + typedef struct { + unsigned long address; + unsigned long port; + } CliqueMember; + + typedef struct { + char name[MAX_CLIQUE_NAME_SIZE]; + double whenGenerated; + double instance; + char skill[MAX_SKILL_SIZE]; + char options[MAX_OPTIONS_SIZE]; + double period; + double timeOut; + CliqueMember members[MAX_MEMBERS]; + unsigned int count; + unsigned int leader; + } Clique; + + + As you can see, this structure contains an array of another user + defined structure. To be able to send struct Clique, + you have to describe each structures that way: + + + static const DataDescriptor cliqueMemberDescriptor[] = + {SIMPLE_MEMBER(UNSIGNED_LONG_TYPE, 1, offsetof(CliqueMember, address)), + SIMPLE_MEMBER(UNSIGNED_LONG_TYPE, 1, offsetof(CliqueMember, port))}; + + static const DataDescriptor cliqueDescriptor[] = + {SIMPLE_MEMBER(CHAR_TYPE, MAX_CLIQUE_NAME_SIZE, offsetof(Clique, name)), + SIMPLE_MEMBER(DOUBLE_TYPE, 1, offsetof(Clique, whenGenerated)), + SIMPLE_MEMBER(DOUBLE_TYPE, 1, offsetof(Clique, instance)), + SIMPLE_MEMBER(CHAR_TYPE, MAX_SKILL_SIZE, offsetof(Clique, skill)), + SIMPLE_MEMBER(CHAR_TYPE, MAX_OPTIONS_SIZE, offsetof(Clique, options)), + SIMPLE_MEMBER(DOUBLE_TYPE, 1, offsetof(Clique, period)), + SIMPLE_MEMBER(DOUBLE_TYPE, 1, offsetof(Clique, timeOut)), + {STRUCT_TYPE, MAX_MEMBERS, offsetof(Clique, members), + (DataDescriptor *)&cliqueMemberDescriptor, cliqueMemberDescriptorLength, + PAD_BYTES(CliqueMember, port, unsigned long, 1)}, + SIMPLE_MEMBER(UNSIGNED_INT_TYPE, 1, offsetof(Clique, count)), + SIMPLE_MEMBER(UNSIGNED_INT_TYPE, 1, offsetof(Clique, leader))}; + + + So, even if less natural, it is possible to send structures + containing structures with these tools. + + You can see that it's not only impossible to send dynamic-sized + strings, it impossible to send dynamic-sized arrays. Here, + MAX_MEMBERS is the maximum of members a clique can + contain. In NWS, this value is defined to 100. I'm not + sure, but I think that all the 100 values are sent each time, even if + there is only 3 non-null members. Yes, that's + bad. + + The DataDescriptor_t MUST be const. Malloc'ing them and + then casting them on argument passing IS NOT OK. This is because we get + the number of elements in the array with the sizeof(dd)/sizeof(dd[0]). + + + + + + + + + + + +Describing the data + + + +DataDescriptor API + + @@ -18,6 +156,46 @@ ErrLog + + + + + + + + + + + + + +Handling sockets + + + +Sockets API + + + + + + + + + + + + + + + + + + + +Data description callbacks persistant state + + @@ -38,6 +216,26 @@ ErrLog config + + + + + + + + + + + + + + + + + +Data description callbacks persistant state + + @@ -190,6 +388,26 @@ gras nws_comm + + + + + + + + + + + + + + + + + +Sockets + + @@ -600,6 +818,15 @@ nws_comm @timeOut: @Returns: + + + + + +@sock: +@waitForPeer: +@Returns: + @@ -618,6 +845,33 @@ nws_comm @sock: @Returns: + + + + + +@description: +@length: +@format: +@Returns: + + + + + + +@CHAR_TYPE: +@DOUBLE_TYPE: +@FLOAT_TYPE: +@INT_TYPE: +@LONG_TYPE: +@SHORT_TYPE: +@UNSIGNED_INT_TYPE: +@UNSIGNED_LONG_TYPE: +@UNSIGNED_SHORT_TYPE: +@STRUCT_TYPE: +@LAST_TYPE: + @@ -641,6 +895,14 @@ nws_comm @earPort: @Returns: + + + + + +@HOST_FORMAT: +@NETWORK_FORMAT: + @@ -899,6 +1161,16 @@ nws_comm + + + + + +@structType: +@lastMember: +@memberType: +@repetitions: + @@ -932,6 +1204,23 @@ nws_comm @sd: @Returns: + + + + + +@type: +@repetitions: + + + + + + +@type: +@repetitions: +@offset: + @@ -1274,6 +1563,15 @@ nws_comm @ud: + + + + + +@dd: +@c: +@data: + @@ -1301,6 +1599,13 @@ nws_comm @whereto: @Returns: + + + + + +@Returns: + @@ -1317,3 +1622,54 @@ nws_comm @cat: @thresholdPriority: + + + + + +@host: +@Param2: +@sock: +@Returns: + + + + + + +@sock: +@Returns: + + + + + + +@sd: +@Returns: + + + + + + +@sd: +@Returns: + + + + + + +@Param1: +@Param2: +@sock: +@Returns: + + + + + + +@Returns: + diff --git a/cruft/doc/tmpl/gras_private.sgml b/cruft/doc/tmpl/gras_private.sgml index 4803e61ef7..170da1192e 100644 --- a/cruft/doc/tmpl/gras_private.sgml +++ b/cruft/doc/tmpl/gras_private.sgml @@ -14,22 +14,6 @@ gras_private - - - - - -@Returns: - - - - - - - -@Returns: - - @@ -39,24 +23,19 @@ gras_private @size: - - - - - -@HOST_FORMAT: -@NETWORK_FORMAT: - +@d1: +@d2: +@Returns: + @dd1: @c1: @dd2: @c2: -@Returns: diff --git a/cruft/doc/tmpl/gras_rl.sgml b/cruft/doc/tmpl/gras_rl.sgml index b16aa9e989..65544a5c6c 100644 --- a/cruft/doc/tmpl/gras_rl.sgml +++ b/cruft/doc/tmpl/gras_rl.sgml @@ -38,17 +38,6 @@ Implementation of GRAS suited for real life. @sourceFormat: - - - - - -@description: -@length: -@format: -@Returns: - - diff --git a/cruft/doc/tmpl/gras_sg.sgml b/cruft/doc/tmpl/gras_sg.sgml index fe69bc5484..925dc0bd64 100644 --- a/cruft/doc/tmpl/gras_sg.sgml +++ b/cruft/doc/tmpl/gras_sg.sgml @@ -73,13 +73,3 @@ sgml-local-ecat-files:nil End: --> - - - - - -@sock: -@waitForPeer: -@Returns: - -