tools/gras/s_smx_simcall_t

   1 typedef struct s_smx_simcall {
   2   e_smx_simcall_t call;
   3   smx_process_t issuer;
   4
   5   union {
   6
   7     struct {
   8       const char *name;
   9       smx_host_t result;
  10     } host_get_by_name;
  11
  12     struct {
  13       smx_host_t host;
  14       const char* result;
  15     } host_get_name;
  16
  17     struct {
  18       smx_host_t host;
  19       xbt_dict_t result;
  20     } host_get_properties;
  21
  22     struct {
  23       smx_host_t host;
  24       double result;
  25     } host_get_speed;
  26
  27     struct {
  28       smx_host_t host;
  29       double result;
  30     } host_get_available_speed;
  31
  32     struct {
  33       smx_host_t host;
  34       int result;
  35     } host_get_state;
  36
  37     struct {
  38       smx_host_t host;
  39       void* result;
  40     } host_get_data;
  41
  42     struct {
  43       smx_host_t host;
  44       void* data;
  45     } host_set_data;
  46
  47     struct {
  48       const char* name;
  49       smx_host_t host;
  50       double computation_amount;
  51       double priority;
  52       smx_action_t result;
  53     } host_execute;
  54
  55     struct {
  56       const char *name;
  57       int host_nb;
  58       smx_host_t *host_list;
  59       double *computation_amount;
  60       double *communication_amount;
  61       double amount;
  62       double rate;
  63       smx_action_t result;
  64     } host_parallel_execute;
  65
  66     struct {
  67       smx_action_t execution;
  68     } host_execution_destroy;
  69
  70     struct {
  71       smx_action_t execution;
  72     } host_execution_cancel;
  73
  74     struct {
  75       smx_action_t execution;
  76       double result;
  77     } host_execution_get_remains;
  78
  79     struct {
  80       smx_action_t execution;
  81       e_smx_state_t result;
  82     } host_execution_get_state;
  83
  84     struct {
  85       smx_action_t execution;
  86       double priority;
  87     } host_execution_set_priority;
  88
  89     struct {
  90       smx_action_t execution;
  91       e_smx_state_t result;
  92     } host_execution_wait;
  93
  94     struct {
  95       smx_process_t *process;
  96       const char *name;
  97       xbt_main_func_t code;
  98       void *data;
  99       const char *hostname;
 100       int argc;
 101       char **argv;
 102       xbt_dict_t properties;
 103     } process_create;
 104
 105     struct {
 106       smx_process_t process;
 107     } process_kill;
 108
 109     struct {
 110       smx_process_t process;
 111     } process_cleanup;
 112
 113     struct {
 114       smx_process_t process;
 115       smx_host_t dest;
 116     } process_change_host;
 117
 118     struct {
 119       smx_process_t process;
 120     } process_suspend;
 121
 122     struct {
 123       smx_process_t process;
 124     } process_resume;
 125
 126     struct {
 127       int result;
 128     } process_count;
 129
 130     struct {
 131       smx_process_t process;
 132       void* result;
 133     } process_get_data;
 134
 135     struct {
 136       smx_process_t process;
 137       void* data;
 138     } process_set_data;
 139
 140     struct {
 141       smx_process_t process;
 142       smx_host_t result;
 143     } process_get_host;
 144
 145     struct {
 146       smx_process_t process;
 147       const char *result;
 148     } process_get_name;
 149
 150     struct {
 151       smx_process_t process;
 152       int result;
 153     } process_is_suspended;
 154
 155     struct {
 156       smx_process_t process;
 157       xbt_dict_t result;
 158     } process_get_properties;
 159
 160     struct {
 161       double duration;
 162       e_smx_state_t result;
 163     } process_sleep;
 164
 165     struct {
 166       const char *name;
 167       smx_rdv_t result;
 168     } rdv_create;
 169
 170     struct {
 171       smx_rdv_t rdv;
 172     } rdv_destroy;
 173
 174     struct {
 175       const char* name;
 176       smx_rdv_t result;
 177     } rdv_get_by_name;
 178
 179     struct {
 180       smx_rdv_t rdv;
 181       smx_host_t host;
 182       unsigned int result;
 183     } rdv_comm_count_by_host;
 184
 185     struct {
 186       smx_rdv_t rdv;
 187       smx_action_t result;
 188     } rdv_get_head;
 189
 190     struct {
 191       smx_rdv_t rdv;
 192       double task_size;
 193       double rate;
 194       void *src_buff;
 195       size_t src_buff_size;
 196       int (*match_fun)(void *, void *);
 197       void *data;
 198       double timeout;
 199     } comm_send;
 200
 201     struct {
 202       smx_rdv_t rdv;
 203       double task_size;
 204       double rate;
 205       void *src_buff;
 206       size_t src_buff_size;
 207       int (*match_fun)(void *, void *);
 208       void (*clean_fun)(void *);
 209       void *data;
 210       int detached;
 211       smx_action_t result;
 212     } comm_isend;
 213
 214     struct {
 215       smx_rdv_t rdv;
 216       void *dst_buff;
 217       size_t *dst_buff_size;
 218       int (*match_fun)(void *, void *);
 219       void *data;
 220       double timeout;
 221     } comm_recv;
 222
 223     struct {
 224       smx_rdv_t rdv;
 225       void *dst_buff;
 226       size_t *dst_buff_size;
 227       int (*match_fun)(void *, void *);
 228           void *data;
 229       smx_action_t result;
 230     } comm_irecv;
 231
 232     struct {
 233       smx_action_t comm;
 234     } comm_destroy;
 235
 236     struct {
 237       smx_action_t comm;
 238     } comm_cancel;
 239
 240     struct {
 241       xbt_dynar_t comms;
 242       unsigned int result;
 243     } comm_waitany;
 244
 245     struct {
 246       smx_action_t comm;
 247       double timeout;
 248     } comm_wait;
 249
 250     struct {
 251       smx_action_t comm;
 252       int result;
 253     } comm_test;
 254
 255     struct {
 256       xbt_dynar_t comms;
 257       int result;
 258     } comm_testany;
 259
 260     struct {
 261       smx_action_t comm;
 262       double result;
 263     } comm_get_remains;
 264
 265     struct {
 266       smx_action_t comm;
 267       e_smx_state_t result;
 268     } comm_get_state;
 269
 270     struct {
 271       smx_action_t comm;
 272       void *result;
 273     } comm_get_src_data;
 274
 275     struct {
 276       smx_action_t comm;
 277       void *result;
 278     } comm_get_dst_data;
 279
 280     struct {
 281       smx_action_t comm;
 282       smx_process_t result;
 283     } comm_get_src_proc;
 284
 285     struct {
 286       smx_action_t comm;
 287       smx_process_t result;
 288     } comm_get_dst_proc;
 289
 290     struct {
 291       smx_action_t comm;
 292       int result;
 293     } comm_is_latency_bounded;
 294
 295     struct {
 296       smx_action_t action;
 297       const char *category;
 298     } set_category;
 299
 300     struct {
 301       smx_mutex_t result;
 302     } mutex_init;
 303
 304     struct {
 305       smx_mutex_t mutex;
 306     } mutex_lock;
 307
 308     struct {
 309       smx_mutex_t mutex;
 310       int result;
 311     } mutex_trylock;
 312
 313     struct {
 314       smx_mutex_t mutex;
 315     } mutex_unlock;
 316
 317     struct {
 318       smx_mutex_t mutex;
 319     } mutex_destroy;
 320
 321     struct {
 322       smx_cond_t result;
 323     } cond_init;
 324
 325     struct {
 326       smx_cond_t cond;
 327     } cond_destroy;
 328
 329     struct {
 330       smx_cond_t cond;
 331     } cond_signal;
 332
 333     struct {
 334       smx_cond_t cond;
 335       smx_mutex_t mutex;
 336     } cond_wait;
 337
 338     struct {
 339       smx_cond_t cond;
 340       smx_mutex_t mutex;
 341       double timeout;
 342     } cond_wait_timeout;
 343
 344     struct {
 345       smx_cond_t cond;
 346     } cond_broadcast;
 347
 348     struct {
 349       int capacity;
 350       smx_sem_t result;
 351     } sem_init;
 352
 353     struct {
 354       smx_sem_t sem;
 355     } sem_destroy;
 356
 357     struct {
 358       smx_sem_t sem;
 359     } sem_release;
 360
 361     struct {
 362       smx_sem_t sem;
 363       int result;
 364     } sem_would_block;
 365
 366     struct {
 367       smx_sem_t sem;
 368     } sem_acquire;
 369
 370     struct {
 371       smx_sem_t sem;
 372       double timeout;
 373     } sem_acquire_timeout;
 374
 375     struct {
 376       smx_sem_t sem;
 377       int result;
 378     } sem_get_capacity;
 379
 380     struct {
 381       const char* storage;
 382       void *ptr;
 383       size_t size;
 384       size_t nmemb;
 385       m_file_t stream;
 386       size_t result;
 387     } file_read;
 388
 389     struct {
 390       const char* storage;
 391       const void *ptr;
 392       size_t size;
 393       size_t nmemb;
 394       m_file_t stream;
 395       size_t result;
 396     } file_write;
 397
 398     struct {
 399       const char* storage;
 400       const char* path;
 401       const char* mode;
 402       m_file_t result;
 403     } file_open;
 404
 405     struct {
 406       const char* storage;
 407       m_file_t fp;
 408       int result;
 409     } file_close;
 410
 411     struct {
 412       const char* storage;
 413       int fd;
 414       //Next should be struct stat* buf
 415       void* buf;
 416       int result;
 417     } file_stat;
 418
 419   };
 420 } s_smx_simcall_t, *smx_simcall_t;
 421
 422
 423
 424