Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Document all commits since 3.31. The changelog may be reordered for clarity
[simgrid.git] / src / msg / msg_legacy.cpp
1 /* Copyright (c) 2004-2022. The SimGrid Team. All rights reserved.          */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5
6 #include "simgrid/Exception.hpp"
7 #include "simgrid/s4u/Engine.hpp"
8 #include "src/msg/msg_private.hpp"
9 #include "xbt/functional.hpp"
10
11 #define MSG_CALL(type, oldname, args)
12
13 /* ************************** Engine *************************** */
14 void MSG_create_environment(const char* filename)
15 {
16   simgrid_load_platform(filename);
17 }
18
19 void MSG_launch_application(const char* filename)
20 {
21   simgrid_load_deployment(filename);
22 }
23 msg_error_t MSG_main()
24 {
25   simgrid_run();
26   return MSG_OK;
27 }
28 void MSG_function_register(const char* name, int (*code)(int, char**))
29 {
30   simgrid::kernel::actor::ActorCodeFactory code_factory = [code](std::vector<std::string> args) {
31     return simgrid::xbt::wrap_main(code, std::move(args));
32   };
33   simgrid::s4u::Engine::get_instance()->register_function(name, code_factory);
34 }
35 void MSG_function_register_default(int (*code)(int, char**))
36 {
37   simgrid::s4u::Engine::get_instance()->register_default(
38       [code](std::vector<std::string> args) { return simgrid::xbt::wrap_main(code, std::move(args)); });
39 }
40 double MSG_get_clock()
41 {
42   return simgrid_get_clock();
43 }
44
45 /* ************************** Mailboxes ************************ */
46 void MSG_mailbox_set_async(const char* alias)
47 {
48   sg_mailbox_set_receiver(alias);
49 }
50 int MSG_task_listen(const char* alias)
51 {
52   return sg_mailbox_listen(alias);
53 }
54
55 /* ************************** Actors *************************** */
56 void MSG_process_on_exit(int_f_int_pvoid_t fun, void* data)
57 {
58   /* We can't use the sg_actor_on_exit, as the return type of the callback changed: the int in MSG is ignored and was
59    * removed in sg */
60   simgrid::s4u::this_actor::on_exit([fun, data](bool failed) { fun(failed ? 1 /*FAILURE*/ : 0 /*SUCCESS*/, data); });
61 }
62
63 int MSG_process_get_PID(const_sg_actor_t actor)
64 {
65   return sg_actor_get_pid(actor);
66 }
67 int MSG_process_get_PPID(const_sg_actor_t actor)
68 {
69   return sg_actor_get_ppid(actor);
70 }
71 msg_process_t MSG_process_from_PID(int pid)
72 {
73   return sg_actor_by_pid(pid);
74 }
75 const char* MSG_process_get_name(const_sg_actor_t actor)
76 {
77   return sg_actor_get_name(actor);
78 }
79 sg_host_t MSG_process_get_host(const_sg_actor_t actor)
80 {
81   return sg_actor_get_host(actor);
82 }
83 xbt_dict_t MSG_process_get_properties(const_sg_actor_t actor)
84 {
85   return sg_actor_get_properties(actor);
86 }
87 const char* MSG_process_get_property_value(const_sg_actor_t actor, const char* name)
88 {
89   return sg_actor_get_property_value(actor, name);
90 }
91 void MSG_process_suspend(sg_actor_t actor)
92 {
93   sg_actor_suspend(actor);
94 }
95 void MSG_process_resume(sg_actor_t actor)
96 {
97   sg_actor_resume(actor);
98 }
99 int MSG_process_is_suspended(const_sg_actor_t actor)
100 {
101   return sg_actor_is_suspended(actor);
102 }
103 void MSG_process_restart(sg_actor_t actor)
104 {
105   sg_actor_restart(actor);
106 }
107 void MSG_process_auto_restart_set(sg_actor_t actor, int auto_restart)
108 {
109   sg_actor_set_auto_restart(actor, auto_restart);
110 }
111
112 void MSG_process_daemonize(sg_actor_t actor)
113 {
114   sg_actor_daemonize(actor);
115 }
116 void MSG_process_migrate(sg_actor_t actor, sg_host_t host)
117 {
118   sg_actor_set_host(actor, host);
119 }
120 void MSG_process_join(const_sg_actor_t actor, double timeout)
121 {
122   sg_actor_join(actor, timeout);
123 }
124 void MSG_process_kill(sg_actor_t actor)
125 {
126   sg_actor_kill(actor);
127 }
128 void MSG_process_killall()
129 {
130   sg_actor_kill_all();
131 }
132 void MSG_process_set_kill_time(sg_actor_t actor, double kill_time)
133 {
134   sg_actor_set_kill_time(actor, kill_time);
135 }
136 void MSG_process_yield()
137 {
138   sg_actor_yield();
139 }
140
141 msg_error_t MSG_process_sleep(double duration)
142 {
143   try {
144     sg_actor_sleep_for(duration);
145     return MSG_OK;
146   } catch (const simgrid::HostFailureException&) {
147     return MSG_HOST_FAILURE;
148   }
149 }
150
151 /** @brief Returns the user data of a process.
152  *
153  * This function checks whether @a process is a valid pointer and returns the user data associated to this process.
154  */
155 void* MSG_process_get_data(const_sg_actor_t process)
156 {
157   xbt_assert(process != nullptr, "Invalid parameter: first parameter must not be nullptr!");
158
159   /* get from SIMIX the MSG process data, and then the user data */
160   return sg_actor_get_data(process);
161 }
162
163 /** @brief Sets the user data of a process.
164  *
165  * This function checks whether @a process is a valid pointer and sets the user data associated to this process.
166  */
167 msg_error_t MSG_process_set_data(msg_process_t process, void* data)
168 {
169   xbt_assert(process != nullptr, "Invalid parameter: first parameter must not be nullptr!");
170   sg_actor_set_data(process, data);
171
172   return MSG_OK;
173 }
174
175 msg_process_t MSG_process_attach(const char* name, void* data, msg_host_t host, xbt_dict_t properties)
176 {
177   return sg_actor_attach(name, data, host, properties);
178 }
179
180 void MSG_process_detach()
181 {
182   sg_actor_detach();
183 }
184 aid_t MSG_process_self_PID()
185 {
186   return sg_actor_self_get_pid();
187 }
188
189 /** @brief Return the PPID of the current process.
190  *
191  * This function returns the PID of the parent of the currently running #msg_process_t.
192  */
193 aid_t MSG_process_self_PPID()
194 {
195   return sg_actor_self_get_ppid();
196 }
197
198 /** @brief Return the name of the current process. */
199 const char* MSG_process_self_name()
200 {
201   return sg_actor_self_get_name();
202 }
203 /** @brief Return the current process.
204  *
205  * This function returns the currently running #msg_process_t.
206  */
207 msg_process_t MSG_process_self()
208 {
209   return sg_actor_self();
210 }
211
212 /** @brief Take an extra reference on that process to prevent it to be garbage-collected */
213 void MSG_process_ref(const_sg_actor_t process)
214 {
215   sg_actor_ref(process);
216 }
217 /** @brief Release a reference on that process so that it can get be garbage-collected */
218 void MSG_process_unref(const_sg_actor_t process)
219 {
220   sg_actor_unref(process);
221 }
222
223 /* ************************** NetZones *************************** */
224 sg_netzone_t MSG_zone_get_root()
225 {
226   return sg_zone_get_root();
227 }
228 const char* MSG_zone_get_name(const_sg_netzone_t zone)
229 {
230   return sg_zone_get_name(zone);
231 }
232 sg_netzone_t MSG_zone_get_by_name(const char* name)
233 {
234   return sg_zone_get_by_name(name);
235 }
236 void MSG_zone_get_sons(const_sg_netzone_t zone, xbt_dict_t whereto)
237 {
238   return sg_zone_get_sons(zone, whereto);
239 }
240 const char* MSG_zone_get_property_value(const_sg_netzone_t zone, const char* name)
241 {
242   return sg_zone_get_property_value(zone, name);
243 }
244 void MSG_zone_set_property_value(sg_netzone_t zone, const char* name, const char* value)
245 {
246   sg_zone_set_property_value(zone, name, value);
247 }
248 void MSG_zone_get_hosts(const_sg_netzone_t zone, xbt_dynar_t whereto)
249 {
250   sg_zone_get_hosts(zone, whereto);
251 }
252
253 /* ************************** hosts *************************** */
254 size_t MSG_get_host_number()
255 {
256   return sg_host_count();
257 }
258 sg_host_t MSG_get_host_by_name(const char* name)
259 {
260   return sg_host_by_name(name);
261 }
262 sg_host_t MSG_host_by_name(const char* name)
263 {
264   return sg_host_by_name(name);
265 }
266 const char* MSG_host_get_name(const_sg_host_t host)
267 {
268   return sg_host_get_name(host);
269 }
270 void* MSG_host_get_data(const_sg_host_t host)
271 {
272   return sg_host_get_data(host);
273 }
274 void MSG_host_set_data(sg_host_t host, void* data)
275 {
276   return sg_host_set_data(host, data);
277 }
278 double MSG_host_get_speed(const_sg_host_t host)
279 {
280   return sg_host_get_speed(host);
281 }
282 double MSG_host_get_power_peak_at(const_sg_host_t host, int pstate_index)
283 {
284   return sg_host_get_pstate_speed(host, pstate_index);
285 }
286 int MSG_host_get_core_number(const_sg_host_t host)
287 {
288   return sg_host_core_count(host);
289 }
290 int MSG_host_get_nb_pstates(const_sg_host_t host)
291 {
292   return sg_host_get_nb_pstates(host);
293 }
294 int MSG_host_get_pstate(const_sg_host_t host)
295 {
296   return sg_host_get_pstate(host);
297 }
298 void MSG_host_set_pstate(sg_host_t host, int pstate)
299 {
300   sg_host_set_pstate(host, pstate);
301 }
302 void MSG_host_on(sg_host_t h)
303 {
304   sg_host_turn_on(h);
305 }
306 void MSG_host_off(sg_host_t h)
307 {
308   sg_host_turn_off(h);
309 }
310 int MSG_host_is_on(const_sg_host_t h)
311 {
312   return sg_host_is_on(h);
313 }
314 xbt_dict_t MSG_host_get_properties(const_sg_host_t host)
315 {
316   return sg_host_get_properties(host);
317 }
318 const char* MSG_host_get_property_value(const_sg_host_t host, const char* name)
319 {
320   return sg_host_get_property_value(host, name);
321 }
322 void MSG_host_set_property_value(sg_host_t host, const char* name, const char* value)
323 {
324   sg_host_set_property_value(host, name, value);
325 }
326 void MSG_host_get_process_list(const_sg_host_t host, xbt_dynar_t whereto)
327 {
328   sg_host_get_actor_list(host, whereto);
329 }
330 sg_host_t MSG_host_self()
331 {
332   return sg_host_self();
333 }
334
335 double MSG_host_get_load(const_sg_host_t host)
336 {
337   return sg_host_get_load(host);
338 }
339 /* ************************** Virtual Machines *************************** */
340 sg_vm_t MSG_vm_create_core(sg_host_t pm, const char* name)
341 {
342   return sg_vm_create_core(pm, name);
343 }
344 sg_vm_t MSG_vm_create_multicore(sg_host_t pm, const char* name, int coreAmount)
345 {
346   return sg_vm_create_multicore(pm, name, coreAmount);
347 }
348 int MSG_vm_is_created(const_sg_vm_t vm)
349 {
350   return sg_vm_is_created(vm);
351 }
352 int MSG_vm_is_running(const_sg_vm_t vm)
353 {
354   return sg_vm_is_running(vm);
355 }
356 int MSG_vm_is_suspended(const_sg_vm_t vm)
357 {
358   return sg_vm_is_suspended(vm);
359 }
360 const char* MSG_vm_get_name(const_sg_vm_t vm)
361 {
362   return sg_vm_get_name(vm);
363 }
364 void MSG_vm_set_ramsize(sg_vm_t vm, size_t size)
365 {
366   sg_vm_set_ramsize(vm, size);
367 }
368 size_t MSG_vm_get_ramsize(const_sg_vm_t vm)
369 {
370   return sg_vm_get_ramsize(vm);
371 }
372 sg_host_t MSG_vm_get_pm(const_sg_vm_t vm)
373 {
374   return sg_vm_get_pm(vm);
375 }
376 void MSG_vm_set_bound(sg_vm_t vm, double bound)
377 {
378   sg_vm_set_bound(vm, bound);
379 }
380 void MSG_vm_start(sg_vm_t vm)
381 {
382   sg_vm_start(vm);
383 }
384 void MSG_vm_suspend(sg_vm_t vm)
385 {
386   sg_vm_suspend(vm);
387 }
388 void MSG_vm_resume(sg_vm_t vm)
389 {
390   sg_vm_resume(vm);
391 }
392 void MSG_vm_shutdown(sg_vm_t vm)
393 {
394   sg_vm_shutdown(vm);
395 }
396 void MSG_vm_destroy(sg_vm_t vm)
397 {
398   sg_vm_destroy(vm);
399 }
400 /********* barriers ************/
401 sg_bar_t MSG_barrier_init(unsigned int count)
402 {
403   return sg_barrier_init(count);
404 }
405
406 void MSG_barrier_destroy(sg_bar_t bar)
407 {
408   sg_barrier_destroy(bar);
409 }
410
411 int MSG_barrier_wait(sg_bar_t bar)
412 {
413   return sg_barrier_wait(bar);
414 }
415
416 sg_sem_t MSG_sem_init(int initial_value)
417 {
418   return sg_sem_init(initial_value);
419 }
420 void MSG_sem_acquire(sg_sem_t sem)
421 {
422   sg_sem_acquire(sem);
423 }
424 int MSG_sem_acquire_timeout(sg_sem_t sem, double timeout)
425 {
426   return sg_sem_acquire_timeout(sem, timeout);
427 }
428 void MSG_sem_release(sg_sem_t sem)
429 {
430   sg_sem_release(sem);
431 }
432 int MSG_sem_get_capacity(const_sg_sem_t sem)
433 {
434   return sg_sem_get_capacity(sem);
435 }
436 void MSG_sem_destroy(const_sg_sem_t sem)
437 {
438   sg_sem_destroy(sem);
439 }
440 int MSG_sem_would_block(const_sg_sem_t sem)
441 {
442   return sg_sem_would_block(sem);
443 }