Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Merge pull request #307 from Jean-Emile/v3.20-expose-simgrid-jni
[simgrid.git] / src / msg / msg_legacy.cpp
1 /* Copyright (c) 2004-2018. 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 "src/msg/msg_private.hpp"
7
8 #define MSG_CALL(type, oldname, args)
9
10 /* ************************** Engine *************************** */
11 void MSG_create_environment(const char* filename)
12 {
13   simgrid_load_platform(filename);
14 }
15
16 void MSG_launch_application(const char* filename)
17 {
18   simgrid_load_deployment(filename);
19 }
20 msg_error_t MSG_main()
21 {
22   simgrid_run();
23   return MSG_OK;
24 }
25 void MSG_function_register(const char* name, xbt_main_func_t code)
26 {
27   simgrid_register_function(name, code);
28 }
29 void MSG_function_register_default(xbt_main_func_t code)
30 {
31   simgrid_register_default(code);
32 }
33 double MSG_get_clock()
34 {
35   return simgrid_get_clock();
36 }
37
38 /* ************************** Mailboxes ************************ */
39 void MSG_mailbox_set_async(const char* alias)
40 {
41   sg_mailbox_set_receiver(alias);
42 }
43 int MSG_task_listen(const char* alias)
44 {
45   return sg_mailbox_listen(alias);
46 }
47
48 /* ************************** Actors *************************** */
49 int MSG_process_get_PID(sg_actor_t actor)
50 {
51   return sg_actor_get_PID(actor);
52 }
53 int MSG_process_get_PPID(sg_actor_t actor)
54 {
55   return sg_actor_get_PPID(actor);
56 }
57 msg_process_t MSG_process_from_PID(int PID)
58 {
59   return sg_actor_by_PID(PID);
60 }
61 const char* MSG_process_get_name(sg_actor_t actor)
62 {
63   return sg_actor_get_name(actor);
64 }
65 sg_host_t MSG_process_get_host(sg_actor_t actor)
66 {
67   return sg_actor_get_host(actor);
68 }
69 xbt_dict_t MSG_process_get_properties(sg_actor_t actor)
70 {
71   return sg_actor_get_properties(actor);
72 }
73 const char* MSG_process_get_property_value(sg_actor_t actor, const char* name)
74 {
75   return sg_actor_get_property_value(actor, name);
76 }
77 void MSG_process_suspend(sg_actor_t actor)
78 {
79   sg_actor_suspend(actor);
80 }
81 void MSG_process_resume(sg_actor_t actor)
82 {
83   sg_actor_resume(actor);
84 }
85 int MSG_process_is_suspended(sg_actor_t actor)
86 {
87   return sg_actor_is_suspended(actor);
88 }
89 void MSG_process_restart(sg_actor_t actor)
90 {
91   sg_actor_restart(actor);
92 }
93 void MSG_process_auto_restart_set(sg_actor_t actor, int auto_restart)
94 {
95   sg_actor_set_auto_restart(actor, auto_restart);
96 }
97
98 void MSG_process_daemonize(sg_actor_t actor)
99 {
100   sg_actor_daemonize(actor);
101 }
102 void MSG_process_migrate(sg_actor_t actor, sg_host_t host)
103 {
104   sg_actor_migrate(actor, host);
105 }
106 void MSG_process_join(sg_actor_t actor, double timeout)
107 {
108   sg_actor_join(actor, timeout);
109 }
110 void MSG_process_kill(sg_actor_t actor)
111 {
112   sg_actor_kill(actor);
113 }
114 void MSG_process_killall()
115 {
116   sg_actor_kill_all();
117 }
118 void MSG_process_set_kill_time(sg_actor_t actor, double kill_time)
119 {
120   sg_actor_set_kill_time(actor, kill_time);
121 }
122 void MSG_process_yield()
123 {
124   sg_actor_yield();
125 }
126
127 /* ************************** NetZones *************************** */
128 sg_netzone_t MSG_zone_get_root()
129 {
130   return sg_zone_get_root();
131 }
132 const char* MSG_zone_get_name(sg_netzone_t zone)
133 {
134   return sg_zone_get_name(zone);
135 }
136 sg_netzone_t MSG_zone_get_by_name(const char* name)
137 {
138   return sg_zone_get_by_name(name);
139 }
140 void MSG_zone_get_sons(sg_netzone_t zone, xbt_dict_t whereto)
141 {
142   return sg_zone_get_sons(zone, whereto);
143 }
144 const char* MSG_zone_get_property_value(sg_netzone_t zone, const char* name)
145 {
146   return sg_zone_get_property_value(zone, name);
147 }
148 void MSG_zone_set_property_value(sg_netzone_t zone, const char* name, char* value)
149 {
150   sg_zone_set_property_value(zone, name, value);
151 }
152 void MSG_zone_get_hosts(sg_netzone_t zone, xbt_dynar_t whereto)
153 {
154   sg_zone_get_hosts(zone, whereto);
155 }
156
157 /* ************************** Storages *************************** */
158 const char* MSG_storage_get_name(sg_storage_t storage)
159 {
160   return sg_storage_get_name(storage);
161 }
162 sg_storage_t MSG_storage_get_by_name(const char* name)
163 {
164   return sg_storage_get_by_name(name);
165 }
166 xbt_dict_t MSG_storage_get_properties(sg_storage_t storage)
167 {
168   return sg_storage_get_properties(storage);
169 }
170 void MSG_storage_set_property_value(sg_storage_t storage, const char* name, const char* value)
171 {
172   sg_storage_set_property_value(storage, name, value);
173 }
174 const char* MSG_storage_get_property_value(sg_storage_t storage, const char* name)
175 {
176   return sg_storage_get_property_value(storage, name);
177 }
178 xbt_dynar_t MSG_storages_as_dynar()
179 {
180   return sg_storages_as_dynar();
181 }
182 void MSG_storage_set_data(sg_storage_t storage, void* data)
183 {
184   sg_storage_set_data(storage, data);
185 }
186 void* MSG_storage_get_data(sg_storage_t storage)
187 {
188   return sg_storage_get_data(storage);
189 }
190 const char* MSG_storage_get_host(sg_storage_t storage)
191 {
192   return sg_storage_get_host(storage);
193 }
194 sg_size_t MSG_storage_read(sg_storage_t storage, sg_size_t size)
195 {
196   return sg_storage_read(storage, size);
197 }
198 sg_size_t MSG_storage_write(sg_storage_t storage, sg_size_t size)
199 {
200   return sg_storage_write(storage, size);
201 }
202
203 /* ************************** hosts *************************** */
204 xbt_dynar_t MSG_hosts_as_dynar()
205 {
206   return sg_hosts_as_dynar();
207 }
208 size_t MSG_get_host_number()
209 {
210   return sg_host_count();
211 }
212 sg_host_t MSG_get_host_by_name(const char* name)
213 {
214   return sg_host_by_name(name);
215 }
216 sg_host_t MSG_host_by_name(const char* name)
217 {
218   return sg_host_by_name(name);
219 }
220 const char* MSG_host_get_name(sg_host_t host)
221 {
222   return sg_host_get_name(host);
223 }
224 void* MSG_host_get_data(sg_host_t host)
225 {
226   return sg_host_user(host);
227 }
228 void MSG_host_set_data(sg_host_t host, void* data)
229 {
230   return sg_host_user_set(host, data);
231 }
232 xbt_dict_t MSG_host_get_mounted_storage_list(sg_host_t host)
233 {
234   return sg_host_get_mounted_storage_list(host);
235 }
236 xbt_dynar_t MSG_host_get_attached_storage_lists(sg_host_t host)
237 {
238   return sg_host_get_attached_storage_list(host);
239 }
240 double MSG_host_get_speed(sg_host_t host)
241 {
242   return sg_host_speed(host);
243 }
244 double MSG_host_get_power_peak_at(sg_host_t host, int pstate_index)
245 {
246   return sg_host_get_pstate_speed(host, pstate_index);
247 }
248 int MSG_host_get_core_number(sg_host_t host)
249 {
250   return sg_host_core_count(host);
251 }
252 int MSG_host_get_nb_pstates(sg_host_t host)
253 {
254   return sg_host_get_nb_pstates(host);
255 }
256 int MSG_host_get_pstate(sg_host_t host)
257 {
258   return sg_host_get_pstate(host);
259 }
260 void MSG_host_set_pstate(sg_host_t host, int pstate)
261 {
262   sg_host_set_pstate(host, pstate);
263 }
264 void MSG_host_on(sg_host_t h)
265 {
266   sg_host_turn_on(h);
267 }
268 void MSG_host_off(sg_host_t h)
269 {
270   sg_host_turn_off(h);
271 }
272 int MSG_host_is_on(sg_host_t h)
273 {
274   return sg_host_is_on(h);
275 }
276 int MSG_host_is_off(sg_host_t h)
277 {
278   return sg_host_is_off(h);
279 }
280 xbt_dict_t MSG_host_get_properties(sg_host_t host)
281 {
282   return sg_host_get_properties(host);
283 }
284 const char* MSG_host_get_property_value(sg_host_t host, const char* name)
285 {
286   return sg_host_get_property_value(host, name);
287 }
288 void MSG_host_set_property_value(sg_host_t host, const char* name, const char* value)
289 {
290   sg_host_set_property_value(host, name, value);
291 }
292 void MSG_host_get_process_list(sg_host_t host, xbt_dynar_t whereto)
293 {
294   sg_host_get_actor_list(host, whereto);
295 }
296 sg_host_t MSG_host_self()
297 {
298   return sg_host_self();
299 }
300
301 double MSG_host_get_load(sg_host_t host)
302 {
303   return sg_host_load(host);
304 }
305 /* ************************** Virtual Machines *************************** */
306 sg_vm_t MSG_vm_create_core(sg_host_t pm, const char* name)
307 {
308   return sg_vm_create_core(pm, name);
309 }
310 sg_vm_t MSG_vm_create_multicore(sg_host_t pm, const char* name, int coreAmount)
311 {
312   return sg_vm_create_multicore(pm, name, coreAmount);
313 }
314 int MSG_vm_is_created(sg_vm_t vm)
315 {
316   return sg_vm_is_created(vm);
317 }
318 int MSG_vm_is_running(sg_vm_t vm)
319 {
320   return sg_vm_is_running(vm);
321 }
322 int MSG_vm_is_suspended(sg_vm_t vm)
323 {
324   return sg_vm_is_suspended(vm);
325 }
326 const char* MSG_vm_get_name(sg_vm_t vm)
327 {
328   return sg_vm_get_name(vm);
329 }
330 void MSG_vm_set_ramsize(sg_vm_t vm, size_t size)
331 {
332   sg_vm_set_ramsize(vm, size);
333 }
334 size_t MSG_vm_get_ramsize(sg_vm_t vm)
335 {
336   return sg_vm_get_ramsize(vm);
337 }
338 sg_host_t MSG_vm_get_pm(sg_vm_t vm)
339 {
340   return sg_vm_get_pm(vm);
341 }
342 void MSG_vm_set_bound(sg_vm_t vm, double bound)
343 {
344   sg_vm_set_bound(vm, bound);
345 }
346 void MSG_vm_start(sg_vm_t vm)
347 {
348   sg_vm_start(vm);
349 }
350 void MSG_vm_suspend(sg_vm_t vm)
351 {
352   sg_vm_suspend(vm);
353 }
354 void MSG_vm_resume(sg_vm_t vm)
355 {
356   sg_vm_resume(vm);
357 }
358 void MSG_vm_shutdown(sg_vm_t vm)
359 {
360   sg_vm_shutdown(vm);
361 }
362 void MSG_vm_destroy(sg_vm_t vm)
363 {
364   sg_vm_destroy(vm);
365 }
366 /********* barriers ************/
367 sg_bar_t MSG_barrier_init(unsigned int count)
368 {
369   return sg_barrier_init(count);
370 }
371
372 void MSG_barrier_destroy(sg_bar_t bar)
373 {
374   sg_barrier_destroy(bar);
375 }
376
377 int MSG_barrier_wait(sg_bar_t bar)
378 {
379   return sg_barrier_wait(bar);
380 }