Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
[simix] Remove lots of simcalls, use run_kernel instead
[simgrid.git] / src / simix / libsmx.cpp
1 /* libsmx.c - public interface to simix                                       */
2 /* --------                                                                   */
3 /* These functions are the only ones that are visible from the higher levels  */
4 /* (most of them simply add some documentation to the generated simcall body) */
5 /*                                                                            */
6 /* This is somehow the "libc" of SimGrid                                      */
7
8 /* Copyright (c) 2010-2015. The SimGrid Team.
9  * All rights reserved.                                                     */
10
11 /* This program is free software; you can redistribute it and/or modify it
12  * under the terms of the license (GNU LGPL) which comes with this package. */
13
14 #include <functional>
15
16 #include "src/mc/mc_replay.h"
17 #include "smx_private.h"
18 #include "src/mc/mc_forward.h"
19 #include "xbt/ex.h"
20 #include <math.h>         /* isfinite() */
21 #include "mc/mc.h"
22 #include "src/simix/smx_host_private.h"
23
24 #include <simgrid/simix.hpp>
25
26 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix);
27
28 #include "popping_bodies.cpp"
29
30 /**
31  * \ingroup simix_host_management
32  * \brief Start the host if it is off
33  *
34  * \param host A SIMIX host
35  */
36 void simcall_host_on(sg_host_t host)
37 {
38   return simgrid::simix::kernel(std::bind(SIMIX_host_on, host));
39 }
40
41 /**
42  * \ingroup simix_host_management
43  * \brief Stop the host if it is on
44  *
45  * \param host A SIMIX host
46  */
47 void simcall_host_off(sg_host_t host)
48 {
49   simcall_BODY_host_off(host);
50 }
51
52 /**
53  * \ingroup simix_host_management
54  * \brief Returns a dict of the properties assigned to a host.
55  *
56  * \param host A host
57  * \return The properties of this host
58  */
59 xbt_dict_t simcall_host_get_properties(sg_host_t host)
60 {
61   return simgrid::simix::kernel(std::bind(SIMIX_host_get_properties, host));
62 }
63
64 /**
65  * \ingroup simix_host_management
66  * \brief Returns a dict of the properties assigned to a router or AS.
67  *
68  * \param name The name of the router or AS
69  * \return The properties
70  */
71 xbt_dict_t simcall_asr_get_properties(const char *name)
72 {
73   return simcall_BODY_asr_get_properties(name);
74 }
75
76 /**
77  * \ingroup simix_host_management
78  * \brief Returns the list of processes attached to the host.
79  *
80  * \param host A SIMIX host
81  * \return the swag of attached processes
82  */
83 xbt_swag_t simcall_host_get_process_list(sg_host_t host)
84 {
85   return simgrid::simix::kernel(std::bind(SIMIX_host_get_process_list, host));
86 }
87
88 /**
89  * \ingroup simix_host_management
90  * \brief Returns the power peak of a host.
91  *
92  * \param host A SIMIX host
93  * \return the current power peak value (double)
94  */
95 double simcall_host_get_current_power_peak(sg_host_t host)
96 {
97   return simgrid::simix::kernel(
98     std::bind(SIMIX_host_get_current_power_peak, host));
99 }
100
101 /**
102  * \ingroup simix_host_management
103  * \brief Returns one power peak (in flops/s) of a host at a given pstate
104  *
105  * \param host A SIMIX host
106  * \param pstate_index pstate to test
107  * \return the current power peak value (double) for pstate_index
108  */
109 double simcall_host_get_power_peak_at(sg_host_t host, int pstate_index)
110 {
111   return simgrid::simix::kernel(
112     std::bind(SIMIX_host_get_power_peak_at, host, pstate_index));
113 }
114
115 /**
116  * \ingroup simix_host_management
117  * \brief Sets the pstate at which the host should run
118  *
119  * \param host A SIMIX host
120  * \param pstate_index The pstate to which the CPU power will be set
121  */
122 void simcall_host_set_pstate(sg_host_t host, int pstate_index)
123 {
124   simgrid::simix::kernel(
125     std::bind(SIMIX_host_set_pstate, host, pstate_index));
126 }
127
128 /** \ingroup simix_host_management
129  * \brief Returns the amount of watt dissipated at the given pstate when the host is idling
130  */
131 double simcall_host_get_wattmin_at(msg_host_t host, int pstate)
132 {
133   return simgrid::simix::kernel(
134     std::bind(SIMIX_host_get_wattmin_at, host, pstate));
135 }
136
137 /** \ingroup simix_host_management
138  * \brief Returns the amount of watt dissipated at the given pstate when the host burns CPU at 100%
139  */
140 double simcall_host_get_wattmax_at(msg_host_t host, int pstate)
141 {
142   return simgrid::simix::kernel(
143     std::bind(SIMIX_host_get_wattmax_at, host, pstate));
144 }
145
146
147
148 /**
149  * \ingroup simix_process_management
150  * \brief Creates a synchro that executes some computation of an host.
151  *
152  * This function creates a SURF action and allocates the data necessary
153  * to create the SIMIX synchro. It can raise a host_error exception if the host crashed.
154  *
155  * \param name Name of the execution synchro to create
156  * \param flops_amount amount Computation amount (in flops)
157  * \param priority computation priority
158  * \param bound
159  * \param affinity_mask
160  * \return A new SIMIX execution synchronization
161  */
162 smx_synchro_t simcall_process_execute(const char *name,
163                                     double flops_amount,
164                                     double priority, double bound, unsigned long affinity_mask)
165 {
166   /* checking for infinite values */
167   xbt_assert(isfinite(flops_amount), "flops_amount is not finite!");
168   xbt_assert(isfinite(priority), "priority is not finite!");
169
170   return simcall_BODY_process_execute(name, flops_amount, priority, bound, affinity_mask);
171 }
172
173 /**
174  * \ingroup simix_process_management
175  * \brief Creates a synchro that may involve parallel computation on
176  * several hosts and communication between them.
177  *
178  * \param name Name of the execution synchro to create
179  * \param host_nb Number of hosts where the synchro will be executed
180  * \param host_list Array (of size host_nb) of hosts where the synchro will be executed
181  * \param flops_amount Array (of size host_nb) of computation amount of hosts (in bytes)
182  * \param bytes_amount Array (of size host_nb * host_nb) representing the communication
183  * amount between each pair of hosts
184  * \param amount the SURF action amount
185  * \param rate the SURF action rate
186  * \return A new SIMIX execution synchronization
187  */
188 smx_synchro_t simcall_process_parallel_execute(const char *name,
189                                          int host_nb,
190                                          sg_host_t *host_list,
191                                          double *flops_amount,
192                                          double *bytes_amount,
193                                          double amount,
194                                          double rate)
195 {
196   int i,j;
197   /* checking for infinite values */
198   for (i = 0 ; i < host_nb ; ++i) {
199      xbt_assert(isfinite(flops_amount[i]), "flops_amount[%d] is not finite!", i);
200      for (j = 0 ; j < host_nb ; ++j) {
201         xbt_assert(isfinite(bytes_amount[i + host_nb * j]),
202              "bytes_amount[%d+%d*%d] is not finite!", i, host_nb, j);
203      }
204   }
205
206   xbt_assert(isfinite(amount), "amount is not finite!");
207   xbt_assert(isfinite(rate), "rate is not finite!");
208
209   return simcall_BODY_process_parallel_execute(name, host_nb, host_list,
210                                             flops_amount,
211                                             bytes_amount,
212                                             amount, rate);
213
214 }
215
216 /**
217  * \ingroup simix_process_management
218  * \brief Destroys an execution synchro.
219  *
220  * Destroys a synchro, freeing its memory. This function cannot be called if there are a conditional waiting for it.
221  * \param execution The execution synchro to destroy
222  */
223 void simcall_process_execution_destroy(smx_synchro_t execution)
224 {
225   simcall_BODY_process_execution_destroy(execution);
226 }
227
228 /**
229  * \ingroup simix_process_management
230  * \brief Cancels an execution synchro.
231  *
232  * This functions stops the execution. It calls a surf function.
233  * \param execution The execution synchro to cancel
234  */
235 void simcall_process_execution_cancel(smx_synchro_t execution)
236 {
237   simcall_BODY_process_execution_cancel(execution);
238 }
239
240 /**
241  * \ingroup simix_process_management
242  * \brief Returns how much of an execution synchro remains to be done.
243  *
244  * \param execution The execution synchro
245  * \return The remaining amount
246  */
247 double simcall_process_execution_get_remains(smx_synchro_t execution)
248 {
249   return simcall_BODY_process_execution_get_remains(execution);
250 }
251
252 /**
253  * \ingroup simix_process_management
254  * \brief Returns the state of an execution synchro.
255  *
256  * \param execution The execution synchro
257  * \return The state
258  */
259 e_smx_state_t simcall_process_execution_get_state(smx_synchro_t execution)
260 {
261   return simcall_BODY_process_execution_get_state(execution);
262 }
263
264 /**
265  * \ingroup simix_process_management
266  * \brief Changes the priority of an execution synchro.
267  *
268  * This functions changes the priority only. It calls a surf function.
269  * \param execution The execution synchro
270  * \param priority The new priority
271  */
272 void simcall_process_execution_set_priority(smx_synchro_t execution, double priority)
273 {
274   /* checking for infinite values */
275   xbt_assert(isfinite(priority), "priority is not finite!");
276
277   simcall_BODY_process_execution_set_priority(execution, priority);
278 }
279
280 /**
281  * \ingroup simix_process_management
282  * \brief Changes the capping (the maximum CPU utilization) of an execution synchro.
283  *
284  * This functions changes the capping only. It calls a surf function.
285  * \param execution The execution synchro
286  * \param bound The new bound
287  */
288 void simcall_process_execution_set_bound(smx_synchro_t execution, double bound)
289 {
290   simcall_BODY_process_execution_set_bound(execution, bound);
291 }
292
293 /**
294  * \ingroup simix_process_management
295  * \brief Changes the CPU affinity of an execution synchro.
296  *
297  * This functions changes the CPU affinity of an execution synchro. See taskset(1) on Linux.
298  * \param execution The execution synchro
299  * \param host Host
300  * \param mask Affinity mask
301  */
302 void simcall_process_execution_set_affinity(smx_synchro_t execution, sg_host_t host, unsigned long mask)
303 {
304   simcall_BODY_process_execution_set_affinity(execution, host, mask);
305 }
306
307 /**
308  * \ingroup simix_host_management
309  * \brief Waits for the completion of an execution synchro and destroy it.
310  *
311  * \param execution The execution synchro
312  */
313 e_smx_state_t simcall_process_execution_wait(smx_synchro_t execution)
314 {
315   return (e_smx_state_t) simcall_BODY_process_execution_wait(execution);
316 }
317
318
319 /**
320  * \ingroup simix_vm_management
321  * \brief Create a VM on the given physical host.
322  *
323  * \param name VM name
324  * \param host Physical host
325  *
326  * \return The host object of the VM
327  */
328 void* simcall_vm_create(const char *name, sg_host_t phys_host)
329 {
330   return simgrid::simix::kernel(std::bind(SIMIX_vm_create, name, phys_host));
331 }
332
333 /**
334  * \ingroup simix_vm_management
335  * \brief Start the given VM to the given physical host
336  *
337  * \param vm VM
338  */
339 void simcall_vm_start(sg_host_t vm)
340 {
341   return simgrid::simix::kernel(std::bind(SIMIX_vm_start, vm));
342 }
343
344 /**
345  * \ingroup simix_vm_management
346  * \brief Get the state of the given VM
347  *
348  * \param vm VM
349  * \return The state of the VM
350  */
351 int simcall_vm_get_state(sg_host_t vm)
352 {
353   return simgrid::simix::kernel(std::bind(SIMIX_vm_get_state, vm));
354 }
355
356 /**
357  * \ingroup simix_vm_management
358  * \brief Get the name of the physical host on which the given VM runs.
359  *
360  * \param vm VM
361  * \return The name of the physical host
362  */
363 void *simcall_vm_get_pm(sg_host_t vm)
364 {
365   return simgrid::simix::kernel(std::bind(SIMIX_vm_get_pm, vm));
366 }
367
368 void simcall_vm_set_bound(sg_host_t vm, double bound)
369 {
370   simgrid::simix::kernel(std::bind(SIMIX_vm_set_bound, vm, bound));
371 }
372
373 void simcall_vm_set_affinity(sg_host_t vm, sg_host_t pm, unsigned long mask)
374 {
375   simgrid::simix::kernel(std::bind(SIMIX_vm_set_affinity, vm, pm, mask));
376 }
377
378 void simcall_host_get_params(sg_host_t vm, vm_params_t params)
379 {
380   simgrid::simix::kernel(std::bind(SIMIX_host_get_params, vm, params));
381 }
382
383 void simcall_host_set_params(sg_host_t vm, vm_params_t params)
384 {
385   simgrid::simix::kernel(std::bind(SIMIX_host_set_params, vm, params));
386 }
387
388 /**
389  * \ingroup simix_vm_management
390  * \brief Migrate the given VM to the given physical host
391  *
392  * \param vm VM
393  * \param host Destination physical host
394  */
395 void simcall_vm_migrate(sg_host_t vm, sg_host_t host)
396 {
397   return simgrid::simix::kernel(std::bind(SIMIX_vm_migrate, vm, host));
398 }
399
400 /**
401  * \ingroup simix_vm_management
402  * \brief Suspend the given VM
403  *
404  * \param vm VM
405  */
406 void simcall_vm_suspend(sg_host_t vm)
407 {
408   simcall_BODY_vm_suspend(vm);
409 }
410
411 /**
412  * \ingroup simix_vm_management
413  * \brief Resume the given VM
414  *
415  * \param vm VM
416  */
417 void simcall_vm_resume(sg_host_t vm)
418 {
419   simcall_BODY_vm_resume(vm);
420 }
421
422 /**
423  * \ingroup simix_vm_management
424  * \brief Save the given VM
425  *
426  * \param vm VM
427  */
428 void simcall_vm_save(sg_host_t vm)
429 {
430   simcall_BODY_vm_save(vm);
431 }
432
433 /**
434  * \ingroup simix_vm_management
435  * \brief Restore the given VM
436  *
437  * \param vm VM
438  */
439 void simcall_vm_restore(sg_host_t vm)
440 {
441   simcall_BODY_vm_restore(vm);
442 }
443
444 /**
445  * \ingroup simix_vm_management
446  * \brief Shutdown the given VM
447  *
448  * \param vm VM
449  */
450 void simcall_vm_shutdown(sg_host_t vm)
451 {
452   simcall_BODY_vm_shutdown(vm);
453 }
454
455 /**
456  * \ingroup simix_vm_management
457  * \brief Destroy the given VM
458  *
459  * \param vm VM
460  */
461 void simcall_vm_destroy(sg_host_t vm)
462 {
463   simgrid::simix::kernel(std::bind(SIMIX_vm_destroy, vm));
464 }
465
466 /**
467  * \ingroup simix_vm_management
468  * \brief Encompassing simcall to prevent the removal of the src or the dst node at the end of a VM migration
469  *  The simcall actually invokes the following calls: 
470  *     simcall_vm_set_affinity(vm, src_pm, 0); 
471  *     simcall_vm_migrate(vm, dst_pm); 
472  *     simcall_vm_resume(vm);
473  *
474  * It is called at the end of the migration_rx_fun function from msg/msg_vm.c
475  *
476  * \param vm VM to migrate
477  * \param src_pm  Source physical host
478  * \param dst_pmt Destination physical host
479  */
480 void simcall_vm_migratefrom_resumeto(sg_host_t vm, sg_host_t src_pm, sg_host_t dst_pm)
481 {
482   simgrid::simix::kernel(std::bind(
483     SIMIX_vm_migratefrom_resumeto, vm, src_pm, dst_pm));
484 }
485
486 /**
487  * \ingroup simix_process_management
488  * \brief Creates and runs a new SIMIX process.
489  *
490  * The structure and the corresponding thread are created and put in the list of ready processes.
491  *
492  * \param name a name for the process. It is for user-level information and can be NULL.
493  * \param code the main function of the process
494  * \param data a pointer to any data one may want to attach to the new object. It is for user-level information and can be NULL.
495  * It can be retrieved with the function \ref simcall_process_get_data.
496  * \param hostname name of the host where the new agent is executed.
497  * \param kill_time time when the process is killed
498  * \param argc first argument passed to \a code
499  * \param argv second argument passed to \a code
500  * \param properties the properties of the process
501  * \param auto_restart either it is autorestarting or not.
502  */
503 smx_process_t simcall_process_create(const char *name,
504                               xbt_main_func_t code,
505                               void *data,
506                               const char *hostname,
507                               double kill_time,
508                               int argc, char **argv,
509                               xbt_dict_t properties,
510                               int auto_restart)
511 {
512   return (smx_process_t) simcall_BODY_process_create(name, code, data, hostname,
513                               kill_time, argc, argv, properties,
514                               auto_restart);
515 }
516
517 /**
518  * \ingroup simix_process_management
519  * \brief Kills a SIMIX process.
520  *
521  * This function simply kills a  process.
522  *
523  * \param process poor victim
524  */
525 void simcall_process_kill(smx_process_t process)
526 {
527   simcall_BODY_process_kill(process);
528 }
529
530 /**
531  * \ingroup simix_process_management
532  * \brief Kills all SIMIX processes.
533  */
534 void simcall_process_killall(int reset_pid)
535 {
536   simcall_BODY_process_killall(reset_pid);
537 }
538
539 /**
540  * \ingroup simix_process_management
541  * \brief Cleans up a SIMIX process.
542  * \param process poor victim (must have already been killed)
543  */
544 void simcall_process_cleanup(smx_process_t process)
545 {
546   simcall_BODY_process_cleanup(process);
547 }
548
549 /**
550  * \ingroup simix_process_management
551  * \brief Migrates an agent to another location.
552  *
553  * This function changes the value of the host on which \a process is running.
554  *
555  * \param process the process to migrate
556  * \param dest name of the new host
557  */
558 void simcall_process_set_host(smx_process_t process, sg_host_t dest)
559 {
560   simcall_BODY_process_set_host(process, dest);
561 }
562
563 void simcall_process_join(smx_process_t process, double timeout)
564 {
565   simcall_BODY_process_join(process, timeout);
566 }
567
568 /**
569  * \ingroup simix_process_management
570  * \brief Suspends a process.
571  *
572  * This function suspends the process by suspending the synchro
573  * it was waiting for completion.
574  *
575  * \param process a SIMIX process
576  */
577 void simcall_process_suspend(smx_process_t process)
578 {
579   xbt_assert(process, "Invalid parameters");
580
581   simcall_BODY_process_suspend(process);
582 }
583
584 /**
585  * \ingroup simix_process_management
586  * \brief Resumes a suspended process.
587  *
588  * This function resumes a suspended process by resuming the synchro
589  * it was waiting for completion.
590  *
591  * \param process a SIMIX process
592  */
593 void simcall_process_resume(smx_process_t process)
594 {
595   simcall_BODY_process_resume(process);
596 }
597
598 /**
599  * \ingroup simix_process_management
600  * \brief Returns the amount of SIMIX processes in the system
601  *
602  * Maestro internal process is not counted, only user code processes are
603  */
604 int simcall_process_count(void)
605 {
606   return simgrid::simix::kernel(SIMIX_process_count);
607 }
608
609 /**
610  * \ingroup simix_process_management
611  * \brief Return the PID of a #smx_process_t.
612  * \param process a SIMIX process
613  * \return the PID of this process
614  */
615 int simcall_process_get_PID(smx_process_t process)
616 {
617   return SIMIX_process_get_PID(process);
618 }
619
620 /**
621  * \ingroup simix_process_management
622  * \brief Return the parent PID of a #smx_process_t.
623  * \param process a SIMIX process
624  * \return the PID of this process parenrt
625  */
626 int simcall_process_get_PPID(smx_process_t process)
627 {
628   return SIMIX_process_get_PPID(process);
629 }
630
631 /**
632  * \ingroup simix_process_management
633  * \brief Return the user data of a #smx_process_t.
634  * \param process a SIMIX process
635  * \return the user data of this process
636  */
637 void* simcall_process_get_data(smx_process_t process)
638 {
639   return SIMIX_process_get_data(process);
640 }
641
642 /**
643  * \ingroup simix_process_management
644  * \brief Set the user data of a #smx_process_t.
645  *
646  * This functions sets the user data associated to \a process.
647  * \param process SIMIX process
648  * \param data User data
649  */
650 void simcall_process_set_data(smx_process_t process, void *data)
651 {
652   simgrid::simix::kernel(std::bind(SIMIX_process_set_data, process, data));
653 }
654
655 static void kill_process(void* arg)
656 {
657   simix_global->kill_process_function((smx_process_t) arg);
658 }
659
660 /**
661  * \ingroup simix_process_management
662  * \brief Set the kill time of a process.
663  */
664 void simcall_process_set_kill_time(smx_process_t process, double kill_time)
665 {
666
667   if (kill_time > SIMIX_get_clock()) {
668     if (simix_global->kill_process_function) {
669       XBT_DEBUG("Set kill time %f for process %s(%s)",kill_time, process->name,
670           sg_host_get_name(process->host));
671       process->kill_timer = SIMIX_timer_set(kill_time, kill_process, process);
672     }
673   }
674 }
675 /**
676  * \ingroup simix_process_management
677  * \brief Get the kill time of a process (or 0 if unset).
678  */
679 double simcall_process_get_kill_time(smx_process_t process) {
680         return SIMIX_timer_get_date(process->kill_timer);
681 }
682
683 /**
684  * \ingroup simix_process_management
685  * \brief Return the location on which an agent is running.
686  *
687  * This functions returns the sg_host_t corresponding to the location on which
688  * \a process is running.
689  * \param process SIMIX process
690  * \return SIMIX host
691  */
692 sg_host_t simcall_process_get_host(smx_process_t process)
693 {
694   return SIMIX_process_get_host(process);
695 }
696
697 /**
698  * \ingroup simix_process_management
699  * \brief Return the name of an agent.
700  *
701  * This functions checks whether \a process is a valid pointer or not and return its name.
702  * \param process SIMIX process
703  * \return The process name
704  */
705 const char* simcall_process_get_name(smx_process_t process)
706 {
707   return SIMIX_process_get_name(process);
708 }
709
710 /**
711  * \ingroup simix_process_management
712  * \brief Returns true if the process is suspended .
713  *
714  * This checks whether a process is suspended or not by inspecting the task on which it was waiting for the completion.
715  * \param process SIMIX process
716  * \return 1, if the process is suspended, else 0.
717  */
718 int simcall_process_is_suspended(smx_process_t process)
719 {
720   return simcall_BODY_process_is_suspended(process);
721 }
722
723 /**
724  * \ingroup simix_process_management
725  * \brief Return the properties
726  *
727  * This functions returns the properties associated with this process
728  */
729 xbt_dict_t simcall_process_get_properties(smx_process_t process)
730 {
731   return SIMIX_process_get_properties(process);
732 }
733 /**
734  * \ingroup simix_process_management
735  * \brief Add an on_exit function
736  * Add an on_exit function which will be executed when the process exits/is killed.
737  */
738 XBT_PUBLIC(void) simcall_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void *data)
739 {
740   simcall_BODY_process_on_exit(process, fun, data);
741 }
742 /**
743  * \ingroup simix_process_management
744  * \brief Sets the process to be auto-restarted or not by SIMIX when its host comes back up.
745  * Will restart the process when the host comes back up if auto_restart is set to 1.
746  */
747
748 XBT_PUBLIC(void) simcall_process_auto_restart_set(smx_process_t process, int auto_restart)
749 {
750   simcall_BODY_process_auto_restart_set(process, auto_restart);
751 }
752
753 /**
754  * \ingroup simix_process_management
755  * \brief Restarts the process, killing it and starting it again from scratch.
756  */
757 XBT_PUBLIC(smx_process_t) simcall_process_restart(smx_process_t process)
758 {
759   return (smx_process_t) simcall_BODY_process_restart(process);
760 }
761 /**
762  * \ingroup simix_process_management
763  * \brief Creates a new sleep SIMIX synchro.
764  *
765  * This function creates a SURF action and allocates the data necessary
766  * to create the SIMIX synchro. It can raise a host_error exception if the
767  * host crashed. The default SIMIX name of the synchro is "sleep".
768  *
769  *   \param duration Time duration of the sleep.
770  *   \return A result telling whether the sleep was successful
771  */
772 e_smx_state_t simcall_process_sleep(double duration)
773 {
774   /* checking for infinite values */
775   xbt_assert(isfinite(duration), "duration is not finite!");
776   return (e_smx_state_t) simcall_BODY_process_sleep(duration);
777 }
778
779 /**
780  *  \ingroup simix_rdv_management
781  *  \brief Creates a new rendez-vous point
782  *  \param name The name of the rendez-vous point
783  *  \return The created rendez-vous point
784  */
785 smx_rdv_t simcall_rdv_create(const char *name)
786 {
787   return simcall_BODY_rdv_create(name);
788 }
789
790
791 /**
792  *  \ingroup simix_rdv_management
793  *  \brief Destroy a rendez-vous point
794  *  \param rdv The rendez-vous point to destroy
795  */
796 void simcall_rdv_destroy(smx_rdv_t rdv)
797 {
798   simcall_BODY_rdv_destroy(rdv);
799 }
800 /**
801  *  \ingroup simix_rdv_management
802  *  \brief Returns a rendez-vous point knowing its name
803  */
804 smx_rdv_t simcall_rdv_get_by_name(const char *name)
805 {
806   xbt_assert(name != NULL, "Invalid parameter for simcall_rdv_get_by_name (name is NULL)");
807
808   /* FIXME: this is a horrible loss of performance, so we hack it out by
809    * skipping the simcall (for now). It works in parallel, it won't work on
810    * distributed but probably we will change MSG for that. */
811
812   return SIMIX_rdv_get_by_name(name);
813 }
814
815 /**
816  *  \ingroup simix_rdv_management
817  *  \brief Counts the number of communication synchros of a given host pending
818  *         on a rendez-vous point.
819  *  \param rdv The rendez-vous point
820  *  \param host The host to be counted
821  *  \return The number of comm synchros pending in the rdv
822  */
823 int simcall_rdv_comm_count_by_host(smx_rdv_t rdv, sg_host_t host)
824 {
825   return simcall_BODY_rdv_comm_count_by_host(rdv, host);
826 }
827
828 /**
829  *  \ingroup simix_rdv_management
830  *  \brief returns the communication at the head of the rendez-vous
831  *  \param rdv The rendez-vous point
832  *  \return The communication or NULL if empty
833  */
834 smx_synchro_t simcall_rdv_get_head(smx_rdv_t rdv)
835 {
836   return simcall_BODY_rdv_get_head(rdv);
837 }
838
839 void simcall_rdv_set_receiver(smx_rdv_t rdv, smx_process_t process)
840 {
841   simcall_BODY_rdv_set_receiver(rdv, process);
842 }
843
844 smx_process_t simcall_rdv_get_receiver(smx_rdv_t rdv)
845 {
846   return simcall_BODY_rdv_get_receiver(rdv);
847 }
848
849 /**
850  * \ingroup simix_comm_management
851  */
852 void simcall_comm_send(smx_process_t sender, smx_rdv_t rdv, double task_size, double rate,
853                          void *src_buff, size_t src_buff_size,
854                          int (*match_fun)(void *, void *, smx_synchro_t),
855                          void (*copy_data_fun)(smx_synchro_t, void*, size_t), void *data,
856                          double timeout)
857 {
858   /* checking for infinite values */
859   xbt_assert(isfinite(task_size), "task_size is not finite!");
860   xbt_assert(isfinite(rate), "rate is not finite!");
861   xbt_assert(isfinite(timeout), "timeout is not finite!");
862
863   xbt_assert(rdv, "No rendez-vous point defined for send");
864
865   if (MC_is_active() || MC_record_replay_is_active()) {
866     /* the model-checker wants two separate simcalls */
867     smx_synchro_t comm = NULL; /* MC needs the comm to be set to NULL during the simcall */
868     comm = simcall_comm_isend(sender, rdv, task_size, rate,
869         src_buff, src_buff_size, match_fun, NULL, copy_data_fun, data, 0);
870     simcall_comm_wait(comm, timeout);
871     comm = NULL;
872   }
873   else {
874     simcall_BODY_comm_send(sender, rdv, task_size, rate, src_buff, src_buff_size,
875                          match_fun, copy_data_fun, data, timeout);
876   }
877 }
878
879 /**
880  * \ingroup simix_comm_management
881  */
882 smx_synchro_t simcall_comm_isend(smx_process_t sender, smx_rdv_t rdv, double task_size, double rate,
883                               void *src_buff, size_t src_buff_size,
884                               int (*match_fun)(void *, void *, smx_synchro_t),
885                               void (*clean_fun)(void *),
886                               void (*copy_data_fun)(smx_synchro_t, void*, size_t),
887                               void *data,
888                               int detached)
889 {
890   /* checking for infinite values */
891   xbt_assert(isfinite(task_size), "task_size is not finite!");
892   xbt_assert(isfinite(rate), "rate is not finite!");
893
894   xbt_assert(rdv, "No rendez-vous point defined for isend");
895
896   return simcall_BODY_comm_isend(sender, rdv, task_size, rate, src_buff,
897                                  src_buff_size, match_fun,
898                                  clean_fun, copy_data_fun, data, detached);
899 }
900
901 /**
902  * \ingroup simix_comm_management
903  */
904 void simcall_comm_recv(smx_process_t receiver, smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size,
905                        int (*match_fun)(void *, void *, smx_synchro_t),
906                        void (*copy_data_fun)(smx_synchro_t, void*, size_t),
907                        void *data, double timeout, double rate)
908 {
909   xbt_assert(isfinite(timeout), "timeout is not finite!");
910   xbt_assert(rdv, "No rendez-vous point defined for recv");
911
912   if (MC_is_active() || MC_record_replay_is_active()) {
913     /* the model-checker wants two separate simcalls */
914     smx_synchro_t comm = NULL; /* MC needs the comm to be set to NULL during the simcall */
915     comm = simcall_comm_irecv(receiver, rdv, dst_buff, dst_buff_size,
916                               match_fun, copy_data_fun, data, rate);
917     simcall_comm_wait(comm, timeout);
918     comm = NULL;
919   }
920   else {
921     simcall_BODY_comm_recv(receiver, rdv, dst_buff, dst_buff_size,
922                            match_fun, copy_data_fun, data, timeout, rate);
923   }
924 }
925 /**
926  * \ingroup simix_comm_management
927  */
928 smx_synchro_t simcall_comm_irecv(smx_process_t receiver, smx_rdv_t rdv, void *dst_buff, size_t *dst_buff_size,
929                                 int (*match_fun)(void *, void *, smx_synchro_t),
930                                 void (*copy_data_fun)(smx_synchro_t, void*, size_t),
931                                 void *data, double rate)
932 {
933   xbt_assert(rdv, "No rendez-vous point defined for irecv");
934
935   return simcall_BODY_comm_irecv(receiver, rdv, dst_buff, dst_buff_size,
936                                  match_fun, copy_data_fun, data, rate);
937 }
938
939 /**
940  * \ingroup simix_comm_management
941  */
942 smx_synchro_t simcall_comm_iprobe(smx_rdv_t rdv, int type, int src, int tag,
943                                 int (*match_fun)(void *, void *, smx_synchro_t), void *data)
944 {
945   xbt_assert(rdv, "No rendez-vous point defined for iprobe");
946
947   return simcall_BODY_comm_iprobe(rdv, type, src, tag, match_fun, data);
948 }
949
950 /**
951  * \ingroup simix_comm_management
952  */
953 void simcall_comm_cancel(smx_synchro_t comm)
954 {
955   simcall_BODY_comm_cancel(comm);
956 }
957
958 /**
959  * \ingroup simix_comm_management
960  */
961 unsigned int simcall_comm_waitany(xbt_dynar_t comms)
962 {
963   return simcall_BODY_comm_waitany(comms);
964 }
965
966 /**
967  * \ingroup simix_comm_management
968  */
969 int simcall_comm_testany(xbt_dynar_t comms)
970 {
971   if (xbt_dynar_is_empty(comms))
972     return -1;
973   return simcall_BODY_comm_testany(comms);
974 }
975
976 /**
977  * \ingroup simix_comm_management
978  */
979 void simcall_comm_wait(smx_synchro_t comm, double timeout)
980 {
981   xbt_assert(isfinite(timeout), "timeout is not finite!");
982   simcall_BODY_comm_wait(comm, timeout);
983 }
984
985 /**
986  * \brief Set the category of an synchro.
987  *
988  * This functions changes the category only. It calls a surf function.
989  * \param execution The execution synchro
990  * \param category The tracing category
991  */
992 void simcall_set_category(smx_synchro_t synchro, const char *category)
993 {
994   if (category == NULL) {
995     return;
996   }
997   simcall_BODY_set_category(synchro, category);
998 }
999
1000 /**
1001  * \ingroup simix_comm_management
1002  *
1003  */
1004 int simcall_comm_test(smx_synchro_t comm)
1005 {
1006   return simcall_BODY_comm_test(comm);
1007 }
1008
1009 /**
1010  * \ingroup simix_comm_management
1011  *
1012  */
1013 double simcall_comm_get_remains(smx_synchro_t comm)
1014 {
1015   return simcall_BODY_comm_get_remains(comm);
1016 }
1017
1018 /**
1019  * \ingroup simix_comm_management
1020  *
1021  */
1022 e_smx_state_t simcall_comm_get_state(smx_synchro_t comm)
1023 {
1024   return simcall_BODY_comm_get_state(comm);
1025 }
1026
1027 /**
1028  * \ingroup simix_comm_management
1029  *
1030  */
1031 void *simcall_comm_get_src_data(smx_synchro_t comm)
1032 {
1033   return simcall_BODY_comm_get_src_data(comm);
1034 }
1035
1036 /**
1037  * \ingroup simix_comm_management
1038  *
1039  */
1040 void *simcall_comm_get_dst_data(smx_synchro_t comm)
1041 {
1042   return simcall_BODY_comm_get_dst_data(comm);
1043 }
1044
1045 /**
1046  * \ingroup simix_comm_management
1047  *
1048  */
1049 smx_process_t simcall_comm_get_src_proc(smx_synchro_t comm)
1050 {
1051   return simcall_BODY_comm_get_src_proc(comm);
1052 }
1053
1054 /**
1055  * \ingroup simix_comm_management
1056  *
1057  */
1058 smx_process_t simcall_comm_get_dst_proc(smx_synchro_t comm)
1059 {
1060   return simcall_BODY_comm_get_dst_proc(comm);
1061 }
1062
1063 #ifdef HAVE_LATENCY_BOUND_TRACKING
1064 int simcall_comm_is_latency_bounded(smx_synchro_t comm)
1065 {
1066   return simcall_BODY_comm_is_latency_bounded(comm);
1067 }
1068 #endif
1069
1070 /**
1071  * \ingroup simix_synchro_management
1072  *
1073  */
1074 smx_mutex_t simcall_mutex_init(void)
1075 {
1076   if(!simix_global) {
1077     fprintf(stderr,"You must run MSG_init before using MSG\n"); // We can't use xbt_die since we may get there before the initialization
1078     xbt_abort();
1079   }
1080   return simcall_BODY_mutex_init();
1081 }
1082
1083 /**
1084  * \ingroup simix_synchro_management
1085  *
1086  */
1087 void simcall_mutex_destroy(smx_mutex_t mutex)
1088 {
1089   simcall_BODY_mutex_destroy(mutex);
1090 }
1091
1092 /**
1093  * \ingroup simix_synchro_management
1094  *
1095  */
1096 void simcall_mutex_lock(smx_mutex_t mutex)
1097 {
1098   simcall_BODY_mutex_lock(mutex);
1099 }
1100
1101 /**
1102  * \ingroup simix_synchro_management
1103  *
1104  */
1105 int simcall_mutex_trylock(smx_mutex_t mutex)
1106 {
1107   return simcall_BODY_mutex_trylock(mutex);
1108 }
1109
1110 /**
1111  * \ingroup simix_synchro_management
1112  *
1113  */
1114 void simcall_mutex_unlock(smx_mutex_t mutex)
1115 {
1116   simcall_BODY_mutex_unlock(mutex);
1117 }
1118
1119 /**
1120  * \ingroup simix_synchro_management
1121  *
1122  */
1123 smx_cond_t simcall_cond_init(void)
1124 {
1125   return simcall_BODY_cond_init();
1126 }
1127
1128 /**
1129  * \ingroup simix_synchro_management
1130  *
1131  */
1132 void simcall_cond_destroy(smx_cond_t cond)
1133 {
1134   simcall_BODY_cond_destroy(cond);
1135 }
1136
1137 /**
1138  * \ingroup simix_synchro_management
1139  *
1140  */
1141 void simcall_cond_signal(smx_cond_t cond)
1142 {
1143   simcall_BODY_cond_signal(cond);
1144 }
1145
1146 /**
1147  * \ingroup simix_synchro_management
1148  *
1149  */
1150 void simcall_cond_wait(smx_cond_t cond, smx_mutex_t mutex)
1151 {
1152   simcall_BODY_cond_wait(cond, mutex);
1153 }
1154
1155 /**
1156  * \ingroup simix_synchro_management
1157  *
1158  */
1159 void simcall_cond_wait_timeout(smx_cond_t cond,
1160                                  smx_mutex_t mutex,
1161                                  double timeout)
1162 {
1163   xbt_assert(isfinite(timeout), "timeout is not finite!");
1164   simcall_BODY_cond_wait_timeout(cond, mutex, timeout);
1165 }
1166
1167 /**
1168  * \ingroup simix_synchro_management
1169  *
1170  */
1171 void simcall_cond_broadcast(smx_cond_t cond)
1172 {
1173   simcall_BODY_cond_broadcast(cond);
1174 }
1175
1176 /**
1177  * \ingroup simix_synchro_management
1178  *
1179  */
1180 smx_sem_t simcall_sem_init(int capacity)
1181 {
1182   return simcall_BODY_sem_init(capacity);
1183 }
1184
1185 /**
1186  * \ingroup simix_synchro_management
1187  *
1188  */
1189 void simcall_sem_destroy(smx_sem_t sem)
1190 {
1191   simcall_BODY_sem_destroy(sem);
1192 }
1193
1194 /**
1195  * \ingroup simix_synchro_management
1196  *
1197  */
1198 void simcall_sem_release(smx_sem_t sem)
1199 {
1200   simcall_BODY_sem_release(sem);
1201 }
1202
1203 /**
1204  * \ingroup simix_synchro_management
1205  *
1206  */
1207 int simcall_sem_would_block(smx_sem_t sem)
1208 {
1209   return simcall_BODY_sem_would_block(sem);
1210 }
1211
1212 /**
1213  * \ingroup simix_synchro_management
1214  *
1215  */
1216 void simcall_sem_acquire(smx_sem_t sem)
1217 {
1218   simcall_BODY_sem_acquire(sem);
1219 }
1220
1221 /**
1222  * \ingroup simix_synchro_management
1223  *
1224  */
1225 void simcall_sem_acquire_timeout(smx_sem_t sem, double timeout)
1226 {
1227   xbt_assert(isfinite(timeout), "timeout is not finite!");
1228   simcall_BODY_sem_acquire_timeout(sem, timeout);
1229 }
1230
1231 /**
1232  * \ingroup simix_synchro_management
1233  *
1234  */
1235 int simcall_sem_get_capacity(smx_sem_t sem)
1236 {
1237   return simcall_BODY_sem_get_capacity(sem);
1238 }
1239
1240 /**
1241  * \ingroup simix_file_management
1242  *
1243  */
1244 sg_size_t simcall_file_read(smx_file_t fd, sg_size_t size, sg_host_t host)
1245 {
1246   return simcall_BODY_file_read(fd, size, host);
1247 }
1248
1249 /**
1250  * \ingroup simix_file_management
1251  *
1252  */
1253 sg_size_t simcall_file_write(smx_file_t fd, sg_size_t size, sg_host_t host)
1254 {
1255   return simcall_BODY_file_write(fd, size, host);
1256 }
1257
1258 /**
1259  * \ingroup simix_file_management
1260  * \brief
1261  */
1262 smx_file_t simcall_file_open(const char* fullpath, sg_host_t host)
1263 {
1264   return simcall_BODY_file_open(fullpath, host);
1265 }
1266
1267 /**
1268  * \ingroup simix_file_management
1269  *
1270  */
1271 int simcall_file_close(smx_file_t fd, sg_host_t host)
1272 {
1273   return simcall_BODY_file_close(fd, host);
1274 }
1275
1276 /**
1277  * \ingroup simix_file_management
1278  *
1279  */
1280 int simcall_file_unlink(smx_file_t fd, sg_host_t host)
1281 {
1282   return simcall_BODY_file_unlink(fd, host);
1283 }
1284
1285 /**
1286  * \ingroup simix_file_management
1287  *
1288  */
1289 sg_size_t simcall_file_get_size(smx_file_t fd){
1290   return simcall_BODY_file_get_size(fd);
1291 }
1292
1293 /**
1294  * \ingroup simix_file_management
1295  *
1296  */
1297 sg_size_t simcall_file_tell(smx_file_t fd){
1298   return simcall_BODY_file_tell(fd);
1299 }
1300
1301 /**
1302  * \ingroup simix_file_management
1303  *
1304  */
1305 xbt_dynar_t simcall_file_get_info(smx_file_t fd)
1306 {
1307   return simcall_BODY_file_get_info(fd);
1308 }
1309
1310 /**
1311  * \ingroup simix_file_management
1312  *
1313  */
1314 int simcall_file_seek(smx_file_t fd, sg_offset_t offset, int origin){
1315   return simcall_BODY_file_seek(fd, offset, origin);
1316 }
1317
1318 /**
1319  * \ingroup simix_file_management
1320  * \brief Move a file to another location on the *same mount point*.
1321  *
1322  */
1323 int simcall_file_move(smx_file_t fd, const char* fullpath)
1324 {
1325   return simcall_BODY_file_move(fd, fullpath);
1326 }
1327
1328 /**
1329  * \ingroup simix_storage_management
1330  * \brief Returns the free space size on a given storage element.
1331  * \param storage a storage
1332  * \return Return the free space size on a given storage element (as sg_size_t)
1333  */
1334 sg_size_t simcall_storage_get_free_size (smx_storage_t storage){
1335   return simcall_BODY_storage_get_free_size(storage);
1336 }
1337
1338 /**
1339  * \ingroup simix_storage_management
1340  * \brief Returns the used space size on a given storage element.
1341  * \param storage a storage
1342  * \return Return the used space size on a given storage element (as sg_size_t)
1343  */
1344 sg_size_t simcall_storage_get_used_size (smx_storage_t storage){
1345   return simcall_BODY_storage_get_used_size(storage);
1346 }
1347
1348 /**
1349  * \ingroup simix_storage_management
1350  * \brief Returns the list of storages mounted on an host.
1351  * \param host A SIMIX host
1352  * \return a dict containing all storages mounted on the host
1353  */
1354 xbt_dict_t simcall_host_get_mounted_storage_list(sg_host_t host)
1355 {
1356   return simgrid::simix::kernel(std::bind(
1357     SIMIX_host_get_mounted_storage_list, host
1358   ));
1359 }
1360
1361 /**
1362  * \ingroup simix_storage_management
1363  * \brief Returns the list of storages attached to an host.
1364  * \param host A SIMIX host
1365  * \return a dict containing all storages attached to the host
1366  */
1367 xbt_dynar_t simcall_host_get_attached_storage_list(sg_host_t host)
1368 {
1369   return simgrid::simix::kernel(std::bind(
1370     SIMIX_host_get_attached_storage_list, host
1371   ));
1372 }
1373
1374 /**
1375  * \ingroup simix_storage_management
1376  * \brief Returns a dict of the properties assigned to a storage element.
1377  *
1378  * \param storage A storage element
1379  * \return The properties of this storage element
1380  */
1381 xbt_dict_t simcall_storage_get_properties(smx_storage_t storage)
1382 {
1383   return simcall_BODY_storage_get_properties(storage);
1384 }
1385
1386 /**
1387  * \ingroup simix_storage_management
1388  * \brief Returns a dict containing the content of a storage element.
1389  *
1390  * \param storage A storage element
1391  * \return The content of this storage element as a dict (full path file => size)
1392  */
1393 xbt_dict_t simcall_storage_get_content(smx_storage_t storage)
1394 {
1395   return simcall_BODY_storage_get_content(storage);
1396 }
1397
1398 void simcall_run_kernel(std::function<void()> const& code)
1399 {
1400   return simcall_BODY_run_kernel((void*) &code);
1401 }
1402
1403 #ifdef HAVE_MC
1404
1405 void *simcall_mc_snapshot(void) {
1406   return simcall_BODY_mc_snapshot();
1407 }
1408
1409 int simcall_mc_compare_snapshots(void *s1, void *s2) {
1410   return simcall_BODY_mc_compare_snapshots((simgrid::mc::Snapshot*)s1, (simgrid::mc::Snapshot*)s2);
1411 }
1412
1413 #endif /* HAVE_MC */
1414
1415 int simcall_mc_random(int min, int max) {
1416   return simcall_BODY_mc_random(min, max);
1417 }
1418
1419 /* ************************************************************************** */
1420
1421 /** @brief returns a printable string representing a simcall */
1422 const char *SIMIX_simcall_name(e_smx_simcall_t kind) {
1423   return simcall_names[kind];
1424 }