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("unsigned short int",
  66                              gras_ddt_scalar_short,
  67                              e_gras_dd_scalar_encoding_uint);
  68
  69   ddt = gras_datadesc_scalar("signed int",
  70                              gras_ddt_scalar_int,
  71                              e_gras_dd_scalar_encoding_sint);
  72   ddt = gras_datadesc_scalar("int",
  73                              gras_ddt_scalar_int,
  74                              e_gras_dd_scalar_encoding_sint);
  75   ddt = gras_datadesc_scalar("unsigned int",
  76                              gras_ddt_scalar_int,
  77                              e_gras_dd_scalar_encoding_uint);
  78
  79   ddt = gras_datadesc_scalar("signed long int",
  80                              gras_ddt_scalar_long,
  81                              e_gras_dd_scalar_encoding_sint);
  82   ddt = gras_datadesc_scalar("long int",
  83                              gras_ddt_scalar_long,
  84                              e_gras_dd_scalar_encoding_sint);
  85   ddt = gras_datadesc_scalar("unsigned long int",
  86                              gras_ddt_scalar_long,
  87                              e_gras_dd_scalar_encoding_uint);
  88
  89   ddt = gras_datadesc_scalar("signed long long int",
  90                              gras_ddt_scalar_long_long,
  91                              e_gras_dd_scalar_encoding_sint);
  92   ddt = gras_datadesc_scalar("long long int",
  93                              gras_ddt_scalar_long_long,
  94                              e_gras_dd_scalar_encoding_sint);
  95   ddt = gras_datadesc_scalar("unsigned long long int",
  96                              gras_ddt_scalar_long_long,
  97                              e_gras_dd_scalar_encoding_uint);
  98
  99   ddt = gras_datadesc_scalar("data pointer",
 100                              gras_ddt_scalar_pdata,
 101                              e_gras_dd_scalar_encoding_uint);
 102   ddt = gras_datadesc_scalar("function pointer",
 103                              gras_ddt_scalar_pfunc,
 104                              e_gras_dd_scalar_encoding_uint);
 105
 106   ddt = gras_datadesc_scalar("float",
 107                              gras_ddt_scalar_float,
 108                              e_gras_dd_scalar_encoding_float);
 109   ddt = gras_datadesc_scalar("double",
 110                              gras_ddt_scalar_double,
 111                              e_gras_dd_scalar_encoding_float);
 112
 113   ddt = gras_datadesc_array_dyn("char[]",
 114                                 gras_datadesc_by_name("char"),
 115                                 _strlen_cb);
 116   ddt = gras_datadesc_ref("string",ddt);
 117
 118   /* specific datatype: the exception type (for RPC) */
 119   ddt = gras_datadesc_struct("ex_t");
 120   gras_datadesc_struct_append(ddt,"msg",gras_datadesc_by_name("string"));
 121   gras_datadesc_struct_append(ddt,"category",gras_datadesc_by_name("int"));
 122   gras_datadesc_struct_append(ddt,"value",gras_datadesc_by_name("int"));
 123
 124   gras_datadesc_struct_append(ddt,"remote",gras_datadesc_by_name("short int"));
 125
 126   gras_datadesc_struct_append(ddt,"host",gras_datadesc_by_name("string"));
 127   gras_datadesc_struct_append(ddt,"procname",gras_datadesc_by_name("string"));
 128   gras_datadesc_struct_append(ddt,"pid",gras_datadesc_by_name("long int"));
 129   gras_datadesc_struct_append(ddt,"file",gras_datadesc_by_name("string"));
 130   gras_datadesc_struct_append(ddt,"line",gras_datadesc_by_name("int"));
 131   gras_datadesc_struct_append(ddt,"func",gras_datadesc_by_name("string"));
 132   gras_datadesc_struct_append(ddt,"used",gras_datadesc_by_name("int"));
 133   gras_datadesc_cb_field_push(ddt,"used");
 134   gras_datadesc_struct_append(ddt,"bt_strings",
 135                               gras_datadesc_ref_pop_arr(gras_datadesc_by_name("string")));
 136
 137   gras_datadesc_struct_close(ddt);
 138
 139   /* specific datatype: xbt_peer_t */
 140   ddt = gras_datadesc_struct("s_xbt_peer_t");
 141   gras_datadesc_struct_append(ddt,"name",gras_datadesc_by_name("string"));
 142   gras_datadesc_struct_append(ddt,"port",gras_datadesc_by_name("int"));
 143   gras_datadesc_struct_close(ddt);
 144
 145   ddt = gras_datadesc_ref("xbt_peer_t",ddt);
 146
 147   /* Dict containing the constant value (for the parsing macro) */
 148   gras_dd_constants = xbt_dict_new();
 149
 150 }
 151
 152 /**
 153  * gras_datadesc_exit:
 154  *
 155  * Finalize the datadesc module
 156  **/
 157 void
 158 gras_datadesc_exit(void) {
 159   VERB0("Exiting DataDesc");
 160   xbt_set_free(&gras_datadesc_set_local);
 161   xbt_dict_free(&gras_dd_constants);
 162   DEBUG0("Exited DataDesc");
 163 }
 164
 165 /** This is mainly to debug */
 166 const char *
 167 gras_datadesc_get_name(gras_datadesc_type_t ddt) {
 168   return ddt?(const char*)ddt->name:"(null)";
 169 }
 170 /** This is mainly to debug */
 171 int
 172 gras_datadesc_get_id(gras_datadesc_type_t ddt) {
 173   return ddt->code;
 174 }
 175
 176 /**
 177  * gras_datadesc_size:
 178  *
 179  * Returns the size occuped by data of this type (on the current arch).
 180  *
 181  */
 182 int gras_datadesc_size(gras_datadesc_type_t type) {
 183   return type?type->size[GRAS_THISARCH]:0;
 184 }
 185
 186 /**
 187  * gras_datadesc_type_dump:
 188  *
 189  * For debugging purpose
 190  */
 191 void gras_datadesc_type_dump(const gras_datadesc_type_t ddt){
 192   int cpt;
 193
 194   printf("DataDesc dump:");
 195   if(!ddt) {
 196     printf("(null)\n");
 197     return;
 198   }
 199   printf ("%s (ID:%d)\n",ddt->name,ddt->code);
 200   printf ("  category: %s\n",gras_datadesc_cat_names[ddt->category_code]);
 201
 202   printf ("  size[");
 203   for (cpt=0; cpt<gras_arch_count; cpt++) {
 204     printf("%s%s%ld%s",
 205            cpt>0?", ":"",
 206            cpt == GRAS_THISARCH ? ">":"",
 207            ddt->size[cpt],
 208            cpt == GRAS_THISARCH ? "<":"");
 209   }
 210   printf ("]\n");
 211
 212   printf ("  alignment[");
 213   for (cpt=0; cpt<gras_arch_count; cpt++) {
 214     printf("%s%s%ld%s",
 215            cpt>0?", ":"",
 216            cpt == GRAS_THISARCH ? ">":"",
 217            ddt->alignment[cpt],
 218            cpt == GRAS_THISARCH ? "<":"");
 219   }
 220   printf ("]\n");
 221
 222   printf ("  aligned_size[");
 223   for (cpt=0; cpt<gras_arch_count; cpt++) {
 224     printf("%s%s%ld%s",
 225            cpt>0?", ":"",
 226            cpt == GRAS_THISARCH ? ">":"",
 227            ddt->aligned_size[cpt],
 228            cpt == GRAS_THISARCH ? "<":"");
 229   }
 230   printf ("]\n");
 231   if (ddt->category_code == e_gras_datadesc_type_cat_struct) {
 232     gras_dd_cat_struct_t struct_data;
 233     gras_dd_cat_field_t  field;
 234
 235     struct_data = ddt->category.struct_data;
 236     xbt_dynar_foreach(struct_data.fields, cpt, field) {
 237     printf(">>> Dump field #%d (%s) (offset=%ld)\n",
 238            cpt,field->name,field->offset[GRAS_THISARCH]);
 239     gras_datadesc_type_dump(field->type);
 240     printf("<<< end dump field #%d (%s)\n",cpt,field->name);
 241     }
 242  }
 243   fflush(stdout);
 244 }