src/simix/smurf_private.h

   1 /* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #ifndef _SIMIX_SMURF_PRIVATE_H
   8 #define _SIMIX_SMURF_PRIVATE_H
   9
  10 /********************************* Requests ***********************************/
  11
  12 /* we want to build the e_smx_t enumeration and the table of the corresponding
  13  * strings automatically, using macros */
  14
  15 #define SIMIX_REQ_LIST1 \
  16 SIMIX_REQ_ENUM_ELEMENT(REQ_NO_REQ),\
  17 SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_GET_BY_NAME),\
  18 SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_GET_NAME),\
  19 SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_GET_PROPERTIES),\
  20 SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_GET_SPEED),\
  21 SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_GET_AVAILABLE_SPEED),\
  22 SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_GET_STATE),\
  23 SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_GET_DATA),\
  24 SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_SET_DATA),\
  25 SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_EXECUTE),\
  26 SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_PARALLEL_EXECUTE),\
  27 SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_EXECUTION_DESTROY),\
  28 SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_EXECUTION_CANCEL),\
  29 SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_EXECUTION_GET_REMAINS),\
  30 SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_EXECUTION_GET_STATE),\
  31 SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_EXECUTION_SET_PRIORITY),\
  32 SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_EXECUTION_WAIT),\
  33 SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_CREATE),\
  34 SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_KILL),\
  35 SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_KILLALL),\
  36 SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_CLEANUP),\
  37 SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_CHANGE_HOST),\
  38 SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_SUSPEND),\
  39 SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_RESUME),\
  40 SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_COUNT),\
  41 SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_GET_DATA),\
  42 SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_SET_DATA),\
  43 SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_GET_HOST),\
  44 SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_GET_NAME),\
  45 SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_IS_SUSPENDED),\
  46 SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_GET_PROPERTIES),\
  47 SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_SLEEP),\
  48 SIMIX_REQ_ENUM_ELEMENT(REQ_RDV_CREATE),\
  49 SIMIX_REQ_ENUM_ELEMENT(REQ_RDV_DESTROY),\
  50 SIMIX_REQ_ENUM_ELEMENT(REQ_RDV_GEY_BY_NAME),\
  51 SIMIX_REQ_ENUM_ELEMENT(REQ_RDV_COMM_COUNT_BY_HOST),\
  52 SIMIX_REQ_ENUM_ELEMENT(REQ_RDV_GET_HEAD),\
  53 SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_SEND),\
  54 SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_ISEND),\
  55 SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_RECV),\
  56 SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_IRECV),\
  57 SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_DESTROY),\
  58 SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_CANCEL),\
  59 SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_WAITANY),\
  60 SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_WAIT),\
  61 SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_TEST),\
  62 SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_TESTANY),\
  63 SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_GET_REMAINS),\
  64 SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_GET_STATE),\
  65 SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_GET_SRC_DATA),\
  66 SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_GET_DST_DATA),\
  67 SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_GET_SRC_PROC),\
  68 SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_GET_DST_PROC),\
  69 SIMIX_REQ_ENUM_ELEMENT(REQ_MUTEX_INIT),\
  70 SIMIX_REQ_ENUM_ELEMENT(REQ_MUTEX_DESTROY),\
  71 SIMIX_REQ_ENUM_ELEMENT(REQ_MUTEX_LOCK),\
  72 SIMIX_REQ_ENUM_ELEMENT(REQ_MUTEX_TRYLOCK),\
  73 SIMIX_REQ_ENUM_ELEMENT(REQ_MUTEX_UNLOCK),\
  74 SIMIX_REQ_ENUM_ELEMENT(REQ_COND_INIT),\
  75 SIMIX_REQ_ENUM_ELEMENT(REQ_COND_DESTROY),\
  76 SIMIX_REQ_ENUM_ELEMENT(REQ_COND_SIGNAL),\
  77 SIMIX_REQ_ENUM_ELEMENT(REQ_COND_WAIT),\
  78 SIMIX_REQ_ENUM_ELEMENT(REQ_COND_WAIT_TIMEOUT),\
  79 SIMIX_REQ_ENUM_ELEMENT(REQ_COND_BROADCAST),\
  80 SIMIX_REQ_ENUM_ELEMENT(REQ_SEM_INIT),\
  81 SIMIX_REQ_ENUM_ELEMENT(REQ_SEM_DESTROY),\
  82 SIMIX_REQ_ENUM_ELEMENT(REQ_SEM_RELEASE),\
  83 SIMIX_REQ_ENUM_ELEMENT(REQ_SEM_WOULD_BLOCK),\
  84 SIMIX_REQ_ENUM_ELEMENT(REQ_SEM_ACQUIRE),\
  85 SIMIX_REQ_ENUM_ELEMENT(REQ_SEM_ACQUIRE_TIMEOUT),\
  86 SIMIX_REQ_ENUM_ELEMENT(REQ_SEM_GET_CAPACITY)
  87
  88 /* REQ_COMM_IS_LATENCY_BOUNDED and REQ_SET_CATEGORY make things complicated
  89  * because they are not always present */
  90 #ifdef HAVE_LATENCY_BOUND_TRACKING
  91 #define SIMIX_REQ_LIST2 \
  92 ,SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_IS_LATENCY_BOUNDED)
  93 #else
  94 #define SIMIX_REQ_LIST2
  95 #endif
  96
  97 #ifdef HAVE_TRACING
  98 #define SIMIX_REQ_LIST3 \
  99 ,SIMIX_REQ_ENUM_ELEMENT(REQ_SET_CATEGORY)
 100 #else
 101 #define SIMIX_REQ_LIST3
 102 #endif
 103
 104 /* SIMIX_REQ_LIST is the final macro to use */
 105 #define SIMIX_REQ_LIST SIMIX_REQ_LIST1 SIMIX_REQ_LIST2 SIMIX_REQ_LIST3
 106
 107 /* you can redefine the following macro differently to generate something else
 108  * with the list of enumeration values (e.g. a table of strings or a table of function pointers) */
 109 #define SIMIX_REQ_ENUM_ELEMENT(x) x
 110
 111 /**
 112  * \brief All possible SIMIX requests.
 113  */
 114 typedef enum {
 115 SIMIX_REQ_LIST
 116 } e_smx_req_t;
 117
 118 /**
 119  * \brief Represents a SIMIX request.
 120  */
 121 typedef struct s_smx_req {
 122   s_xbt_swag_hookup_t reqtable_hookup;
 123   e_smx_req_t call;
 124   smx_process_t issuer;
 125
 126   union {
 127
 128     struct {
 129       const char *name;
 130       smx_host_t result;
 131     } host_get_by_name;
 132
 133     struct {
 134       smx_host_t host;
 135       const char* result;
 136     } host_get_name;
 137
 138     struct {
 139       smx_host_t host;
 140       xbt_dict_t result;
 141     } host_get_properties;
 142
 143     struct {
 144       smx_host_t host;
 145       double result;
 146     } host_get_speed;
 147
 148     struct {
 149       smx_host_t host;
 150       double result;
 151     } host_get_available_speed;
 152
 153     struct {
 154       smx_host_t host;
 155       int result;
 156     } host_get_state;
 157
 158     struct {
 159       smx_host_t host;
 160       void* result;
 161     } host_get_data;
 162
 163     struct {
 164       smx_host_t host;
 165       void* data;
 166     } host_set_data;
 167
 168     struct {
 169       const char* name;
 170       smx_host_t host;
 171       double computation_amount;
 172       double priority;
 173       smx_action_t result;
 174     } host_execute;
 175
 176     struct {
 177       const char *name;
 178       int host_nb;
 179       smx_host_t *host_list;
 180       double *computation_amount;
 181       double *communication_amount;
 182       double amount;
 183       double rate;
 184       smx_action_t result;
 185     } host_parallel_execute;
 186
 187     struct {
 188       smx_action_t execution;
 189     } host_execution_destroy;
 190
 191     struct {
 192       smx_action_t execution;
 193     } host_execution_cancel;
 194
 195     struct {
 196       smx_action_t execution;
 197       double result;
 198     } host_execution_get_remains;
 199
 200     struct {
 201       smx_action_t execution;
 202       e_smx_state_t result;
 203     } host_execution_get_state;
 204
 205     struct {
 206       smx_action_t execution;
 207       double priority;
 208     } host_execution_set_priority;
 209
 210     struct {
 211       smx_action_t execution;
 212       e_smx_state_t result;
 213     } host_execution_wait;
 214
 215     struct {
 216       smx_process_t *process;
 217       const char *name;
 218       xbt_main_func_t code;
 219       void *data;
 220       const char *hostname;
 221       int argc;
 222       char **argv;
 223       xbt_dict_t properties;
 224     } process_create;
 225
 226     struct {
 227       smx_process_t process;
 228     } process_kill;
 229
 230     struct {
 231       smx_process_t process;
 232     } process_cleanup;
 233
 234     struct {
 235       smx_process_t process;
 236       const char *source;
 237       const char *dest;
 238     } process_change_host;
 239
 240     struct {
 241       smx_process_t process;
 242     } process_suspend;
 243
 244     struct {
 245       smx_process_t process;
 246     } process_resume;
 247
 248     struct {
 249       int result;
 250     } process_count;
 251
 252     struct {
 253       smx_process_t process;
 254       void* result;
 255     } process_get_data;
 256
 257     struct {
 258       smx_process_t process;
 259       void* data;
 260     } process_set_data;
 261
 262     struct {
 263       smx_process_t process;
 264       smx_host_t result;
 265     } process_get_host;
 266
 267     struct {
 268       smx_process_t process;
 269       const char *result;
 270     } process_get_name;
 271
 272     struct {
 273       smx_process_t process;
 274       int result;
 275     } process_is_suspended;
 276
 277     struct {
 278       smx_process_t process;
 279       xbt_dict_t result;
 280     } process_get_properties;
 281
 282     struct {
 283       double duration;
 284       e_smx_state_t result;
 285     } process_sleep;
 286
 287     struct {
 288       const char *name;
 289       smx_rdv_t result;
 290     } rdv_create;
 291
 292     struct {
 293       smx_rdv_t rdv;
 294     } rdv_destroy;
 295
 296     struct {
 297       const char* name;
 298       smx_rdv_t result;
 299     } rdv_get_by_name;
 300
 301     struct {
 302       smx_rdv_t rdv;
 303       smx_host_t host;
 304       unsigned int result;
 305     } rdv_comm_count_by_host;
 306
 307     struct {
 308       smx_rdv_t rdv;
 309       smx_action_t result;
 310     } rdv_get_head;
 311
 312     struct {
 313       smx_rdv_t rdv;
 314       double task_size;
 315       double rate;
 316       void *src_buff;
 317       size_t src_buff_size;
 318       int (*match_fun)(void *, void *);
 319       void *data;
 320       double timeout;
 321     } comm_send;
 322
 323     struct {
 324       smx_rdv_t rdv;
 325       double task_size;
 326       double rate;
 327       void *src_buff;
 328       size_t src_buff_size;
 329       int (*match_fun)(void *, void *);
 330       void *data;
 331       int detached;
 332       smx_action_t result;
 333     } comm_isend;
 334
 335     struct {
 336       smx_rdv_t rdv;
 337       void *dst_buff;
 338       size_t *dst_buff_size;
 339       int (*match_fun)(void *, void *);
 340       void *data;
 341       double timeout;
 342     } comm_recv;
 343
 344     struct {
 345       smx_rdv_t rdv;
 346       void *dst_buff;
 347       size_t *dst_buff_size;
 348       int (*match_fun)(void *, void *);
 349           void *data;
 350       smx_action_t result;
 351     } comm_irecv;
 352
 353     struct {
 354       smx_action_t comm;
 355     } comm_destroy;
 356
 357     struct {
 358       smx_action_t comm;
 359     } comm_cancel;
 360
 361     struct {
 362       xbt_dynar_t comms;
 363       unsigned int result;
 364     } comm_waitany;
 365
 366     struct {
 367       smx_action_t comm;
 368       double timeout;
 369     } comm_wait;
 370
 371     struct {
 372       smx_action_t comm;
 373       int result;
 374     } comm_test;
 375
 376     struct {
 377       xbt_dynar_t comms;
 378       int result;
 379     } comm_testany;
 380
 381     struct {
 382       smx_action_t comm;
 383       double result;
 384     } comm_get_remains;
 385
 386     struct {
 387       smx_action_t comm;
 388       e_smx_state_t result;
 389     } comm_get_state;
 390
 391     struct {
 392       smx_action_t comm;
 393       void *result;
 394     } comm_get_src_data;
 395
 396     struct {
 397       smx_action_t comm;
 398       void *result;
 399     } comm_get_dst_data;
 400
 401     struct {
 402       smx_action_t comm;
 403       smx_process_t result;
 404     } comm_get_src_proc;
 405
 406     struct {
 407       smx_action_t comm;
 408       smx_process_t result;
 409     } comm_get_dst_proc;
 410
 411 #ifdef HAVE_LATENCY_BOUND_TRACKING
 412     struct {
 413       smx_action_t comm;
 414       int result;
 415     } comm_is_latency_bounded;
 416 #endif
 417
 418 #ifdef HAVE_TRACING
 419     struct {
 420       smx_action_t action;
 421       const char *category;
 422     } set_category;
 423 #endif
 424
 425     struct {
 426       smx_mutex_t result;
 427     } mutex_init;
 428
 429     struct {
 430       smx_mutex_t mutex;
 431     } mutex_lock;
 432
 433     struct {
 434       smx_mutex_t mutex;
 435       int result;
 436     } mutex_trylock;
 437
 438     struct {
 439       smx_mutex_t mutex;
 440     } mutex_unlock;
 441
 442     struct {
 443       smx_mutex_t mutex;
 444     } mutex_destroy;
 445
 446     struct {
 447       smx_cond_t result;
 448     } cond_init;
 449
 450     struct {
 451       smx_cond_t cond;
 452     } cond_destroy;
 453
 454     struct {
 455       smx_cond_t cond;
 456     } cond_signal;
 457
 458     struct {
 459       smx_cond_t cond;
 460       smx_mutex_t mutex;
 461     } cond_wait;
 462
 463     struct {
 464       smx_cond_t cond;
 465       smx_mutex_t mutex;
 466       double timeout;
 467     } cond_wait_timeout;
 468
 469     struct {
 470       smx_cond_t cond;
 471     } cond_broadcast;
 472
 473     struct {
 474       int capacity;
 475       smx_sem_t result;
 476     } sem_init;
 477
 478     struct {
 479       smx_sem_t sem;
 480     } sem_destroy;
 481
 482     struct {
 483       smx_sem_t sem;
 484     } sem_release;
 485
 486     struct {
 487       smx_sem_t sem;
 488       int result;
 489     } sem_would_block;
 490
 491     struct {
 492       smx_sem_t sem;
 493     } sem_acquire;
 494
 495     struct {
 496       smx_sem_t sem;
 497       double timeout;
 498     } sem_acquire_timeout;
 499
 500     struct {
 501       smx_sem_t sem;
 502       int result;
 503     } sem_get_capacity;
 504   };
 505 } s_smx_req_t, *smx_req_t;
 506
 507 /******************************** General *************************************/
 508
 509 void SIMIX_request_init(void);
 510 void SIMIX_request_destroy(void);
 511 xbt_swag_t SIMIX_request_get_reqlist(int thread_pid);
 512 void SIMIX_request_push(void);
 513 smx_req_t SIMIX_request_pop(void);
 514 void SIMIX_request_answer(smx_req_t);
 515 void SIMIX_request_pre(smx_req_t, int);
 516 void SIMIX_request_post(smx_action_t);
 517 XBT_INLINE smx_req_t SIMIX_req_mine(void);
 518
 519 #endif
 520