src/msg/msg_legacy.cpp

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