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