Logo AND Algorithmique Numérique Distribuée

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