src/gras/DataDesc/datadesc.c

   1 /* $Id$ */
   2
   3 /* datadesc - data description in order to send/recv it in GRAS             */
   4
   5 /* Copyright (c) 2003 Olivier Aumage.                                       */
   6 /* Copyright (c) 2003, 2004 Martin Quinson.                                 */
   7 /* All rights reserved.                                                     */
   8
   9 /* This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the license (GNU LGPL) which comes with this package. */
  11
  12 #include "gras/DataDesc/datadesc_private.h"
  13
  14 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(gras_ddt,gras,"Data description");
  15 /* FIXME: make this host-dependent using a trick such as UserData*/
  16 /*@null@*/xbt_set_t gras_datadesc_set_local=NULL;
  17
  18
  19 /* callback for array size when sending strings */
  20 static int
  21 _strlen_cb(/*@unused@*/gras_datadesc_type_t type,/*@unused@*/gras_cbps_t vars, void *data) {
  22
  23         return 1+(int)strlen(data);
  24 }
  25
  26
  27 /**
  28  * gras_datadesc_init:
  29  *
  30  * Initialize the datadesc module.
  31  * FIXME: We assume that when neither signed nor unsigned is given,
  32  *    that means signed. To be checked by configure.
  33  **/
  34 void
  35 gras_datadesc_init(void) {
  36         gras_datadesc_type_t ddt; /* What to add */
  37
  38         /* only initialize once */
  39         if (gras_datadesc_set_local != NULL)
  40                 return;
  41
  42         VERB0("Initializing DataDesc");
  43
  44         gras_datadesc_set_local = xbt_set_new();
  45
  46
  47         /* all known datatypes */
  48
  49         ddt = gras_datadesc_scalar("signed char",
  50                         gras_ddt_scalar_char,
  51                         e_gras_dd_scalar_encoding_sint);
  52         ddt = gras_datadesc_scalar("char",
  53                         gras_ddt_scalar_char,
  54                         e_gras_dd_scalar_encoding_sint);
  55         ddt = gras_datadesc_scalar("unsigned char",
  56                         gras_ddt_scalar_char,
  57                         e_gras_dd_scalar_encoding_uint);
  58
  59         ddt = gras_datadesc_scalar("signed short int",
  60                         gras_ddt_scalar_short,
  61                         e_gras_dd_scalar_encoding_sint);
  62         ddt = gras_datadesc_scalar("short int",
  63                         gras_ddt_scalar_short,
  64                         e_gras_dd_scalar_encoding_sint);
  65         ddt = gras_datadesc_scalar("short",
  66                         gras_ddt_scalar_short,
  67                         e_gras_dd_scalar_encoding_sint);
  68         ddt = gras_datadesc_scalar("unsigned short int",
  69                         gras_ddt_scalar_short,
  70                         e_gras_dd_scalar_encoding_uint);
  71
  72         ddt = gras_datadesc_scalar("signed int",
  73                         gras_ddt_scalar_int,
  74                         e_gras_dd_scalar_encoding_sint);
  75         ddt = gras_datadesc_scalar("int",
  76                         gras_ddt_scalar_int,
  77                         e_gras_dd_scalar_encoding_sint);
  78         ddt = gras_datadesc_scalar("unsigned int",
  79                         gras_ddt_scalar_int,
  80                         e_gras_dd_scalar_encoding_uint);
  81
  82         ddt = gras_datadesc_scalar("signed long int",
  83                         gras_ddt_scalar_long,
  84                         e_gras_dd_scalar_encoding_sint);
  85         ddt = gras_datadesc_scalar("long int",
  86                         gras_ddt_scalar_long,
  87                         e_gras_dd_scalar_encoding_sint);
  88         ddt = gras_datadesc_scalar("long",
  89                         gras_ddt_scalar_long,
  90                         e_gras_dd_scalar_encoding_sint);
  91         ddt = gras_datadesc_scalar("unsigned long int",
  92                         gras_ddt_scalar_long,
  93                         e_gras_dd_scalar_encoding_uint);
  94
  95         ddt = gras_datadesc_scalar("signed long long int",
  96                         gras_ddt_scalar_long_long,
  97                         e_gras_dd_scalar_encoding_sint);
  98         ddt = gras_datadesc_scalar("long long int",
  99                         gras_ddt_scalar_long_long,
 100                         e_gras_dd_scalar_encoding_sint);
 101         ddt = gras_datadesc_scalar("unsigned long long int",
 102                         gras_ddt_scalar_long_long,
 103                         e_gras_dd_scalar_encoding_uint);
 104
 105         ddt = gras_datadesc_scalar("data pointer",
 106                         gras_ddt_scalar_pdata,
 107                         e_gras_dd_scalar_encoding_uint);
 108         ddt = gras_datadesc_scalar("function pointer",
 109                         gras_ddt_scalar_pfunc,
 110                         e_gras_dd_scalar_encoding_uint);
 111
 112         ddt = gras_datadesc_scalar("float",
 113                         gras_ddt_scalar_float,
 114                         e_gras_dd_scalar_encoding_float);
 115         ddt = gras_datadesc_scalar("double",
 116                         gras_ddt_scalar_double,
 117                         e_gras_dd_scalar_encoding_float);
 118
 119         ddt = gras_datadesc_array_dyn("char[]",
 120                         gras_datadesc_by_name("char"),
 121                         _strlen_cb);
 122         gras_datadesc_ref("string",ddt);
 123         gras_datadesc_ref("xbt_string_t",ddt);
 124
 125         /* specific datatype: the exception type (for RPC) */
 126         ddt = gras_datadesc_struct("ex_t");
 127         gras_datadesc_struct_append(ddt,"msg",gras_datadesc_by_name("string"));
 128         gras_datadesc_struct_append(ddt,"category",gras_datadesc_by_name("int"));
 129         gras_datadesc_struct_append(ddt,"value",gras_datadesc_by_name("int"));
 130
 131         gras_datadesc_struct_append(ddt,"remote",gras_datadesc_by_name("short int"));
 132
 133         gras_datadesc_struct_append(ddt,"host",gras_datadesc_by_name("string"));
 134         gras_datadesc_struct_append(ddt,"procname",gras_datadesc_by_name("string"));
 135         gras_datadesc_struct_append(ddt,"pid",gras_datadesc_by_name("long int"));
 136         gras_datadesc_struct_append(ddt,"file",gras_datadesc_by_name("string"));
 137         gras_datadesc_struct_append(ddt,"line",gras_datadesc_by_name("int"));
 138         gras_datadesc_struct_append(ddt,"func",gras_datadesc_by_name("string"));
 139         gras_datadesc_struct_append(ddt,"used",gras_datadesc_by_name("int"));
 140         gras_datadesc_cb_field_push(ddt,"used");
 141         gras_datadesc_struct_append(ddt,"bt_strings",
 142                         gras_datadesc_ref_pop_arr(gras_datadesc_by_name("string")));
 143
 144         gras_datadesc_struct_close(ddt);
 145
 146         /* specific datatype: xbt_peer_t */
 147         ddt = gras_datadesc_struct("s_xbt_peer_t");
 148         gras_datadesc_struct_append(ddt,"name",gras_datadesc_by_name("string"));
 149         gras_datadesc_struct_append(ddt,"port",gras_datadesc_by_name("int"));
 150         gras_datadesc_struct_close(ddt);
 151
 152         ddt = gras_datadesc_ref("xbt_peer_t",ddt);
 153
 154         /* Dict containing the constant value (for the parsing macro) */
 155         gras_dd_constants = xbt_dict_new();
 156
 157 }
 158
 159 /**
 160  * gras_datadesc_exit:
 161  *
 162  * Finalize the datadesc module
 163  **/
 164 void
 165 gras_datadesc_exit(void) {
 166         VERB0("Exiting DataDesc");
 167         xbt_set_free(&gras_datadesc_set_local);
 168         xbt_dict_free(&gras_dd_constants);
 169         DEBUG0("Exited DataDesc");
 170 }
 171
 172 /** This is mainly to debug */
 173 const char *
 174 gras_datadesc_get_name(gras_datadesc_type_t ddt) {
 175         return ddt?(const char*)ddt->name:"(null)";
 176 }
 177 /** This is mainly to debug */
 178 int
 179 gras_datadesc_get_id(gras_datadesc_type_t ddt) {
 180         return ddt->code;
 181 }
 182
 183 /**
 184  * gras_datadesc_size:
 185  *
 186  * Returns the size occuped by data of this type (on the current arch).
 187  *
 188  */
 189 int gras_datadesc_size(gras_datadesc_type_t type) {
 190         return type?type->size[GRAS_THISARCH]:0;
 191 }
 192
 193 /**
 194  * gras_datadesc_type_dump:
 195  *
 196  * For debugging purpose
 197  */
 198 void gras_datadesc_type_dump(const gras_datadesc_type_t ddt){
 199         unsigned int cpt;
 200
 201         printf("DataDesc dump:");
 202         if(!ddt) {
 203                 printf("(null)\n");
 204                 return;
 205         }
 206         printf ("%s (ID:%d)\n",ddt->name,ddt->code);
 207         printf ("  category: %s\n",gras_datadesc_cat_names[ddt->category_code]);
 208
 209         printf ("  size[");
 210         for (cpt=0; cpt<gras_arch_count; cpt++) {
 211                 printf("%s%s%ld%s",
 212                                 cpt>0?", ":"",
 213                                                 cpt == GRAS_THISARCH ? ">":"",
 214                                                                 ddt->size[cpt],
 215                                                                 cpt == GRAS_THISARCH ? "<":"");
 216         }
 217         printf ("]\n");
 218
 219         printf ("  alignment[");
 220         for (cpt=0; cpt<gras_arch_count; cpt++) {
 221                 printf("%s%s%ld%s",
 222                                 cpt>0?", ":"",
 223                                                 cpt == GRAS_THISARCH ? ">":"",
 224                                                                 ddt->alignment[cpt],
 225                                                                 cpt == GRAS_THISARCH ? "<":"");
 226         }
 227         printf ("]\n");
 228
 229         printf ("  aligned_size[");
 230         for (cpt=0; cpt<gras_arch_count; cpt++) {
 231                 printf("%s%s%ld%s",
 232                                 cpt>0?", ":"",
 233                                                 cpt == GRAS_THISARCH ? ">":"",
 234                                                                 ddt->aligned_size[cpt],
 235                                                                 cpt == GRAS_THISARCH ? "<":"");
 236         }
 237         printf ("]\n");
 238         if (ddt->category_code == e_gras_datadesc_type_cat_struct) {
 239                 gras_dd_cat_struct_t struct_data;
 240                 gras_dd_cat_field_t  field;
 241
 242                 struct_data = ddt->category.struct_data;
 243                 xbt_dynar_foreach(struct_data.fields, cpt, field) {
 244                         printf(">>> Dump field #%d (%s) (offset=%ld)\n",
 245                                         cpt,field->name,field->offset[GRAS_THISARCH]);
 246                         gras_datadesc_type_dump(field->type);
 247                         printf("<<< end dump field #%d (%s)\n",cpt,field->name);
 248                 }
 249         }
 250         fflush(stdout);
 251 }