src/simix/smx_popping_accessors.h

   1 /**********************************************************************/
   2 /* File generated by src/simix/simcalls.py from src/simix/simcalls.in */
   3 /*                                                                    */
   4 /*                    DO NOT EVER CHANGE THIS FILE                    */
   5 /*                                                                    */
   6 /* change simcalls specification in src/simix/simcalls.in             */
   7 /**********************************************************************/
   8
   9
  10 static inline const char* simcall_host_get_by_name__get__name(smx_simcall_t simcall){
  11   return  simcall->args[0].cc;
  12 }
  13
  14 static inline void simcall_host_get_by_name__set__name(smx_simcall_t simcall, const char* arg){
  15     simcall->args[0].cc = arg;
  16 }
  17 static inline smx_host_t simcall_host_get_by_name__get__result(smx_simcall_t simcall){
  18     return (smx_host_t) simcall->result.dp;
  19 }
  20 static inline void simcall_host_get_by_name__set__result(smx_simcall_t simcall, void* result){
  21     simcall->result.dp = result;
  22 }
  23
  24 static inline smx_host_t simcall_host_get_name__get__host(smx_simcall_t simcall){
  25   return (smx_host_t) simcall->args[0].dp;
  26 }
  27
  28 static inline void simcall_host_get_name__set__host(smx_simcall_t simcall, void* arg){
  29     simcall->args[0].dp = arg;
  30 }
  31 static inline const char* simcall_host_get_name__get__result(smx_simcall_t simcall){
  32     return  simcall->result.cc;
  33 }
  34 static inline void simcall_host_get_name__set__result(smx_simcall_t simcall, const char* result){
  35     simcall->result.cc = result;
  36 }
  37
  38 static inline smx_host_t simcall_host_on__get__host(smx_simcall_t simcall){
  39   return (smx_host_t) simcall->args[0].dp;
  40 }
  41
  42 static inline void simcall_host_on__set__host(smx_simcall_t simcall, void* arg){
  43     simcall->args[0].dp = arg;
  44 }
  45
  46 static inline smx_host_t simcall_host_off__get__host(smx_simcall_t simcall){
  47   return (smx_host_t) simcall->args[0].dp;
  48 }
  49
  50 static inline void simcall_host_off__set__host(smx_simcall_t simcall, void* arg){
  51     simcall->args[0].dp = arg;
  52 }
  53
  54 static inline smx_host_t simcall_host_get_properties__get__host(smx_simcall_t simcall){
  55   return (smx_host_t) simcall->args[0].dp;
  56 }
  57
  58 static inline void simcall_host_get_properties__set__host(smx_simcall_t simcall, void* arg){
  59     simcall->args[0].dp = arg;
  60 }
  61 static inline xbt_dict_t simcall_host_get_properties__get__result(smx_simcall_t simcall){
  62     return (xbt_dict_t) simcall->result.dp;
  63 }
  64 static inline void simcall_host_get_properties__set__result(smx_simcall_t simcall, void* result){
  65     simcall->result.dp = result;
  66 }
  67
  68 static inline smx_host_t simcall_host_get_core__get__host(smx_simcall_t simcall){
  69   return (smx_host_t) simcall->args[0].dp;
  70 }
  71
  72 static inline void simcall_host_get_core__set__host(smx_simcall_t simcall, void* arg){
  73     simcall->args[0].dp = arg;
  74 }
  75 static inline int simcall_host_get_core__get__result(smx_simcall_t simcall){
  76     return  simcall->result.i;
  77 }
  78 static inline void simcall_host_get_core__set__result(smx_simcall_t simcall, int result){
  79     simcall->result.i = result;
  80 }
  81
  82 static inline smx_host_t simcall_host_get_process_list__get__host(smx_simcall_t simcall){
  83   return (smx_host_t) simcall->args[0].dp;
  84 }
  85
  86 static inline void simcall_host_get_process_list__set__host(smx_simcall_t simcall, void* arg){
  87     simcall->args[0].dp = arg;
  88 }
  89 static inline xbt_swag_t simcall_host_get_process_list__get__result(smx_simcall_t simcall){
  90     return (xbt_swag_t) simcall->result.dp;
  91 }
  92 static inline void simcall_host_get_process_list__set__result(smx_simcall_t simcall, void* result){
  93     simcall->result.dp = result;
  94 }
  95
  96 static inline smx_host_t simcall_host_get_speed__get__host(smx_simcall_t simcall){
  97   return (smx_host_t) simcall->args[0].dp;
  98 }
  99
 100 static inline void simcall_host_get_speed__set__host(smx_simcall_t simcall, void* arg){
 101     simcall->args[0].dp = arg;
 102 }
 103 static inline double simcall_host_get_speed__get__result(smx_simcall_t simcall){
 104     return  simcall->result.d;
 105 }
 106 static inline void simcall_host_get_speed__set__result(smx_simcall_t simcall, double result){
 107     simcall->result.d = result;
 108 }
 109
 110 static inline smx_host_t simcall_host_get_available_speed__get__host(smx_simcall_t simcall){
 111   return (smx_host_t) simcall->args[0].dp;
 112 }
 113
 114 static inline void simcall_host_get_available_speed__set__host(smx_simcall_t simcall, void* arg){
 115     simcall->args[0].dp = arg;
 116 }
 117 static inline double simcall_host_get_available_speed__get__result(smx_simcall_t simcall){
 118     return  simcall->result.d;
 119 }
 120 static inline void simcall_host_get_available_speed__set__result(smx_simcall_t simcall, double result){
 121     simcall->result.d = result;
 122 }
 123
 124 static inline smx_host_t simcall_host_get_state__get__host(smx_simcall_t simcall){
 125   return (smx_host_t) simcall->args[0].dp;
 126 }
 127
 128 static inline void simcall_host_get_state__set__host(smx_simcall_t simcall, void* arg){
 129     simcall->args[0].dp = arg;
 130 }
 131 static inline int simcall_host_get_state__get__result(smx_simcall_t simcall){
 132     return  simcall->result.i;
 133 }
 134 static inline void simcall_host_get_state__set__result(smx_simcall_t simcall, int result){
 135     simcall->result.i = result;
 136 }
 137
 138 static inline smx_host_t simcall_host_get_current_power_peak__get__host(smx_simcall_t simcall){
 139   return (smx_host_t) simcall->args[0].dp;
 140 }
 141
 142 static inline void simcall_host_get_current_power_peak__set__host(smx_simcall_t simcall, void* arg){
 143     simcall->args[0].dp = arg;
 144 }
 145 static inline double simcall_host_get_current_power_peak__get__result(smx_simcall_t simcall){
 146     return  simcall->result.d;
 147 }
 148 static inline void simcall_host_get_current_power_peak__set__result(smx_simcall_t simcall, double result){
 149     simcall->result.d = result;
 150 }
 151
 152 static inline smx_host_t simcall_host_get_power_peak_at__get__host(smx_simcall_t simcall){
 153   return (smx_host_t) simcall->args[0].dp;
 154 }
 155
 156 static inline void simcall_host_get_power_peak_at__set__host(smx_simcall_t simcall, void* arg){
 157     simcall->args[0].dp = arg;
 158 }
 159
 160 static inline int simcall_host_get_power_peak_at__get__pstate_index(smx_simcall_t simcall){
 161   return  simcall->args[1].i;
 162 }
 163
 164 static inline void simcall_host_get_power_peak_at__set__pstate_index(smx_simcall_t simcall, int arg){
 165     simcall->args[1].i = arg;
 166 }
 167 static inline double simcall_host_get_power_peak_at__get__result(smx_simcall_t simcall){
 168     return  simcall->result.d;
 169 }
 170 static inline void simcall_host_get_power_peak_at__set__result(smx_simcall_t simcall, double result){
 171     simcall->result.d = result;
 172 }
 173
 174 static inline smx_host_t simcall_host_get_nb_pstates__get__host(smx_simcall_t simcall){
 175   return (smx_host_t) simcall->args[0].dp;
 176 }
 177
 178 static inline void simcall_host_get_nb_pstates__set__host(smx_simcall_t simcall, void* arg){
 179     simcall->args[0].dp = arg;
 180 }
 181 static inline int simcall_host_get_nb_pstates__get__result(smx_simcall_t simcall){
 182     return  simcall->result.i;
 183 }
 184 static inline void simcall_host_get_nb_pstates__set__result(smx_simcall_t simcall, int result){
 185     simcall->result.i = result;
 186 }
 187
 188 static inline smx_host_t simcall_host_set_power_peak_at__get__host(smx_simcall_t simcall){
 189   return (smx_host_t) simcall->args[0].dp;
 190 }
 191
 192 static inline void simcall_host_set_power_peak_at__set__host(smx_simcall_t simcall, void* arg){
 193     simcall->args[0].dp = arg;
 194 }
 195
 196 static inline int simcall_host_set_power_peak_at__get__pstate_index(smx_simcall_t simcall){
 197   return  simcall->args[1].i;
 198 }
 199
 200 static inline void simcall_host_set_power_peak_at__set__pstate_index(smx_simcall_t simcall, int arg){
 201     simcall->args[1].i = arg;
 202 }
 203
 204 static inline smx_host_t simcall_host_get_consumed_energy__get__host(smx_simcall_t simcall){
 205   return (smx_host_t) simcall->args[0].dp;
 206 }
 207
 208 static inline void simcall_host_get_consumed_energy__set__host(smx_simcall_t simcall, void* arg){
 209     simcall->args[0].dp = arg;
 210 }
 211 static inline double simcall_host_get_consumed_energy__get__result(smx_simcall_t simcall){
 212     return  simcall->result.d;
 213 }
 214 static inline void simcall_host_get_consumed_energy__set__result(smx_simcall_t simcall, double result){
 215     simcall->result.d = result;
 216 }
 217
 218 static inline const char* simcall_host_execute__get__name(smx_simcall_t simcall){
 219   return  simcall->args[0].cc;
 220 }
 221
 222 static inline void simcall_host_execute__set__name(smx_simcall_t simcall, const char* arg){
 223     simcall->args[0].cc = arg;
 224 }
 225
 226 static inline smx_host_t simcall_host_execute__get__host(smx_simcall_t simcall){
 227   return (smx_host_t) simcall->args[1].dp;
 228 }
 229
 230 static inline void simcall_host_execute__set__host(smx_simcall_t simcall, void* arg){
 231     simcall->args[1].dp = arg;
 232 }
 233
 234 static inline double simcall_host_execute__get__computation_amount(smx_simcall_t simcall){
 235   return  simcall->args[2].d;
 236 }
 237
 238 static inline void simcall_host_execute__set__computation_amount(smx_simcall_t simcall, double arg){
 239     simcall->args[2].d = arg;
 240 }
 241
 242 static inline double simcall_host_execute__get__priority(smx_simcall_t simcall){
 243   return  simcall->args[3].d;
 244 }
 245
 246 static inline void simcall_host_execute__set__priority(smx_simcall_t simcall, double arg){
 247     simcall->args[3].d = arg;
 248 }
 249
 250 static inline double simcall_host_execute__get__bound(smx_simcall_t simcall){
 251   return  simcall->args[4].d;
 252 }
 253
 254 static inline void simcall_host_execute__set__bound(smx_simcall_t simcall, double arg){
 255     simcall->args[4].d = arg;
 256 }
 257
 258 static inline unsigned long simcall_host_execute__get__affinity_mask(smx_simcall_t simcall){
 259   return  simcall->args[5].ul;
 260 }
 261
 262 static inline void simcall_host_execute__set__affinity_mask(smx_simcall_t simcall, unsigned long arg){
 263     simcall->args[5].ul = arg;
 264 }
 265 static inline smx_action_t simcall_host_execute__get__result(smx_simcall_t simcall){
 266     return (smx_action_t) simcall->result.dp;
 267 }
 268 static inline void simcall_host_execute__set__result(smx_simcall_t simcall, void* result){
 269     simcall->result.dp = result;
 270 }
 271
 272 static inline const char* simcall_host_parallel_execute__get__name(smx_simcall_t simcall){
 273   return  simcall->args[0].cc;
 274 }
 275
 276 static inline void simcall_host_parallel_execute__set__name(smx_simcall_t simcall, const char* arg){
 277     simcall->args[0].cc = arg;
 278 }
 279
 280 static inline int simcall_host_parallel_execute__get__host_nb(smx_simcall_t simcall){
 281   return  simcall->args[1].i;
 282 }
 283
 284 static inline void simcall_host_parallel_execute__set__host_nb(smx_simcall_t simcall, int arg){
 285     simcall->args[1].i = arg;
 286 }
 287
 288 static inline smx_host_t* simcall_host_parallel_execute__get__host_list(smx_simcall_t simcall){
 289   return (smx_host_t*) simcall->args[2].dp;
 290 }
 291
 292 static inline void simcall_host_parallel_execute__set__host_list(smx_simcall_t simcall, void* arg){
 293     simcall->args[2].dp = arg;
 294 }
 295
 296 static inline double* simcall_host_parallel_execute__get__computation_amount(smx_simcall_t simcall){
 297   return (double*) simcall->args[3].dp;
 298 }
 299
 300 static inline void simcall_host_parallel_execute__set__computation_amount(smx_simcall_t simcall, void* arg){
 301     simcall->args[3].dp = arg;
 302 }
 303
 304 static inline double* simcall_host_parallel_execute__get__communication_amount(smx_simcall_t simcall){
 305   return (double*) simcall->args[4].dp;
 306 }
 307
 308 static inline void simcall_host_parallel_execute__set__communication_amount(smx_simcall_t simcall, void* arg){
 309     simcall->args[4].dp = arg;
 310 }
 311
 312 static inline double simcall_host_parallel_execute__get__amount(smx_simcall_t simcall){
 313   return  simcall->args[5].d;
 314 }
 315
 316 static inline void simcall_host_parallel_execute__set__amount(smx_simcall_t simcall, double arg){
 317     simcall->args[5].d = arg;
 318 }
 319
 320 static inline double simcall_host_parallel_execute__get__rate(smx_simcall_t simcall){
 321   return  simcall->args[6].d;
 322 }
 323
 324 static inline void simcall_host_parallel_execute__set__rate(smx_simcall_t simcall, double arg){
 325     simcall->args[6].d = arg;
 326 }
 327 static inline smx_action_t simcall_host_parallel_execute__get__result(smx_simcall_t simcall){
 328     return (smx_action_t) simcall->result.dp;
 329 }
 330 static inline void simcall_host_parallel_execute__set__result(smx_simcall_t simcall, void* result){
 331     simcall->result.dp = result;
 332 }
 333
 334 static inline smx_action_t simcall_host_execution_destroy__get__execution(smx_simcall_t simcall){
 335   return (smx_action_t) simcall->args[0].dp;
 336 }
 337
 338 static inline void simcall_host_execution_destroy__set__execution(smx_simcall_t simcall, void* arg){
 339     simcall->args[0].dp = arg;
 340 }
 341
 342 static inline smx_action_t simcall_host_execution_cancel__get__execution(smx_simcall_t simcall){
 343   return (smx_action_t) simcall->args[0].dp;
 344 }
 345
 346 static inline void simcall_host_execution_cancel__set__execution(smx_simcall_t simcall, void* arg){
 347     simcall->args[0].dp = arg;
 348 }
 349
 350 static inline smx_action_t simcall_host_execution_get_remains__get__execution(smx_simcall_t simcall){
 351   return (smx_action_t) simcall->args[0].dp;
 352 }
 353
 354 static inline void simcall_host_execution_get_remains__set__execution(smx_simcall_t simcall, void* arg){
 355     simcall->args[0].dp = arg;
 356 }
 357 static inline double simcall_host_execution_get_remains__get__result(smx_simcall_t simcall){
 358     return  simcall->result.d;
 359 }
 360 static inline void simcall_host_execution_get_remains__set__result(smx_simcall_t simcall, double result){
 361     simcall->result.d = result;
 362 }
 363
 364 static inline smx_action_t simcall_host_execution_get_state__get__execution(smx_simcall_t simcall){
 365   return (smx_action_t) simcall->args[0].dp;
 366 }
 367
 368 static inline void simcall_host_execution_get_state__set__execution(smx_simcall_t simcall, void* arg){
 369     simcall->args[0].dp = arg;
 370 }
 371 static inline int simcall_host_execution_get_state__get__result(smx_simcall_t simcall){
 372     return  simcall->result.i;
 373 }
 374 static inline void simcall_host_execution_get_state__set__result(smx_simcall_t simcall, int result){
 375     simcall->result.i = result;
 376 }
 377
 378 static inline smx_action_t simcall_host_execution_set_priority__get__execution(smx_simcall_t simcall){
 379   return (smx_action_t) simcall->args[0].dp;
 380 }
 381
 382 static inline void simcall_host_execution_set_priority__set__execution(smx_simcall_t simcall, void* arg){
 383     simcall->args[0].dp = arg;
 384 }
 385
 386 static inline double simcall_host_execution_set_priority__get__priority(smx_simcall_t simcall){
 387   return  simcall->args[1].d;
 388 }
 389
 390 static inline void simcall_host_execution_set_priority__set__priority(smx_simcall_t simcall, double arg){
 391     simcall->args[1].d = arg;
 392 }
 393
 394 static inline smx_action_t simcall_host_execution_set_bound__get__execution(smx_simcall_t simcall){
 395   return (smx_action_t) simcall->args[0].dp;
 396 }
 397
 398 static inline void simcall_host_execution_set_bound__set__execution(smx_simcall_t simcall, void* arg){
 399     simcall->args[0].dp = arg;
 400 }
 401
 402 static inline double simcall_host_execution_set_bound__get__bound(smx_simcall_t simcall){
 403   return  simcall->args[1].d;
 404 }
 405
 406 static inline void simcall_host_execution_set_bound__set__bound(smx_simcall_t simcall, double arg){
 407     simcall->args[1].d = arg;
 408 }
 409
 410 static inline smx_action_t simcall_host_execution_set_affinity__get__execution(smx_simcall_t simcall){
 411   return (smx_action_t) simcall->args[0].dp;
 412 }
 413
 414 static inline void simcall_host_execution_set_affinity__set__execution(smx_simcall_t simcall, void* arg){
 415     simcall->args[0].dp = arg;
 416 }
 417
 418 static inline smx_host_t simcall_host_execution_set_affinity__get__ws(smx_simcall_t simcall){
 419   return (smx_host_t) simcall->args[1].dp;
 420 }
 421
 422 static inline void simcall_host_execution_set_affinity__set__ws(smx_simcall_t simcall, void* arg){
 423     simcall->args[1].dp = arg;
 424 }
 425
 426 static inline unsigned long simcall_host_execution_set_affinity__get__mask(smx_simcall_t simcall){
 427   return  simcall->args[2].ul;
 428 }
 429
 430 static inline void simcall_host_execution_set_affinity__set__mask(smx_simcall_t simcall, unsigned long arg){
 431     simcall->args[2].ul = arg;
 432 }
 433
 434 static inline smx_action_t simcall_host_execution_wait__get__execution(smx_simcall_t simcall){
 435   return (smx_action_t) simcall->args[0].dp;
 436 }
 437
 438 static inline void simcall_host_execution_wait__set__execution(smx_simcall_t simcall, void* arg){
 439     simcall->args[0].dp = arg;
 440 }
 441 static inline int simcall_host_execution_wait__get__result(smx_simcall_t simcall){
 442     return  simcall->result.i;
 443 }
 444 static inline void simcall_host_execution_wait__set__result(smx_simcall_t simcall, int result){
 445     simcall->result.i = result;
 446 }
 447
 448 static inline smx_host_t simcall_host_get_mounted_storage_list__get__host(smx_simcall_t simcall){
 449   return (smx_host_t) simcall->args[0].dp;
 450 }
 451
 452 static inline void simcall_host_get_mounted_storage_list__set__host(smx_simcall_t simcall, void* arg){
 453     simcall->args[0].dp = arg;
 454 }
 455 static inline xbt_dict_t simcall_host_get_mounted_storage_list__get__result(smx_simcall_t simcall){
 456     return (xbt_dict_t) simcall->result.dp;
 457 }
 458 static inline void simcall_host_get_mounted_storage_list__set__result(smx_simcall_t simcall, void* result){
 459     simcall->result.dp = result;
 460 }
 461
 462 static inline smx_host_t simcall_host_get_attached_storage_list__get__host(smx_simcall_t simcall){
 463   return (smx_host_t) simcall->args[0].dp;
 464 }
 465
 466 static inline void simcall_host_get_attached_storage_list__set__host(smx_simcall_t simcall, void* arg){
 467     simcall->args[0].dp = arg;
 468 }
 469 static inline xbt_dynar_t simcall_host_get_attached_storage_list__get__result(smx_simcall_t simcall){
 470     return (xbt_dynar_t) simcall->result.dp;
 471 }
 472 static inline void simcall_host_get_attached_storage_list__set__result(smx_simcall_t simcall, void* result){
 473     simcall->result.dp = result;
 474 }
 475
 476 static inline smx_host_t simcall_host_get_params__get__ind_vm(smx_simcall_t simcall){
 477   return (smx_host_t) simcall->args[0].dp;
 478 }
 479
 480 static inline void simcall_host_get_params__set__ind_vm(smx_simcall_t simcall, void* arg){
 481     simcall->args[0].dp = arg;
 482 }
 483
 484 static inline ws_params_t simcall_host_get_params__get__params(smx_simcall_t simcall){
 485   return (ws_params_t) simcall->args[1].dp;
 486 }
 487
 488 static inline void simcall_host_get_params__set__params(smx_simcall_t simcall, void* arg){
 489     simcall->args[1].dp = arg;
 490 }
 491
 492 static inline smx_host_t simcall_host_set_params__get__ind_vm(smx_simcall_t simcall){
 493   return (smx_host_t) simcall->args[0].dp;
 494 }
 495
 496 static inline void simcall_host_set_params__set__ind_vm(smx_simcall_t simcall, void* arg){
 497     simcall->args[0].dp = arg;
 498 }
 499
 500 static inline ws_params_t simcall_host_set_params__get__params(smx_simcall_t simcall){
 501   return (ws_params_t) simcall->args[1].dp;
 502 }
 503
 504 static inline void simcall_host_set_params__set__params(smx_simcall_t simcall, void* arg){
 505     simcall->args[1].dp = arg;
 506 }
 507
 508 static inline const char* simcall_vm_create__get__name(smx_simcall_t simcall){
 509   return  simcall->args[0].cc;
 510 }
 511
 512 static inline void simcall_vm_create__set__name(smx_simcall_t simcall, const char* arg){
 513     simcall->args[0].cc = arg;
 514 }
 515
 516 static inline smx_host_t simcall_vm_create__get__ind_pm(smx_simcall_t simcall){
 517   return (smx_host_t) simcall->args[1].dp;
 518 }
 519
 520 static inline void simcall_vm_create__set__ind_pm(smx_simcall_t simcall, void* arg){
 521     simcall->args[1].dp = arg;
 522 }
 523 static inline void* simcall_vm_create__get__result(smx_simcall_t simcall){
 524     return  simcall->result.dp;
 525 }
 526 static inline void simcall_vm_create__set__result(smx_simcall_t simcall, void* result){
 527     simcall->result.dp = result;
 528 }
 529
 530 static inline smx_host_t simcall_vm_start__get__ind_vm(smx_simcall_t simcall){
 531   return (smx_host_t) simcall->args[0].dp;
 532 }
 533
 534 static inline void simcall_vm_start__set__ind_vm(smx_simcall_t simcall, void* arg){
 535     simcall->args[0].dp = arg;
 536 }
 537
 538 static inline smx_host_t simcall_vm_get_state__get__ind_vm(smx_simcall_t simcall){
 539   return (smx_host_t) simcall->args[0].dp;
 540 }
 541
 542 static inline void simcall_vm_get_state__set__ind_vm(smx_simcall_t simcall, void* arg){
 543     simcall->args[0].dp = arg;
 544 }
 545 static inline int simcall_vm_get_state__get__result(smx_simcall_t simcall){
 546     return  simcall->result.i;
 547 }
 548 static inline void simcall_vm_get_state__set__result(smx_simcall_t simcall, int result){
 549     simcall->result.i = result;
 550 }
 551
 552 static inline smx_host_t simcall_vm_migrate__get__ind_vm(smx_simcall_t simcall){
 553   return (smx_host_t) simcall->args[0].dp;
 554 }
 555
 556 static inline void simcall_vm_migrate__set__ind_vm(smx_simcall_t simcall, void* arg){
 557     simcall->args[0].dp = arg;
 558 }
 559
 560 static inline smx_host_t simcall_vm_migrate__get__ind_dst_pm(smx_simcall_t simcall){
 561   return (smx_host_t) simcall->args[1].dp;
 562 }
 563
 564 static inline void simcall_vm_migrate__set__ind_dst_pm(smx_simcall_t simcall, void* arg){
 565     simcall->args[1].dp = arg;
 566 }
 567
 568 static inline smx_host_t simcall_vm_get_pm__get__ind_vm(smx_simcall_t simcall){
 569   return (smx_host_t) simcall->args[0].dp;
 570 }
 571
 572 static inline void simcall_vm_get_pm__set__ind_vm(smx_simcall_t simcall, void* arg){
 573     simcall->args[0].dp = arg;
 574 }
 575 static inline void* simcall_vm_get_pm__get__result(smx_simcall_t simcall){
 576     return  simcall->result.dp;
 577 }
 578 static inline void simcall_vm_get_pm__set__result(smx_simcall_t simcall, void* result){
 579     simcall->result.dp = result;
 580 }
 581
 582 static inline smx_host_t simcall_vm_set_bound__get__ind_vm(smx_simcall_t simcall){
 583   return (smx_host_t) simcall->args[0].dp;
 584 }
 585
 586 static inline void simcall_vm_set_bound__set__ind_vm(smx_simcall_t simcall, void* arg){
 587     simcall->args[0].dp = arg;
 588 }
 589
 590 static inline double simcall_vm_set_bound__get__bound(smx_simcall_t simcall){
 591   return  simcall->args[1].d;
 592 }
 593
 594 static inline void simcall_vm_set_bound__set__bound(smx_simcall_t simcall, double arg){
 595     simcall->args[1].d = arg;
 596 }
 597
 598 static inline smx_host_t simcall_vm_set_affinity__get__ind_vm(smx_simcall_t simcall){
 599   return (smx_host_t) simcall->args[0].dp;
 600 }
 601
 602 static inline void simcall_vm_set_affinity__set__ind_vm(smx_simcall_t simcall, void* arg){
 603     simcall->args[0].dp = arg;
 604 }
 605
 606 static inline smx_host_t simcall_vm_set_affinity__get__ind_pm(smx_simcall_t simcall){
 607   return (smx_host_t) simcall->args[1].dp;
 608 }
 609
 610 static inline void simcall_vm_set_affinity__set__ind_pm(smx_simcall_t simcall, void* arg){
 611     simcall->args[1].dp = arg;
 612 }
 613
 614 static inline unsigned long simcall_vm_set_affinity__get__mask(smx_simcall_t simcall){
 615   return  simcall->args[2].ul;
 616 }
 617
 618 static inline void simcall_vm_set_affinity__set__mask(smx_simcall_t simcall, unsigned long arg){
 619     simcall->args[2].ul = arg;
 620 }
 621
 622 static inline smx_host_t simcall_vm_destroy__get__ind_vm(smx_simcall_t simcall){
 623   return (smx_host_t) simcall->args[0].dp;
 624 }
 625
 626 static inline void simcall_vm_destroy__set__ind_vm(smx_simcall_t simcall, void* arg){
 627     simcall->args[0].dp = arg;
 628 }
 629
 630 static inline smx_host_t simcall_vm_suspend__get__ind_vm(smx_simcall_t simcall){
 631   return (smx_host_t) simcall->args[0].dp;
 632 }
 633
 634 static inline void simcall_vm_suspend__set__ind_vm(smx_simcall_t simcall, void* arg){
 635     simcall->args[0].dp = arg;
 636 }
 637
 638 static inline smx_host_t simcall_vm_resume__get__ind_vm(smx_simcall_t simcall){
 639   return (smx_host_t) simcall->args[0].dp;
 640 }
 641
 642 static inline void simcall_vm_resume__set__ind_vm(smx_simcall_t simcall, void* arg){
 643     simcall->args[0].dp = arg;
 644 }
 645
 646 static inline smx_host_t simcall_vm_shutdown__get__ind_vm(smx_simcall_t simcall){
 647   return (smx_host_t) simcall->args[0].dp;
 648 }
 649
 650 static inline void simcall_vm_shutdown__set__ind_vm(smx_simcall_t simcall, void* arg){
 651     simcall->args[0].dp = arg;
 652 }
 653
 654 static inline smx_host_t simcall_vm_save__get__ind_vm(smx_simcall_t simcall){
 655   return (smx_host_t) simcall->args[0].dp;
 656 }
 657
 658 static inline void simcall_vm_save__set__ind_vm(smx_simcall_t simcall, void* arg){
 659     simcall->args[0].dp = arg;
 660 }
 661
 662 static inline smx_host_t simcall_vm_restore__get__ind_vm(smx_simcall_t simcall){
 663   return (smx_host_t) simcall->args[0].dp;
 664 }
 665
 666 static inline void simcall_vm_restore__set__ind_vm(smx_simcall_t simcall, void* arg){
 667     simcall->args[0].dp = arg;
 668 }
 669
 670 static inline smx_process_t* simcall_process_create__get__process(smx_simcall_t simcall){
 671   return (smx_process_t*) simcall->args[0].dp;
 672 }
 673
 674 static inline void simcall_process_create__set__process(smx_simcall_t simcall, void* arg){
 675     simcall->args[0].dp = arg;
 676 }
 677
 678 static inline const char* simcall_process_create__get__name(smx_simcall_t simcall){
 679   return  simcall->args[1].cc;
 680 }
 681
 682 static inline void simcall_process_create__set__name(smx_simcall_t simcall, const char* arg){
 683     simcall->args[1].cc = arg;
 684 }
 685
 686 static inline xbt_main_func_t simcall_process_create__get__code(smx_simcall_t simcall){
 687   return (xbt_main_func_t) simcall->args[2].fp;
 688 }
 689
 690 static inline void simcall_process_create__set__code(smx_simcall_t simcall, FPtr arg){
 691     simcall->args[2].fp = arg;
 692 }
 693
 694 static inline void* simcall_process_create__get__data(smx_simcall_t simcall){
 695   return  simcall->args[3].dp;
 696 }
 697
 698 static inline void simcall_process_create__set__data(smx_simcall_t simcall, void* arg){
 699     simcall->args[3].dp = arg;
 700 }
 701
 702 static inline const char* simcall_process_create__get__hostname(smx_simcall_t simcall){
 703   return  simcall->args[4].cc;
 704 }
 705
 706 static inline void simcall_process_create__set__hostname(smx_simcall_t simcall, const char* arg){
 707     simcall->args[4].cc = arg;
 708 }
 709
 710 static inline double simcall_process_create__get__kill_time(smx_simcall_t simcall){
 711   return  simcall->args[5].d;
 712 }
 713
 714 static inline void simcall_process_create__set__kill_time(smx_simcall_t simcall, double arg){
 715     simcall->args[5].d = arg;
 716 }
 717
 718 static inline int simcall_process_create__get__argc(smx_simcall_t simcall){
 719   return  simcall->args[6].i;
 720 }
 721
 722 static inline void simcall_process_create__set__argc(smx_simcall_t simcall, int arg){
 723     simcall->args[6].i = arg;
 724 }
 725
 726 static inline char** simcall_process_create__get__argv(smx_simcall_t simcall){
 727   return (char**) simcall->args[7].dp;
 728 }
 729
 730 static inline void simcall_process_create__set__argv(smx_simcall_t simcall, void* arg){
 731     simcall->args[7].dp = arg;
 732 }
 733
 734 static inline xbt_dict_t simcall_process_create__get__properties(smx_simcall_t simcall){
 735   return (xbt_dict_t) simcall->args[8].dp;
 736 }
 737
 738 static inline void simcall_process_create__set__properties(smx_simcall_t simcall, void* arg){
 739     simcall->args[8].dp = arg;
 740 }
 741
 742 static inline int simcall_process_create__get__auto_restart(smx_simcall_t simcall){
 743   return  simcall->args[9].i;
 744 }
 745
 746 static inline void simcall_process_create__set__auto_restart(smx_simcall_t simcall, int arg){
 747     simcall->args[9].i = arg;
 748 }
 749
 750 static inline smx_process_t simcall_process_kill__get__process(smx_simcall_t simcall){
 751   return (smx_process_t) simcall->args[0].dp;
 752 }
 753
 754 static inline void simcall_process_kill__set__process(smx_simcall_t simcall, void* arg){
 755     simcall->args[0].dp = arg;
 756 }
 757
 758 static inline int simcall_process_killall__get__reset_pid(smx_simcall_t simcall){
 759   return  simcall->args[0].i;
 760 }
 761
 762 static inline void simcall_process_killall__set__reset_pid(smx_simcall_t simcall, int arg){
 763     simcall->args[0].i = arg;
 764 }
 765
 766 static inline smx_process_t simcall_process_cleanup__get__process(smx_simcall_t simcall){
 767   return (smx_process_t) simcall->args[0].dp;
 768 }
 769
 770 static inline void simcall_process_cleanup__set__process(smx_simcall_t simcall, void* arg){
 771     simcall->args[0].dp = arg;
 772 }
 773
 774 static inline smx_process_t simcall_process_change_host__get__process(smx_simcall_t simcall){
 775   return (smx_process_t) simcall->args[0].dp;
 776 }
 777
 778 static inline void simcall_process_change_host__set__process(smx_simcall_t simcall, void* arg){
 779     simcall->args[0].dp = arg;
 780 }
 781
 782 static inline smx_host_t simcall_process_change_host__get__dest(smx_simcall_t simcall){
 783   return (smx_host_t) simcall->args[1].dp;
 784 }
 785
 786 static inline void simcall_process_change_host__set__dest(smx_simcall_t simcall, void* arg){
 787     simcall->args[1].dp = arg;
 788 }
 789
 790 static inline smx_process_t simcall_process_suspend__get__process(smx_simcall_t simcall){
 791   return (smx_process_t) simcall->args[0].dp;
 792 }
 793
 794 static inline void simcall_process_suspend__set__process(smx_simcall_t simcall, void* arg){
 795     simcall->args[0].dp = arg;
 796 }
 797
 798 static inline smx_process_t simcall_process_resume__get__process(smx_simcall_t simcall){
 799   return (smx_process_t) simcall->args[0].dp;
 800 }
 801
 802 static inline void simcall_process_resume__set__process(smx_simcall_t simcall, void* arg){
 803     simcall->args[0].dp = arg;
 804 }
 805 static inline int simcall_process_count__get__result(smx_simcall_t simcall){
 806     return  simcall->result.i;
 807 }
 808 static inline void simcall_process_count__set__result(smx_simcall_t simcall, int result){
 809     simcall->result.i = result;
 810 }
 811
 812 static inline smx_process_t simcall_process_get_PID__get__process(smx_simcall_t simcall){
 813   return (smx_process_t) simcall->args[0].dp;
 814 }
 815
 816 static inline void simcall_process_get_PID__set__process(smx_simcall_t simcall, void* arg){
 817     simcall->args[0].dp = arg;
 818 }
 819 static inline int simcall_process_get_PID__get__result(smx_simcall_t simcall){
 820     return  simcall->result.i;
 821 }
 822 static inline void simcall_process_get_PID__set__result(smx_simcall_t simcall, int result){
 823     simcall->result.i = result;
 824 }
 825
 826 static inline smx_process_t simcall_process_get_PPID__get__process(smx_simcall_t simcall){
 827   return (smx_process_t) simcall->args[0].dp;
 828 }
 829
 830 static inline void simcall_process_get_PPID__set__process(smx_simcall_t simcall, void* arg){
 831     simcall->args[0].dp = arg;
 832 }
 833 static inline int simcall_process_get_PPID__get__result(smx_simcall_t simcall){
 834     return  simcall->result.i;
 835 }
 836 static inline void simcall_process_get_PPID__set__result(smx_simcall_t simcall, int result){
 837     simcall->result.i = result;
 838 }
 839
 840 static inline smx_process_t simcall_process_get_data__get__process(smx_simcall_t simcall){
 841   return (smx_process_t) simcall->args[0].dp;
 842 }
 843
 844 static inline void simcall_process_get_data__set__process(smx_simcall_t simcall, void* arg){
 845     simcall->args[0].dp = arg;
 846 }
 847 static inline void* simcall_process_get_data__get__result(smx_simcall_t simcall){
 848     return  simcall->result.dp;
 849 }
 850 static inline void simcall_process_get_data__set__result(smx_simcall_t simcall, void* result){
 851     simcall->result.dp = result;
 852 }
 853
 854 static inline smx_process_t simcall_process_set_data__get__process(smx_simcall_t simcall){
 855   return (smx_process_t) simcall->args[0].dp;
 856 }
 857
 858 static inline void simcall_process_set_data__set__process(smx_simcall_t simcall, void* arg){
 859     simcall->args[0].dp = arg;
 860 }
 861
 862 static inline void* simcall_process_set_data__get__data(smx_simcall_t simcall){
 863   return  simcall->args[1].dp;
 864 }
 865
 866 static inline void simcall_process_set_data__set__data(smx_simcall_t simcall, void* arg){
 867     simcall->args[1].dp = arg;
 868 }
 869
 870 static inline smx_process_t simcall_process_get_host__get__process(smx_simcall_t simcall){
 871   return (smx_process_t) simcall->args[0].dp;
 872 }
 873
 874 static inline void simcall_process_get_host__set__process(smx_simcall_t simcall, void* arg){
 875     simcall->args[0].dp = arg;
 876 }
 877 static inline smx_host_t simcall_process_get_host__get__result(smx_simcall_t simcall){
 878     return (smx_host_t) simcall->result.dp;
 879 }
 880 static inline void simcall_process_get_host__set__result(smx_simcall_t simcall, void* result){
 881     simcall->result.dp = result;
 882 }
 883
 884 static inline smx_process_t simcall_process_get_name__get__process(smx_simcall_t simcall){
 885   return (smx_process_t) simcall->args[0].dp;
 886 }
 887
 888 static inline void simcall_process_get_name__set__process(smx_simcall_t simcall, void* arg){
 889     simcall->args[0].dp = arg;
 890 }
 891 static inline const char* simcall_process_get_name__get__result(smx_simcall_t simcall){
 892     return  simcall->result.cc;
 893 }
 894 static inline void simcall_process_get_name__set__result(smx_simcall_t simcall, const char* result){
 895     simcall->result.cc = result;
 896 }
 897
 898 static inline smx_process_t simcall_process_is_suspended__get__process(smx_simcall_t simcall){
 899   return (smx_process_t) simcall->args[0].dp;
 900 }
 901
 902 static inline void simcall_process_is_suspended__set__process(smx_simcall_t simcall, void* arg){
 903     simcall->args[0].dp = arg;
 904 }
 905 static inline int simcall_process_is_suspended__get__result(smx_simcall_t simcall){
 906     return  simcall->result.i;
 907 }
 908 static inline void simcall_process_is_suspended__set__result(smx_simcall_t simcall, int result){
 909     simcall->result.i = result;
 910 }
 911
 912 static inline smx_process_t simcall_process_get_properties__get__process(smx_simcall_t simcall){
 913   return (smx_process_t) simcall->args[0].dp;
 914 }
 915
 916 static inline void simcall_process_get_properties__set__process(smx_simcall_t simcall, void* arg){
 917     simcall->args[0].dp = arg;
 918 }
 919 static inline xbt_dict_t simcall_process_get_properties__get__result(smx_simcall_t simcall){
 920     return (xbt_dict_t) simcall->result.dp;
 921 }
 922 static inline void simcall_process_get_properties__set__result(smx_simcall_t simcall, void* result){
 923     simcall->result.dp = result;
 924 }
 925
 926 static inline smx_process_t simcall_process_join__get__process(smx_simcall_t simcall){
 927   return (smx_process_t) simcall->args[0].dp;
 928 }
 929
 930 static inline void simcall_process_join__set__process(smx_simcall_t simcall, void* arg){
 931     simcall->args[0].dp = arg;
 932 }
 933
 934 static inline double simcall_process_join__get__timeout(smx_simcall_t simcall){
 935   return  simcall->args[1].d;
 936 }
 937
 938 static inline void simcall_process_join__set__timeout(smx_simcall_t simcall, double arg){
 939     simcall->args[1].d = arg;
 940 }
 941 static inline int simcall_process_join__get__result(smx_simcall_t simcall){
 942     return  simcall->result.i;
 943 }
 944 static inline void simcall_process_join__set__result(smx_simcall_t simcall, int result){
 945     simcall->result.i = result;
 946 }
 947
 948 static inline double simcall_process_sleep__get__duration(smx_simcall_t simcall){
 949   return  simcall->args[0].d;
 950 }
 951
 952 static inline void simcall_process_sleep__set__duration(smx_simcall_t simcall, double arg){
 953     simcall->args[0].d = arg;
 954 }
 955 static inline int simcall_process_sleep__get__result(smx_simcall_t simcall){
 956     return  simcall->result.i;
 957 }
 958 static inline void simcall_process_sleep__set__result(smx_simcall_t simcall, int result){
 959     simcall->result.i = result;
 960 }
 961
 962 static inline smx_process_t simcall_process_on_exit__get__process(smx_simcall_t simcall){
 963   return (smx_process_t) simcall->args[0].dp;
 964 }
 965
 966 static inline void simcall_process_on_exit__set__process(smx_simcall_t simcall, void* arg){
 967     simcall->args[0].dp = arg;
 968 }
 969
 970 static inline int_f_pvoid_pvoid_t simcall_process_on_exit__get__fun(smx_simcall_t simcall){
 971   return (int_f_pvoid_pvoid_t) simcall->args[1].fp;
 972 }
 973
 974 static inline void simcall_process_on_exit__set__fun(smx_simcall_t simcall, FPtr arg){
 975     simcall->args[1].fp = arg;
 976 }
 977
 978 static inline void* simcall_process_on_exit__get__data(smx_simcall_t simcall){
 979   return  simcall->args[2].dp;
 980 }
 981
 982 static inline void simcall_process_on_exit__set__data(smx_simcall_t simcall, void* arg){
 983     simcall->args[2].dp = arg;
 984 }
 985
 986 static inline smx_process_t simcall_process_auto_restart_set__get__process(smx_simcall_t simcall){
 987   return (smx_process_t) simcall->args[0].dp;
 988 }
 989
 990 static inline void simcall_process_auto_restart_set__set__process(smx_simcall_t simcall, void* arg){
 991     simcall->args[0].dp = arg;
 992 }
 993
 994 static inline int simcall_process_auto_restart_set__get__auto_restart(smx_simcall_t simcall){
 995   return  simcall->args[1].i;
 996 }
 997
 998 static inline void simcall_process_auto_restart_set__set__auto_restart(smx_simcall_t simcall, int arg){
 999     simcall->args[1].i = arg;
1000 }
1001
1002 static inline smx_process_t simcall_process_restart__get__process(smx_simcall_t simcall){
1003   return (smx_process_t) simcall->args[0].dp;
1004 }
1005
1006 static inline void simcall_process_restart__set__process(smx_simcall_t simcall, void* arg){
1007     simcall->args[0].dp = arg;
1008 }
1009 static inline smx_process_t simcall_process_restart__get__result(smx_simcall_t simcall){
1010     return (smx_process_t) simcall->result.dp;
1011 }
1012 static inline void simcall_process_restart__set__result(smx_simcall_t simcall, void* result){
1013     simcall->result.dp = result;
1014 }
1015
1016 static inline const char* simcall_rdv_create__get__name(smx_simcall_t simcall){
1017   return  simcall->args[0].cc;
1018 }
1019
1020 static inline void simcall_rdv_create__set__name(smx_simcall_t simcall, const char* arg){
1021     simcall->args[0].cc = arg;
1022 }
1023 static inline smx_rdv_t simcall_rdv_create__get__result(smx_simcall_t simcall){
1024     return (smx_rdv_t) simcall->result.dp;
1025 }
1026 static inline void simcall_rdv_create__set__result(smx_simcall_t simcall, void* result){
1027     simcall->result.dp = result;
1028 }
1029
1030 static inline smx_rdv_t simcall_rdv_destroy__get__rdv(smx_simcall_t simcall){
1031   return (smx_rdv_t) simcall->args[0].dp;
1032 }
1033
1034 static inline void simcall_rdv_destroy__set__rdv(smx_simcall_t simcall, void* arg){
1035     simcall->args[0].dp = arg;
1036 }
1037
1038 static inline smx_rdv_t simcall_rdv_comm_count_by_host__get__rdv(smx_simcall_t simcall){
1039   return (smx_rdv_t) simcall->args[0].dp;
1040 }
1041
1042 static inline void simcall_rdv_comm_count_by_host__set__rdv(smx_simcall_t simcall, void* arg){
1043     simcall->args[0].dp = arg;
1044 }
1045
1046 static inline smx_host_t simcall_rdv_comm_count_by_host__get__host(smx_simcall_t simcall){
1047   return (smx_host_t) simcall->args[1].dp;
1048 }
1049
1050 static inline void simcall_rdv_comm_count_by_host__set__host(smx_simcall_t simcall, void* arg){
1051     simcall->args[1].dp = arg;
1052 }
1053 static inline unsigned int simcall_rdv_comm_count_by_host__get__result(smx_simcall_t simcall){
1054     return  simcall->result.ui;
1055 }
1056 static inline void simcall_rdv_comm_count_by_host__set__result(smx_simcall_t simcall, unsigned int result){
1057     simcall->result.ui = result;
1058 }
1059
1060 static inline smx_rdv_t simcall_rdv_get_head__get__rdv(smx_simcall_t simcall){
1061   return (smx_rdv_t) simcall->args[0].dp;
1062 }
1063
1064 static inline void simcall_rdv_get_head__set__rdv(smx_simcall_t simcall, void* arg){
1065     simcall->args[0].dp = arg;
1066 }
1067 static inline smx_action_t simcall_rdv_get_head__get__result(smx_simcall_t simcall){
1068     return (smx_action_t) simcall->result.dp;
1069 }
1070 static inline void simcall_rdv_get_head__set__result(smx_simcall_t simcall, void* result){
1071     simcall->result.dp = result;
1072 }
1073
1074 static inline smx_rdv_t simcall_rdv_set_receiver__get__rdv(smx_simcall_t simcall){
1075   return (smx_rdv_t) simcall->args[0].dp;
1076 }
1077
1078 static inline void simcall_rdv_set_receiver__set__rdv(smx_simcall_t simcall, void* arg){
1079     simcall->args[0].dp = arg;
1080 }
1081
1082 static inline smx_process_t simcall_rdv_set_receiver__get__receiver(smx_simcall_t simcall){
1083   return (smx_process_t) simcall->args[1].dp;
1084 }
1085
1086 static inline void simcall_rdv_set_receiver__set__receiver(smx_simcall_t simcall, void* arg){
1087     simcall->args[1].dp = arg;
1088 }
1089
1090 static inline smx_rdv_t simcall_rdv_get_receiver__get__rdv(smx_simcall_t simcall){
1091   return (smx_rdv_t) simcall->args[0].dp;
1092 }
1093
1094 static inline void simcall_rdv_get_receiver__set__rdv(smx_simcall_t simcall, void* arg){
1095     simcall->args[0].dp = arg;
1096 }
1097 static inline smx_process_t simcall_rdv_get_receiver__get__result(smx_simcall_t simcall){
1098     return (smx_process_t) simcall->result.dp;
1099 }
1100 static inline void simcall_rdv_get_receiver__set__result(smx_simcall_t simcall, void* result){
1101     simcall->result.dp = result;
1102 }
1103
1104 static inline smx_rdv_t simcall_comm_iprobe__get__rdv(smx_simcall_t simcall){
1105   return (smx_rdv_t) simcall->args[0].dp;
1106 }
1107
1108 static inline void simcall_comm_iprobe__set__rdv(smx_simcall_t simcall, void* arg){
1109     simcall->args[0].dp = arg;
1110 }
1111
1112 static inline int simcall_comm_iprobe__get__type(smx_simcall_t simcall){
1113   return  simcall->args[1].i;
1114 }
1115
1116 static inline void simcall_comm_iprobe__set__type(smx_simcall_t simcall, int arg){
1117     simcall->args[1].i = arg;
1118 }
1119
1120 static inline int simcall_comm_iprobe__get__src(smx_simcall_t simcall){
1121   return  simcall->args[2].i;
1122 }
1123
1124 static inline void simcall_comm_iprobe__set__src(smx_simcall_t simcall, int arg){
1125     simcall->args[2].i = arg;
1126 }
1127
1128 static inline int simcall_comm_iprobe__get__tag(smx_simcall_t simcall){
1129   return  simcall->args[3].i;
1130 }
1131
1132 static inline void simcall_comm_iprobe__set__tag(smx_simcall_t simcall, int arg){
1133     simcall->args[3].i = arg;
1134 }
1135
1136 static inline simix_match_func_t simcall_comm_iprobe__get__match_fun(smx_simcall_t simcall){
1137   return (simix_match_func_t) simcall->args[4].fp;
1138 }
1139
1140 static inline void simcall_comm_iprobe__set__match_fun(smx_simcall_t simcall, FPtr arg){
1141     simcall->args[4].fp = arg;
1142 }
1143
1144 static inline void* simcall_comm_iprobe__get__data(smx_simcall_t simcall){
1145   return  simcall->args[5].dp;
1146 }
1147
1148 static inline void simcall_comm_iprobe__set__data(smx_simcall_t simcall, void* arg){
1149     simcall->args[5].dp = arg;
1150 }
1151 static inline smx_action_t simcall_comm_iprobe__get__result(smx_simcall_t simcall){
1152     return (smx_action_t) simcall->result.dp;
1153 }
1154 static inline void simcall_comm_iprobe__set__result(smx_simcall_t simcall, void* result){
1155     simcall->result.dp = result;
1156 }
1157
1158 static inline smx_process_t simcall_comm_send__get__src(smx_simcall_t simcall){
1159   return (smx_process_t) simcall->args[0].dp;
1160 }
1161
1162 static inline void simcall_comm_send__set__src(smx_simcall_t simcall, void* arg){
1163     simcall->args[0].dp = arg;
1164 }
1165
1166 static inline smx_rdv_t simcall_comm_send__get__rdv(smx_simcall_t simcall){
1167   return (smx_rdv_t) simcall->args[1].dp;
1168 }
1169
1170 static inline void simcall_comm_send__set__rdv(smx_simcall_t simcall, void* arg){
1171     simcall->args[1].dp = arg;
1172 }
1173
1174 static inline double simcall_comm_send__get__task_size(smx_simcall_t simcall){
1175   return  simcall->args[2].d;
1176 }
1177
1178 static inline void simcall_comm_send__set__task_size(smx_simcall_t simcall, double arg){
1179     simcall->args[2].d = arg;
1180 }
1181
1182 static inline double simcall_comm_send__get__rate(smx_simcall_t simcall){
1183   return  simcall->args[3].d;
1184 }
1185
1186 static inline void simcall_comm_send__set__rate(smx_simcall_t simcall, double arg){
1187     simcall->args[3].d = arg;
1188 }
1189
1190 static inline void* simcall_comm_send__get__src_buff(smx_simcall_t simcall){
1191   return  simcall->args[4].dp;
1192 }
1193
1194 static inline void simcall_comm_send__set__src_buff(smx_simcall_t simcall, void* arg){
1195     simcall->args[4].dp = arg;
1196 }
1197
1198 static inline size_t simcall_comm_send__get__src_buff_size(smx_simcall_t simcall){
1199   return  simcall->args[5].sz;
1200 }
1201
1202 static inline void simcall_comm_send__set__src_buff_size(smx_simcall_t simcall, size_t arg){
1203     simcall->args[5].sz = arg;
1204 }
1205
1206 static inline simix_match_func_t simcall_comm_send__get__match_fun(smx_simcall_t simcall){
1207   return (simix_match_func_t) simcall->args[6].fp;
1208 }
1209
1210 static inline void simcall_comm_send__set__match_fun(smx_simcall_t simcall, FPtr arg){
1211     simcall->args[6].fp = arg;
1212 }
1213
1214 static inline simix_copy_data_func_t simcall_comm_send__get__copy_data_fun(smx_simcall_t simcall){
1215   return (simix_copy_data_func_t) simcall->args[7].fp;
1216 }
1217
1218 static inline void simcall_comm_send__set__copy_data_fun(smx_simcall_t simcall, FPtr arg){
1219     simcall->args[7].fp = arg;
1220 }
1221
1222 static inline void* simcall_comm_send__get__data(smx_simcall_t simcall){
1223   return  simcall->args[8].dp;
1224 }
1225
1226 static inline void simcall_comm_send__set__data(smx_simcall_t simcall, void* arg){
1227     simcall->args[8].dp = arg;
1228 }
1229
1230 static inline double simcall_comm_send__get__timeout(smx_simcall_t simcall){
1231   return  simcall->args[9].d;
1232 }
1233
1234 static inline void simcall_comm_send__set__timeout(smx_simcall_t simcall, double arg){
1235     simcall->args[9].d = arg;
1236 }
1237
1238 static inline smx_process_t simcall_comm_isend__get__src(smx_simcall_t simcall){
1239   return (smx_process_t) simcall->args[0].dp;
1240 }
1241
1242 static inline void simcall_comm_isend__set__src(smx_simcall_t simcall, void* arg){
1243     simcall->args[0].dp = arg;
1244 }
1245
1246 static inline smx_rdv_t simcall_comm_isend__get__rdv(smx_simcall_t simcall){
1247   return (smx_rdv_t) simcall->args[1].dp;
1248 }
1249
1250 static inline void simcall_comm_isend__set__rdv(smx_simcall_t simcall, void* arg){
1251     simcall->args[1].dp = arg;
1252 }
1253
1254 static inline double simcall_comm_isend__get__task_size(smx_simcall_t simcall){
1255   return  simcall->args[2].d;
1256 }
1257
1258 static inline void simcall_comm_isend__set__task_size(smx_simcall_t simcall, double arg){
1259     simcall->args[2].d = arg;
1260 }
1261
1262 static inline double simcall_comm_isend__get__rate(smx_simcall_t simcall){
1263   return  simcall->args[3].d;
1264 }
1265
1266 static inline void simcall_comm_isend__set__rate(smx_simcall_t simcall, double arg){
1267     simcall->args[3].d = arg;
1268 }
1269
1270 static inline void* simcall_comm_isend__get__src_buff(smx_simcall_t simcall){
1271   return  simcall->args[4].dp;
1272 }
1273
1274 static inline void simcall_comm_isend__set__src_buff(smx_simcall_t simcall, void* arg){
1275     simcall->args[4].dp = arg;
1276 }
1277
1278 static inline size_t simcall_comm_isend__get__src_buff_size(smx_simcall_t simcall){
1279   return  simcall->args[5].sz;
1280 }
1281
1282 static inline void simcall_comm_isend__set__src_buff_size(smx_simcall_t simcall, size_t arg){
1283     simcall->args[5].sz = arg;
1284 }
1285
1286 static inline simix_match_func_t simcall_comm_isend__get__match_fun(smx_simcall_t simcall){
1287   return (simix_match_func_t) simcall->args[6].fp;
1288 }
1289
1290 static inline void simcall_comm_isend__set__match_fun(smx_simcall_t simcall, FPtr arg){
1291     simcall->args[6].fp = arg;
1292 }
1293
1294 static inline simix_clean_func_t simcall_comm_isend__get__clean_fun(smx_simcall_t simcall){
1295   return (simix_clean_func_t) simcall->args[7].fp;
1296 }
1297
1298 static inline void simcall_comm_isend__set__clean_fun(smx_simcall_t simcall, FPtr arg){
1299     simcall->args[7].fp = arg;
1300 }
1301
1302 static inline simix_copy_data_func_t simcall_comm_isend__get__copy_data_fun(smx_simcall_t simcall){
1303   return (simix_copy_data_func_t) simcall->args[8].fp;
1304 }
1305
1306 static inline void simcall_comm_isend__set__copy_data_fun(smx_simcall_t simcall, FPtr arg){
1307     simcall->args[8].fp = arg;
1308 }
1309
1310 static inline void* simcall_comm_isend__get__data(smx_simcall_t simcall){
1311   return  simcall->args[9].dp;
1312 }
1313
1314 static inline void simcall_comm_isend__set__data(smx_simcall_t simcall, void* arg){
1315     simcall->args[9].dp = arg;
1316 }
1317
1318 static inline int simcall_comm_isend__get__detached(smx_simcall_t simcall){
1319   return  simcall->args[10].i;
1320 }
1321
1322 static inline void simcall_comm_isend__set__detached(smx_simcall_t simcall, int arg){
1323     simcall->args[10].i = arg;
1324 }
1325 static inline smx_action_t simcall_comm_isend__get__result(smx_simcall_t simcall){
1326     return (smx_action_t) simcall->result.dp;
1327 }
1328 static inline void simcall_comm_isend__set__result(smx_simcall_t simcall, void* result){
1329     simcall->result.dp = result;
1330 }
1331
1332 static inline smx_rdv_t simcall_comm_recv__get__rdv(smx_simcall_t simcall){
1333   return (smx_rdv_t) simcall->args[0].dp;
1334 }
1335
1336 static inline void simcall_comm_recv__set__rdv(smx_simcall_t simcall, void* arg){
1337     simcall->args[0].dp = arg;
1338 }
1339
1340 static inline void* simcall_comm_recv__get__dst_buff(smx_simcall_t simcall){
1341   return  simcall->args[1].dp;
1342 }
1343
1344 static inline void simcall_comm_recv__set__dst_buff(smx_simcall_t simcall, void* arg){
1345     simcall->args[1].dp = arg;
1346 }
1347
1348 static inline size_t* simcall_comm_recv__get__dst_buff_size(smx_simcall_t simcall){
1349   return (size_t*) simcall->args[2].dp;
1350 }
1351
1352 static inline void simcall_comm_recv__set__dst_buff_size(smx_simcall_t simcall, void* arg){
1353     simcall->args[2].dp = arg;
1354 }
1355
1356 static inline simix_match_func_t simcall_comm_recv__get__match_fun(smx_simcall_t simcall){
1357   return (simix_match_func_t) simcall->args[3].fp;
1358 }
1359
1360 static inline void simcall_comm_recv__set__match_fun(smx_simcall_t simcall, FPtr arg){
1361     simcall->args[3].fp = arg;
1362 }
1363
1364 static inline simix_copy_data_func_t simcall_comm_recv__get__copy_data_fun(smx_simcall_t simcall){
1365   return (simix_copy_data_func_t) simcall->args[4].fp;
1366 }
1367
1368 static inline void simcall_comm_recv__set__copy_data_fun(smx_simcall_t simcall, FPtr arg){
1369     simcall->args[4].fp = arg;
1370 }
1371
1372 static inline void* simcall_comm_recv__get__data(smx_simcall_t simcall){
1373   return  simcall->args[5].dp;
1374 }
1375
1376 static inline void simcall_comm_recv__set__data(smx_simcall_t simcall, void* arg){
1377     simcall->args[5].dp = arg;
1378 }
1379
1380 static inline double simcall_comm_recv__get__timeout(smx_simcall_t simcall){
1381   return  simcall->args[6].d;
1382 }
1383
1384 static inline void simcall_comm_recv__set__timeout(smx_simcall_t simcall, double arg){
1385     simcall->args[6].d = arg;
1386 }
1387
1388 static inline double simcall_comm_recv__get__rate(smx_simcall_t simcall){
1389   return  simcall->args[7].d;
1390 }
1391
1392 static inline void simcall_comm_recv__set__rate(smx_simcall_t simcall, double arg){
1393     simcall->args[7].d = arg;
1394 }
1395
1396 static inline smx_rdv_t simcall_comm_irecv__get__rdv(smx_simcall_t simcall){
1397   return (smx_rdv_t) simcall->args[0].dp;
1398 }
1399
1400 static inline void simcall_comm_irecv__set__rdv(smx_simcall_t simcall, void* arg){
1401     simcall->args[0].dp = arg;
1402 }
1403
1404 static inline void* simcall_comm_irecv__get__dst_buff(smx_simcall_t simcall){
1405   return  simcall->args[1].dp;
1406 }
1407
1408 static inline void simcall_comm_irecv__set__dst_buff(smx_simcall_t simcall, void* arg){
1409     simcall->args[1].dp = arg;
1410 }
1411
1412 static inline size_t* simcall_comm_irecv__get__dst_buff_size(smx_simcall_t simcall){
1413   return (size_t*) simcall->args[2].dp;
1414 }
1415
1416 static inline void simcall_comm_irecv__set__dst_buff_size(smx_simcall_t simcall, void* arg){
1417     simcall->args[2].dp = arg;
1418 }
1419
1420 static inline simix_match_func_t simcall_comm_irecv__get__match_fun(smx_simcall_t simcall){
1421   return (simix_match_func_t) simcall->args[3].fp;
1422 }
1423
1424 static inline void simcall_comm_irecv__set__match_fun(smx_simcall_t simcall, FPtr arg){
1425     simcall->args[3].fp = arg;
1426 }
1427
1428 static inline simix_copy_data_func_t simcall_comm_irecv__get__copy_data_fun(smx_simcall_t simcall){
1429   return (simix_copy_data_func_t) simcall->args[4].fp;
1430 }
1431
1432 static inline void simcall_comm_irecv__set__copy_data_fun(smx_simcall_t simcall, FPtr arg){
1433     simcall->args[4].fp = arg;
1434 }
1435
1436 static inline void* simcall_comm_irecv__get__data(smx_simcall_t simcall){
1437   return  simcall->args[5].dp;
1438 }
1439
1440 static inline void simcall_comm_irecv__set__data(smx_simcall_t simcall, void* arg){
1441     simcall->args[5].dp = arg;
1442 }
1443
1444 static inline double simcall_comm_irecv__get__rate(smx_simcall_t simcall){
1445   return  simcall->args[6].d;
1446 }
1447
1448 static inline void simcall_comm_irecv__set__rate(smx_simcall_t simcall, double arg){
1449     simcall->args[6].d = arg;
1450 }
1451 static inline smx_action_t simcall_comm_irecv__get__result(smx_simcall_t simcall){
1452     return (smx_action_t) simcall->result.dp;
1453 }
1454 static inline void simcall_comm_irecv__set__result(smx_simcall_t simcall, void* result){
1455     simcall->result.dp = result;
1456 }
1457
1458 static inline smx_action_t simcall_comm_cancel__get__comm(smx_simcall_t simcall){
1459   return (smx_action_t) simcall->args[0].dp;
1460 }
1461
1462 static inline void simcall_comm_cancel__set__comm(smx_simcall_t simcall, void* arg){
1463     simcall->args[0].dp = arg;
1464 }
1465
1466 static inline xbt_dynar_t simcall_comm_waitany__get__comms(smx_simcall_t simcall){
1467   return (xbt_dynar_t) simcall->args[0].dp;
1468 }
1469
1470 static inline void simcall_comm_waitany__set__comms(smx_simcall_t simcall, void* arg){
1471     simcall->args[0].dp = arg;
1472 }
1473 static inline int simcall_comm_waitany__get__result(smx_simcall_t simcall){
1474     return  simcall->result.i;
1475 }
1476 static inline void simcall_comm_waitany__set__result(smx_simcall_t simcall, int result){
1477     simcall->result.i = result;
1478 }
1479
1480 static inline smx_action_t simcall_comm_wait__get__comm(smx_simcall_t simcall){
1481   return (smx_action_t) simcall->args[0].dp;
1482 }
1483
1484 static inline void simcall_comm_wait__set__comm(smx_simcall_t simcall, void* arg){
1485     simcall->args[0].dp = arg;
1486 }
1487
1488 static inline double simcall_comm_wait__get__timeout(smx_simcall_t simcall){
1489   return  simcall->args[1].d;
1490 }
1491
1492 static inline void simcall_comm_wait__set__timeout(smx_simcall_t simcall, double arg){
1493     simcall->args[1].d = arg;
1494 }
1495
1496 static inline smx_action_t simcall_comm_test__get__comm(smx_simcall_t simcall){
1497   return (smx_action_t) simcall->args[0].dp;
1498 }
1499
1500 static inline void simcall_comm_test__set__comm(smx_simcall_t simcall, void* arg){
1501     simcall->args[0].dp = arg;
1502 }
1503 static inline int simcall_comm_test__get__result(smx_simcall_t simcall){
1504     return  simcall->result.i;
1505 }
1506 static inline void simcall_comm_test__set__result(smx_simcall_t simcall, int result){
1507     simcall->result.i = result;
1508 }
1509
1510 static inline xbt_dynar_t simcall_comm_testany__get__comms(smx_simcall_t simcall){
1511   return (xbt_dynar_t) simcall->args[0].dp;
1512 }
1513
1514 static inline void simcall_comm_testany__set__comms(smx_simcall_t simcall, void* arg){
1515     simcall->args[0].dp = arg;
1516 }
1517 static inline int simcall_comm_testany__get__result(smx_simcall_t simcall){
1518     return  simcall->result.i;
1519 }
1520 static inline void simcall_comm_testany__set__result(smx_simcall_t simcall, int result){
1521     simcall->result.i = result;
1522 }
1523
1524 static inline smx_action_t simcall_comm_get_remains__get__comm(smx_simcall_t simcall){
1525   return (smx_action_t) simcall->args[0].dp;
1526 }
1527
1528 static inline void simcall_comm_get_remains__set__comm(smx_simcall_t simcall, void* arg){
1529     simcall->args[0].dp = arg;
1530 }
1531 static inline double simcall_comm_get_remains__get__result(smx_simcall_t simcall){
1532     return  simcall->result.d;
1533 }
1534 static inline void simcall_comm_get_remains__set__result(smx_simcall_t simcall, double result){
1535     simcall->result.d = result;
1536 }
1537
1538 static inline smx_action_t simcall_comm_get_state__get__comm(smx_simcall_t simcall){
1539   return (smx_action_t) simcall->args[0].dp;
1540 }
1541
1542 static inline void simcall_comm_get_state__set__comm(smx_simcall_t simcall, void* arg){
1543     simcall->args[0].dp = arg;
1544 }
1545 static inline int simcall_comm_get_state__get__result(smx_simcall_t simcall){
1546     return  simcall->result.i;
1547 }
1548 static inline void simcall_comm_get_state__set__result(smx_simcall_t simcall, int result){
1549     simcall->result.i = result;
1550 }
1551
1552 static inline smx_action_t simcall_comm_get_src_data__get__comm(smx_simcall_t simcall){
1553   return (smx_action_t) simcall->args[0].dp;
1554 }
1555
1556 static inline void simcall_comm_get_src_data__set__comm(smx_simcall_t simcall, void* arg){
1557     simcall->args[0].dp = arg;
1558 }
1559 static inline void* simcall_comm_get_src_data__get__result(smx_simcall_t simcall){
1560     return  simcall->result.dp;
1561 }
1562 static inline void simcall_comm_get_src_data__set__result(smx_simcall_t simcall, void* result){
1563     simcall->result.dp = result;
1564 }
1565
1566 static inline smx_action_t simcall_comm_get_dst_data__get__comm(smx_simcall_t simcall){
1567   return (smx_action_t) simcall->args[0].dp;
1568 }
1569
1570 static inline void simcall_comm_get_dst_data__set__comm(smx_simcall_t simcall, void* arg){
1571     simcall->args[0].dp = arg;
1572 }
1573 static inline void* simcall_comm_get_dst_data__get__result(smx_simcall_t simcall){
1574     return  simcall->result.dp;
1575 }
1576 static inline void simcall_comm_get_dst_data__set__result(smx_simcall_t simcall, void* result){
1577     simcall->result.dp = result;
1578 }
1579
1580 static inline smx_action_t simcall_comm_get_src_proc__get__comm(smx_simcall_t simcall){
1581   return (smx_action_t) simcall->args[0].dp;
1582 }
1583
1584 static inline void simcall_comm_get_src_proc__set__comm(smx_simcall_t simcall, void* arg){
1585     simcall->args[0].dp = arg;
1586 }
1587 static inline smx_process_t simcall_comm_get_src_proc__get__result(smx_simcall_t simcall){
1588     return (smx_process_t) simcall->result.dp;
1589 }
1590 static inline void simcall_comm_get_src_proc__set__result(smx_simcall_t simcall, void* result){
1591     simcall->result.dp = result;
1592 }
1593
1594 static inline smx_action_t simcall_comm_get_dst_proc__get__comm(smx_simcall_t simcall){
1595   return (smx_action_t) simcall->args[0].dp;
1596 }
1597
1598 static inline void simcall_comm_get_dst_proc__set__comm(smx_simcall_t simcall, void* arg){
1599     simcall->args[0].dp = arg;
1600 }
1601 static inline smx_process_t simcall_comm_get_dst_proc__get__result(smx_simcall_t simcall){
1602     return (smx_process_t) simcall->result.dp;
1603 }
1604 static inline void simcall_comm_get_dst_proc__set__result(smx_simcall_t simcall, void* result){
1605     simcall->result.dp = result;
1606 }
1607 static inline smx_mutex_t simcall_mutex_init__get__result(smx_simcall_t simcall){
1608     return (smx_mutex_t) simcall->result.dp;
1609 }
1610 static inline void simcall_mutex_init__set__result(smx_simcall_t simcall, void* result){
1611     simcall->result.dp = result;
1612 }
1613
1614 static inline smx_mutex_t simcall_mutex_destroy__get__mutex(smx_simcall_t simcall){
1615   return (smx_mutex_t) simcall->args[0].dp;
1616 }
1617
1618 static inline void simcall_mutex_destroy__set__mutex(smx_simcall_t simcall, void* arg){
1619     simcall->args[0].dp = arg;
1620 }
1621
1622 static inline smx_mutex_t simcall_mutex_lock__get__mutex(smx_simcall_t simcall){
1623   return (smx_mutex_t) simcall->args[0].dp;
1624 }
1625
1626 static inline void simcall_mutex_lock__set__mutex(smx_simcall_t simcall, void* arg){
1627     simcall->args[0].dp = arg;
1628 }
1629
1630 static inline smx_mutex_t simcall_mutex_trylock__get__mutex(smx_simcall_t simcall){
1631   return (smx_mutex_t) simcall->args[0].dp;
1632 }
1633
1634 static inline void simcall_mutex_trylock__set__mutex(smx_simcall_t simcall, void* arg){
1635     simcall->args[0].dp = arg;
1636 }
1637 static inline int simcall_mutex_trylock__get__result(smx_simcall_t simcall){
1638     return  simcall->result.i;
1639 }
1640 static inline void simcall_mutex_trylock__set__result(smx_simcall_t simcall, int result){
1641     simcall->result.i = result;
1642 }
1643
1644 static inline smx_mutex_t simcall_mutex_unlock__get__mutex(smx_simcall_t simcall){
1645   return (smx_mutex_t) simcall->args[0].dp;
1646 }
1647
1648 static inline void simcall_mutex_unlock__set__mutex(smx_simcall_t simcall, void* arg){
1649     simcall->args[0].dp = arg;
1650 }
1651 static inline smx_cond_t simcall_cond_init__get__result(smx_simcall_t simcall){
1652     return (smx_cond_t) simcall->result.dp;
1653 }
1654 static inline void simcall_cond_init__set__result(smx_simcall_t simcall, void* result){
1655     simcall->result.dp = result;
1656 }
1657
1658 static inline smx_cond_t simcall_cond_destroy__get__cond(smx_simcall_t simcall){
1659   return (smx_cond_t) simcall->args[0].dp;
1660 }
1661
1662 static inline void simcall_cond_destroy__set__cond(smx_simcall_t simcall, void* arg){
1663     simcall->args[0].dp = arg;
1664 }
1665
1666 static inline smx_cond_t simcall_cond_signal__get__cond(smx_simcall_t simcall){
1667   return (smx_cond_t) simcall->args[0].dp;
1668 }
1669
1670 static inline void simcall_cond_signal__set__cond(smx_simcall_t simcall, void* arg){
1671     simcall->args[0].dp = arg;
1672 }
1673
1674 static inline smx_cond_t simcall_cond_wait__get__cond(smx_simcall_t simcall){
1675   return (smx_cond_t) simcall->args[0].dp;
1676 }
1677
1678 static inline void simcall_cond_wait__set__cond(smx_simcall_t simcall, void* arg){
1679     simcall->args[0].dp = arg;
1680 }
1681
1682 static inline smx_mutex_t simcall_cond_wait__get__mutex(smx_simcall_t simcall){
1683   return (smx_mutex_t) simcall->args[1].dp;
1684 }
1685
1686 static inline void simcall_cond_wait__set__mutex(smx_simcall_t simcall, void* arg){
1687     simcall->args[1].dp = arg;
1688 }
1689
1690 static inline smx_cond_t simcall_cond_wait_timeout__get__cond(smx_simcall_t simcall){
1691   return (smx_cond_t) simcall->args[0].dp;
1692 }
1693
1694 static inline void simcall_cond_wait_timeout__set__cond(smx_simcall_t simcall, void* arg){
1695     simcall->args[0].dp = arg;
1696 }
1697
1698 static inline smx_mutex_t simcall_cond_wait_timeout__get__mutex(smx_simcall_t simcall){
1699   return (smx_mutex_t) simcall->args[1].dp;
1700 }
1701
1702 static inline void simcall_cond_wait_timeout__set__mutex(smx_simcall_t simcall, void* arg){
1703     simcall->args[1].dp = arg;
1704 }
1705
1706 static inline double simcall_cond_wait_timeout__get__timeout(smx_simcall_t simcall){
1707   return  simcall->args[2].d;
1708 }
1709
1710 static inline void simcall_cond_wait_timeout__set__timeout(smx_simcall_t simcall, double arg){
1711     simcall->args[2].d = arg;
1712 }
1713
1714 static inline smx_cond_t simcall_cond_broadcast__get__cond(smx_simcall_t simcall){
1715   return (smx_cond_t) simcall->args[0].dp;
1716 }
1717
1718 static inline void simcall_cond_broadcast__set__cond(smx_simcall_t simcall, void* arg){
1719     simcall->args[0].dp = arg;
1720 }
1721
1722 static inline int simcall_sem_init__get__capacity(smx_simcall_t simcall){
1723   return  simcall->args[0].i;
1724 }
1725
1726 static inline void simcall_sem_init__set__capacity(smx_simcall_t simcall, int arg){
1727     simcall->args[0].i = arg;
1728 }
1729 static inline smx_sem_t simcall_sem_init__get__result(smx_simcall_t simcall){
1730     return (smx_sem_t) simcall->result.dp;
1731 }
1732 static inline void simcall_sem_init__set__result(smx_simcall_t simcall, void* result){
1733     simcall->result.dp = result;
1734 }
1735
1736 static inline smx_sem_t simcall_sem_destroy__get__sem(smx_simcall_t simcall){
1737   return (smx_sem_t) simcall->args[0].dp;
1738 }
1739
1740 static inline void simcall_sem_destroy__set__sem(smx_simcall_t simcall, void* arg){
1741     simcall->args[0].dp = arg;
1742 }
1743
1744 static inline smx_sem_t simcall_sem_release__get__sem(smx_simcall_t simcall){
1745   return (smx_sem_t) simcall->args[0].dp;
1746 }
1747
1748 static inline void simcall_sem_release__set__sem(smx_simcall_t simcall, void* arg){
1749     simcall->args[0].dp = arg;
1750 }
1751
1752 static inline smx_sem_t simcall_sem_would_block__get__sem(smx_simcall_t simcall){
1753   return (smx_sem_t) simcall->args[0].dp;
1754 }
1755
1756 static inline void simcall_sem_would_block__set__sem(smx_simcall_t simcall, void* arg){
1757     simcall->args[0].dp = arg;
1758 }
1759 static inline int simcall_sem_would_block__get__result(smx_simcall_t simcall){
1760     return  simcall->result.i;
1761 }
1762 static inline void simcall_sem_would_block__set__result(smx_simcall_t simcall, int result){
1763     simcall->result.i = result;
1764 }
1765
1766 static inline smx_sem_t simcall_sem_acquire__get__sem(smx_simcall_t simcall){
1767   return (smx_sem_t) simcall->args[0].dp;
1768 }
1769
1770 static inline void simcall_sem_acquire__set__sem(smx_simcall_t simcall, void* arg){
1771     simcall->args[0].dp = arg;
1772 }
1773
1774 static inline smx_sem_t simcall_sem_acquire_timeout__get__sem(smx_simcall_t simcall){
1775   return (smx_sem_t) simcall->args[0].dp;
1776 }
1777
1778 static inline void simcall_sem_acquire_timeout__set__sem(smx_simcall_t simcall, void* arg){
1779     simcall->args[0].dp = arg;
1780 }
1781
1782 static inline double simcall_sem_acquire_timeout__get__timeout(smx_simcall_t simcall){
1783   return  simcall->args[1].d;
1784 }
1785
1786 static inline void simcall_sem_acquire_timeout__set__timeout(smx_simcall_t simcall, double arg){
1787     simcall->args[1].d = arg;
1788 }
1789
1790 static inline smx_sem_t simcall_sem_get_capacity__get__sem(smx_simcall_t simcall){
1791   return (smx_sem_t) simcall->args[0].dp;
1792 }
1793
1794 static inline void simcall_sem_get_capacity__set__sem(smx_simcall_t simcall, void* arg){
1795     simcall->args[0].dp = arg;
1796 }
1797 static inline int simcall_sem_get_capacity__get__result(smx_simcall_t simcall){
1798     return  simcall->result.i;
1799 }
1800 static inline void simcall_sem_get_capacity__set__result(smx_simcall_t simcall, int result){
1801     simcall->result.i = result;
1802 }
1803
1804 static inline smx_file_t simcall_file_read__get__fd(smx_simcall_t simcall){
1805   return (smx_file_t) simcall->args[0].dp;
1806 }
1807
1808 static inline void simcall_file_read__set__fd(smx_simcall_t simcall, void* arg){
1809     simcall->args[0].dp = arg;
1810 }
1811
1812 static inline sg_size_t simcall_file_read__get__size(smx_simcall_t simcall){
1813   return  simcall->args[1].sgsz;
1814 }
1815
1816 static inline void simcall_file_read__set__size(smx_simcall_t simcall, sg_size_t arg){
1817     simcall->args[1].sgsz = arg;
1818 }
1819
1820 static inline smx_host_t simcall_file_read__get__host(smx_simcall_t simcall){
1821   return (smx_host_t) simcall->args[2].dp;
1822 }
1823
1824 static inline void simcall_file_read__set__host(smx_simcall_t simcall, void* arg){
1825     simcall->args[2].dp = arg;
1826 }
1827 static inline sg_size_t simcall_file_read__get__result(smx_simcall_t simcall){
1828     return  simcall->result.sgsz;
1829 }
1830 static inline void simcall_file_read__set__result(smx_simcall_t simcall, sg_size_t result){
1831     simcall->result.sgsz = result;
1832 }
1833
1834 static inline smx_file_t simcall_file_write__get__fd(smx_simcall_t simcall){
1835   return (smx_file_t) simcall->args[0].dp;
1836 }
1837
1838 static inline void simcall_file_write__set__fd(smx_simcall_t simcall, void* arg){
1839     simcall->args[0].dp = arg;
1840 }
1841
1842 static inline sg_size_t simcall_file_write__get__size(smx_simcall_t simcall){
1843   return  simcall->args[1].sgsz;
1844 }
1845
1846 static inline void simcall_file_write__set__size(smx_simcall_t simcall, sg_size_t arg){
1847     simcall->args[1].sgsz = arg;
1848 }
1849
1850 static inline smx_host_t simcall_file_write__get__host(smx_simcall_t simcall){
1851   return (smx_host_t) simcall->args[2].dp;
1852 }
1853
1854 static inline void simcall_file_write__set__host(smx_simcall_t simcall, void* arg){
1855     simcall->args[2].dp = arg;
1856 }
1857 static inline sg_size_t simcall_file_write__get__result(smx_simcall_t simcall){
1858     return  simcall->result.sgsz;
1859 }
1860 static inline void simcall_file_write__set__result(smx_simcall_t simcall, sg_size_t result){
1861     simcall->result.sgsz = result;
1862 }
1863
1864 static inline const char* simcall_file_open__get__fullpath(smx_simcall_t simcall){
1865   return  simcall->args[0].cc;
1866 }
1867
1868 static inline void simcall_file_open__set__fullpath(smx_simcall_t simcall, const char* arg){
1869     simcall->args[0].cc = arg;
1870 }
1871
1872 static inline smx_host_t simcall_file_open__get__host(smx_simcall_t simcall){
1873   return (smx_host_t) simcall->args[1].dp;
1874 }
1875
1876 static inline void simcall_file_open__set__host(smx_simcall_t simcall, void* arg){
1877     simcall->args[1].dp = arg;
1878 }
1879 static inline smx_file_t simcall_file_open__get__result(smx_simcall_t simcall){
1880     return (smx_file_t) simcall->result.dp;
1881 }
1882 static inline void simcall_file_open__set__result(smx_simcall_t simcall, void* result){
1883     simcall->result.dp = result;
1884 }
1885
1886 static inline smx_file_t simcall_file_close__get__fd(smx_simcall_t simcall){
1887   return (smx_file_t) simcall->args[0].dp;
1888 }
1889
1890 static inline void simcall_file_close__set__fd(smx_simcall_t simcall, void* arg){
1891     simcall->args[0].dp = arg;
1892 }
1893
1894 static inline smx_host_t simcall_file_close__get__host(smx_simcall_t simcall){
1895   return (smx_host_t) simcall->args[1].dp;
1896 }
1897
1898 static inline void simcall_file_close__set__host(smx_simcall_t simcall, void* arg){
1899     simcall->args[1].dp = arg;
1900 }
1901 static inline int simcall_file_close__get__result(smx_simcall_t simcall){
1902     return  simcall->result.i;
1903 }
1904 static inline void simcall_file_close__set__result(smx_simcall_t simcall, int result){
1905     simcall->result.i = result;
1906 }
1907
1908 static inline smx_file_t simcall_file_unlink__get__fd(smx_simcall_t simcall){
1909   return (smx_file_t) simcall->args[0].dp;
1910 }
1911
1912 static inline void simcall_file_unlink__set__fd(smx_simcall_t simcall, void* arg){
1913     simcall->args[0].dp = arg;
1914 }
1915
1916 static inline smx_host_t simcall_file_unlink__get__host(smx_simcall_t simcall){
1917   return (smx_host_t) simcall->args[1].dp;
1918 }
1919
1920 static inline void simcall_file_unlink__set__host(smx_simcall_t simcall, void* arg){
1921     simcall->args[1].dp = arg;
1922 }
1923 static inline int simcall_file_unlink__get__result(smx_simcall_t simcall){
1924     return  simcall->result.i;
1925 }
1926 static inline void simcall_file_unlink__set__result(smx_simcall_t simcall, int result){
1927     simcall->result.i = result;
1928 }
1929
1930 static inline smx_file_t simcall_file_get_size__get__fd(smx_simcall_t simcall){
1931   return (smx_file_t) simcall->args[0].dp;
1932 }
1933
1934 static inline void simcall_file_get_size__set__fd(smx_simcall_t simcall, void* arg){
1935     simcall->args[0].dp = arg;
1936 }
1937 static inline sg_size_t simcall_file_get_size__get__result(smx_simcall_t simcall){
1938     return  simcall->result.sgsz;
1939 }
1940 static inline void simcall_file_get_size__set__result(smx_simcall_t simcall, sg_size_t result){
1941     simcall->result.sgsz = result;
1942 }
1943
1944 static inline smx_file_t simcall_file_tell__get__fd(smx_simcall_t simcall){
1945   return (smx_file_t) simcall->args[0].dp;
1946 }
1947
1948 static inline void simcall_file_tell__set__fd(smx_simcall_t simcall, void* arg){
1949     simcall->args[0].dp = arg;
1950 }
1951 static inline sg_size_t simcall_file_tell__get__result(smx_simcall_t simcall){
1952     return  simcall->result.sgsz;
1953 }
1954 static inline void simcall_file_tell__set__result(smx_simcall_t simcall, sg_size_t result){
1955     simcall->result.sgsz = result;
1956 }
1957
1958 static inline smx_file_t simcall_file_seek__get__fd(smx_simcall_t simcall){
1959   return (smx_file_t) simcall->args[0].dp;
1960 }
1961
1962 static inline void simcall_file_seek__set__fd(smx_simcall_t simcall, void* arg){
1963     simcall->args[0].dp = arg;
1964 }
1965
1966 static inline sg_offset_t simcall_file_seek__get__offset(smx_simcall_t simcall){
1967   return  simcall->args[1].sgoff;
1968 }
1969
1970 static inline void simcall_file_seek__set__offset(smx_simcall_t simcall, sg_offset_t arg){
1971     simcall->args[1].sgoff = arg;
1972 }
1973
1974 static inline int simcall_file_seek__get__origin(smx_simcall_t simcall){
1975   return  simcall->args[2].i;
1976 }
1977
1978 static inline void simcall_file_seek__set__origin(smx_simcall_t simcall, int arg){
1979     simcall->args[2].i = arg;
1980 }
1981 static inline int simcall_file_seek__get__result(smx_simcall_t simcall){
1982     return  simcall->result.i;
1983 }
1984 static inline void simcall_file_seek__set__result(smx_simcall_t simcall, int result){
1985     simcall->result.i = result;
1986 }
1987
1988 static inline smx_file_t simcall_file_get_info__get__fd(smx_simcall_t simcall){
1989   return (smx_file_t) simcall->args[0].dp;
1990 }
1991
1992 static inline void simcall_file_get_info__set__fd(smx_simcall_t simcall, void* arg){
1993     simcall->args[0].dp = arg;
1994 }
1995 static inline xbt_dynar_t simcall_file_get_info__get__result(smx_simcall_t simcall){
1996     return (xbt_dynar_t) simcall->result.dp;
1997 }
1998 static inline void simcall_file_get_info__set__result(smx_simcall_t simcall, void* result){
1999     simcall->result.dp = result;
2000 }
2001
2002 static inline smx_file_t simcall_file_move__get__fd(smx_simcall_t simcall){
2003   return (smx_file_t) simcall->args[0].dp;
2004 }
2005
2006 static inline void simcall_file_move__set__fd(smx_simcall_t simcall, void* arg){
2007     simcall->args[0].dp = arg;
2008 }
2009
2010 static inline const char* simcall_file_move__get__fullpath(smx_simcall_t simcall){
2011   return  simcall->args[1].cc;
2012 }
2013
2014 static inline void simcall_file_move__set__fullpath(smx_simcall_t simcall, const char* arg){
2015     simcall->args[1].cc = arg;
2016 }
2017 static inline int simcall_file_move__get__result(smx_simcall_t simcall){
2018     return  simcall->result.i;
2019 }
2020 static inline void simcall_file_move__set__result(smx_simcall_t simcall, int result){
2021     simcall->result.i = result;
2022 }
2023
2024 static inline smx_storage_t simcall_storage_get_free_size__get__storage(smx_simcall_t simcall){
2025   return (smx_storage_t) simcall->args[0].dp;
2026 }
2027
2028 static inline void simcall_storage_get_free_size__set__storage(smx_simcall_t simcall, void* arg){
2029     simcall->args[0].dp = arg;
2030 }
2031 static inline sg_size_t simcall_storage_get_free_size__get__result(smx_simcall_t simcall){
2032     return  simcall->result.sgsz;
2033 }
2034 static inline void simcall_storage_get_free_size__set__result(smx_simcall_t simcall, sg_size_t result){
2035     simcall->result.sgsz = result;
2036 }
2037
2038 static inline smx_storage_t simcall_storage_get_used_size__get__name(smx_simcall_t simcall){
2039   return (smx_storage_t) simcall->args[0].dp;
2040 }
2041
2042 static inline void simcall_storage_get_used_size__set__name(smx_simcall_t simcall, void* arg){
2043     simcall->args[0].dp = arg;
2044 }
2045 static inline sg_size_t simcall_storage_get_used_size__get__result(smx_simcall_t simcall){
2046     return  simcall->result.sgsz;
2047 }
2048 static inline void simcall_storage_get_used_size__set__result(smx_simcall_t simcall, sg_size_t result){
2049     simcall->result.sgsz = result;
2050 }
2051
2052 static inline smx_storage_t simcall_storage_get_properties__get__storage(smx_simcall_t simcall){
2053   return (smx_storage_t) simcall->args[0].dp;
2054 }
2055
2056 static inline void simcall_storage_get_properties__set__storage(smx_simcall_t simcall, void* arg){
2057     simcall->args[0].dp = arg;
2058 }
2059 static inline xbt_dict_t simcall_storage_get_properties__get__result(smx_simcall_t simcall){
2060     return (xbt_dict_t) simcall->result.dp;
2061 }
2062 static inline void simcall_storage_get_properties__set__result(smx_simcall_t simcall, void* result){
2063     simcall->result.dp = result;
2064 }
2065
2066 static inline smx_storage_t simcall_storage_get_content__get__storage(smx_simcall_t simcall){
2067   return (smx_storage_t) simcall->args[0].dp;
2068 }
2069
2070 static inline void simcall_storage_get_content__set__storage(smx_simcall_t simcall, void* arg){
2071     simcall->args[0].dp = arg;
2072 }
2073 static inline xbt_dict_t simcall_storage_get_content__get__result(smx_simcall_t simcall){
2074     return (xbt_dict_t) simcall->result.dp;
2075 }
2076 static inline void simcall_storage_get_content__set__result(smx_simcall_t simcall, void* result){
2077     simcall->result.dp = result;
2078 }
2079
2080 static inline const char* simcall_asr_get_properties__get__name(smx_simcall_t simcall){
2081   return  simcall->args[0].cc;
2082 }
2083
2084 static inline void simcall_asr_get_properties__set__name(smx_simcall_t simcall, const char* arg){
2085     simcall->args[0].cc = arg;
2086 }
2087 static inline xbt_dict_t simcall_asr_get_properties__get__result(smx_simcall_t simcall){
2088     return (xbt_dict_t) simcall->result.dp;
2089 }
2090 static inline void simcall_asr_get_properties__set__result(smx_simcall_t simcall, void* result){
2091     simcall->result.dp = result;
2092 }
2093 #ifdef HAVE_LATENCY_BOUND_TRACKING
2094
2095 static inline smx_action_t simcall_comm_is_latency_bounded__get__comm(smx_simcall_t simcall){
2096   return (smx_action_t) simcall->args[0].dp;
2097 }
2098
2099 static inline void simcall_comm_is_latency_bounded__set__comm(smx_simcall_t simcall, void* arg){
2100     simcall->args[0].dp = arg;
2101 }
2102 static inline int simcall_comm_is_latency_bounded__get__result(smx_simcall_t simcall){
2103     return  simcall->result.i;
2104 }
2105 static inline void simcall_comm_is_latency_bounded__set__result(smx_simcall_t simcall, int result){
2106     simcall->result.i = result;
2107 }
2108 #endif
2109
2110 #ifdef HAVE_TRACING
2111
2112 static inline smx_action_t simcall_set_category__get__action(smx_simcall_t simcall){
2113   return (smx_action_t) simcall->args[0].dp;
2114 }
2115
2116 static inline void simcall_set_category__set__action(smx_simcall_t simcall, void* arg){
2117     simcall->args[0].dp = arg;
2118 }
2119
2120 static inline const char* simcall_set_category__get__category(smx_simcall_t simcall){
2121   return  simcall->args[1].cc;
2122 }
2123
2124 static inline void simcall_set_category__set__category(smx_simcall_t simcall, const char* arg){
2125     simcall->args[1].cc = arg;
2126 }
2127 #endif
2128
2129 #ifdef HAVE_MC
2130 static inline void* simcall_mc_snapshot__get__result(smx_simcall_t simcall){
2131     return  simcall->result.dp;
2132 }
2133 static inline void simcall_mc_snapshot__set__result(smx_simcall_t simcall, void* result){
2134     simcall->result.dp = result;
2135 }
2136
2137 static inline void* simcall_mc_compare_snapshots__get__s1(smx_simcall_t simcall){
2138   return  simcall->args[0].dp;
2139 }
2140
2141 static inline void simcall_mc_compare_snapshots__set__s1(smx_simcall_t simcall, void* arg){
2142     simcall->args[0].dp = arg;
2143 }
2144
2145 static inline void* simcall_mc_compare_snapshots__get__s2(smx_simcall_t simcall){
2146   return  simcall->args[1].dp;
2147 }
2148
2149 static inline void simcall_mc_compare_snapshots__set__s2(smx_simcall_t simcall, void* arg){
2150     simcall->args[1].dp = arg;
2151 }
2152 static inline int simcall_mc_compare_snapshots__get__result(smx_simcall_t simcall){
2153     return  simcall->result.i;
2154 }
2155 static inline void simcall_mc_compare_snapshots__set__result(smx_simcall_t simcall, int result){
2156     simcall->result.i = result;
2157 }
2158
2159 static inline int simcall_mc_random__get__min(smx_simcall_t simcall){
2160   return  simcall->args[0].i;
2161 }
2162
2163 static inline void simcall_mc_random__set__min(smx_simcall_t simcall, int arg){
2164     simcall->args[0].i = arg;
2165 }
2166
2167 static inline int simcall_mc_random__get__max(smx_simcall_t simcall){
2168   return  simcall->args[1].i;
2169 }
2170
2171 static inline void simcall_mc_random__set__max(smx_simcall_t simcall, int arg){
2172     simcall->args[1].i = arg;
2173 }
2174 static inline int simcall_mc_random__get__result(smx_simcall_t simcall){
2175     return  simcall->result.i;
2176 }
2177 static inline void simcall_mc_random__set__result(smx_simcall_t simcall, int result){
2178     simcall->result.i = result;
2179 }
2180 #endif