src/simgrid/host.cpp

   1 /* Copyright (c) 2013-201. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #include <simgrid/simix.hpp>
   8
   9 #include "xbt/dict.h"
  10 #include "simgrid/host.h"
  11 #include "simgrid/Host.hpp"
  12 #include "surf/surf.h" // routing_get_network_element_type FIXME:killme
  13
  14 #include "src/simix/smx_private.hpp"
  15
  16 size_t sg_host_count()
  17 {
  18   return xbt_dict_length(host_list);
  19 }
  20
  21 const char *sg_host_get_name(sg_host_t host)
  22 {
  23         return host->getName().c_str();
  24 }
  25
  26 void* sg_host_extension_get(sg_host_t host, size_t ext)
  27 {
  28   return host->extension(ext);
  29 }
  30
  31 size_t sg_host_extension_create(void(*deleter)(void*))
  32 {
  33   return simgrid::Host::extension_create(deleter);
  34 }
  35
  36 sg_host_t sg_host_by_name(const char *name)
  37 {
  38   return simgrid::Host::by_name_or_null(name);
  39 }
  40
  41 sg_host_t sg_host_by_name_or_create(const char *name)
  42 {
  43   return simgrid::Host::by_name_or_create(name);
  44 }
  45
  46 xbt_dynar_t sg_hosts_as_dynar(void)
  47 {
  48         xbt_dynar_t res = xbt_dynar_new(sizeof(sg_host_t),NULL);
  49
  50   xbt_dict_cursor_t cursor = nullptr;
  51   const char* name = nullptr;
  52   simgrid::Host* host = nullptr;
  53         xbt_dict_foreach(host_list, cursor, name, host)
  54                 if(routing_get_network_element_type(name) == SURF_NETWORK_ELEMENT_HOST)
  55                         xbt_dynar_push(res, &host);
  56         return res;
  57 }
  58
  59 // ========= Layering madness ==============
  60
  61 int MSG_HOST_LEVEL;
  62 int SD_HOST_LEVEL;
  63 int SIMIX_HOST_LEVEL;
  64 int ROUTING_HOST_LEVEL;
  65 int USER_HOST_LEVEL;
  66
  67 #include "src/msg/msg_private.h" // MSG_host_priv_free. FIXME: killme by initializing that level in msg when used
  68 #include "src/simdag/simdag_private.h" // __SD_workstation_destroy. FIXME: killme by initializing that level in simdag when used
  69 #include "src/simix/smx_host_private.h" // SIMIX_host_destroy. FIXME: killme by initializing that level in simix when used
  70 #include "src/surf/cpu_interface.hpp"
  71 #include "src/surf/surf_routing.hpp"
  72
  73 void sg_host_init()
  74 {
  75   MSG_HOST_LEVEL = simgrid::Host::extension_create([](void *p) {
  76     __MSG_host_priv_free((msg_host_priv_t) p);
  77   });
  78
  79   ROUTING_HOST_LEVEL = simgrid::Host::extension_create([](void *p) {
  80           delete static_cast<simgrid::surf::NetCard*>(p);
  81   });
  82
  83   SD_HOST_LEVEL = simgrid::Host::extension_create(__SD_workstation_destroy);
  84   SIMIX_HOST_LEVEL = simgrid::Host::extension_create(SIMIX_host_destroy);
  85   USER_HOST_LEVEL = simgrid::Host::extension_create(NULL);
  86 }
  87
  88 // ========== User data Layer ==========
  89 void *sg_host_user(sg_host_t host) {
  90   return host->extension(USER_HOST_LEVEL);
  91 }
  92 void sg_host_user_set(sg_host_t host, void* userdata) {
  93   host->extension_set(USER_HOST_LEVEL,userdata);
  94 }
  95 void sg_host_user_destroy(sg_host_t host) {
  96   host->extension_set(USER_HOST_LEVEL, nullptr);
  97 }
  98
  99 // ========== MSG Layer ==============
 100 msg_host_priv_t sg_host_msg(sg_host_t host) {
 101         return (msg_host_priv_t) host->extension(MSG_HOST_LEVEL);
 102 }
 103 void sg_host_msg_set(sg_host_t host, msg_host_priv_t smx_host) {
 104   host->extension_set(MSG_HOST_LEVEL, smx_host);
 105 }
 106 void sg_host_msg_destroy(sg_host_t host) {
 107   host->extension_set(MSG_HOST_LEVEL, nullptr);
 108 }
 109 // ========== SimDag Layer ==============
 110 SD_workstation_priv_t sg_host_sd(sg_host_t host) {
 111   return (SD_workstation_priv_t) host->extension(SD_HOST_LEVEL);
 112 }
 113 void sg_host_sd_set(sg_host_t host, SD_workstation_priv_t smx_host) {
 114   host->extension_set(SD_HOST_LEVEL, smx_host);
 115 }
 116 void sg_host_sd_destroy(sg_host_t host) {
 117   host->extension_set(SD_HOST_LEVEL, nullptr);
 118 }
 119
 120 // ========== Simix layer =============
 121 smx_host_priv_t sg_host_simix(sg_host_t host){
 122   return (smx_host_priv_t) host->extension(SIMIX_HOST_LEVEL);
 123 }
 124 void sg_host_simix_set(sg_host_t host, smx_host_priv_t smx_host) {
 125   host->extension_set(SIMIX_HOST_LEVEL, smx_host);
 126 }
 127 void sg_host_simix_destroy(sg_host_t host) {
 128   host->extension_set(SIMIX_HOST_LEVEL, nullptr);
 129 }
 130
 131 // =========== user-level functions ===============
 132 // ================================================
 133
 134 double sg_host_get_available_speed(sg_host_t host){
 135   return surf_host_get_available_speed(host);
 136 }
 137 /** @brief Returns the state of a host.
 138  *  @return 1 if the host is active or 0 if it has crashed.
 139  */
 140 int sg_host_is_on(sg_host_t host) {
 141         return host->pimpl_cpu->isOn();
 142 }
 143
 144 /** @brief Returns the number of power states for a host.
 145  *
 146  *  See also @ref SURF_plugin_energy.
 147  */
 148 int sg_host_get_nb_pstates(sg_host_t host) {
 149   return host->pimpl_cpu->getNbPStates();
 150 }
 151
 152 /** @brief Gets the pstate at which that host currently runs.
 153  *
 154  *  See also @ref SURF_plugin_energy.
 155  */
 156 int sg_host_get_pstate(sg_host_t host) {
 157   return host->getPState();
 158 }
 159 /** @brief Sets the pstate at which that host should run.
 160  *
 161  *  See also @ref SURF_plugin_energy.
 162  */
 163 void sg_host_set_pstate(sg_host_t host,int pstate) {
 164   host->setPState(pstate);
 165 }
 166
 167 namespace simgrid {
 168
 169 Host::Host(std::string const& id)
 170   : name_(id)
 171 {
 172 }
 173
 174 Host::~Host()
 175 {
 176 }
 177
 178 /** Start the host if it is off */
 179 void Host::turnOn()
 180 {
 181   simgrid::simix::kernel(std::bind(SIMIX_host_on, this));
 182 }
 183
 184 /** Stop the host if it is on */
 185 void Host::turnOff()
 186 {
 187   /* Go to that function to follow the code flow through the simcall barrier */
 188   if (0) simcall_HANDLER_host_off(&SIMIX_process_self()->simcall, this);
 189   simgrid::simix::simcall<void>(SIMCALL_HOST_OFF, this);
 190 }
 191
 192 bool Host::isOn() {
 193   return pimpl_cpu->isOn();
 194 }
 195 bool Host::isOff() {
 196   return ! pimpl_cpu->isOn();
 197 }
 198
 199
 200 /** Get the properties assigned to a host */
 201 xbt_dict_t Host::getProperties()
 202 {
 203   return simgrid::simix::kernel(std::bind(sg_host_get_properties, this));
 204 }
 205
 206 /** Get the processes attached to the host */
 207 xbt_swag_t Host::getProcessList()
 208 {
 209   return simgrid::simix::kernel([&]() {
 210     return ((smx_host_priv_t)this->extension(SIMIX_HOST_LEVEL))->process_list;
 211   });
 212 }
 213
 214 /** Get the peak power of a host */
 215 double Host::getCurrentPowerPeak()
 216 {
 217   return simgrid::simix::kernel(
 218     std::bind(SIMIX_host_get_current_power_peak, this));
 219 }
 220
 221 /** Get one power peak (in flops/s) of a host at a given pstate */
 222 double Host::getPowerPeakAt(int pstate_index)
 223 {
 224   return simgrid::simix::kernel(
 225     std::bind(SIMIX_host_get_power_peak_at, this, pstate_index));
 226 }
 227
 228 /** @brief Get the speed of the cpu associated to a host */
 229 double Host::getSpeed() {
 230         return pimpl_cpu->getSpeed(1.0);
 231 }
 232 /** @brief Returns the number of core of the processor. */
 233 int Host::getCoreAmount() {
 234         return pimpl_cpu->getCore();
 235 }
 236
 237 Host* Host::by_name_or_null(const char* name)
 238 {
 239   return (Host*) xbt_dict_get_or_null(host_list, name);
 240 }
 241
 242 Host* Host::by_name_or_create(const char* name)
 243 {
 244   Host* host = by_name_or_null(name);
 245   if (host == nullptr) {
 246     host = new Host(name);
 247     xbt_dict_set(host_list, name, host, NULL);
 248   }
 249   return host;
 250 }
 251
 252 /** @brief Set the pstate at which the host should run */
 253 void Host::setPState(int pstate_index)
 254 {
 255   simgrid::simix::kernel(std::bind(
 256       &simgrid::surf::Cpu::setPState, pimpl_cpu, pstate_index
 257   ));
 258 }
 259 /** @brief Retrieve the pstate at which the host is currently running */
 260 int Host::getPState()
 261 {
 262   return pimpl_cpu->getPState();
 263 }
 264
 265 void Host::getParams(vm_params_t params)
 266 {
 267   simgrid::simix::kernel(std::bind(SIMIX_host_get_params, this, params));
 268 }
 269
 270 void Host::setParams(vm_params_t params)
 271 {
 272   simgrid::simix::kernel(std::bind(SIMIX_host_set_params, this, params));
 273 }
 274
 275 /**
 276  * \ingroup simix_storage_management
 277  * \brief Returns the list of storages mounted on an host.
 278  * \return a dict containing all storages mounted on the host
 279  */
 280 xbt_dict_t Host::getMountedStorageList()
 281 {
 282   return simgrid::simix::kernel(std::bind(
 283     SIMIX_host_get_mounted_storage_list, this
 284   ));
 285 }
 286
 287 /**
 288  * \ingroup simix_storage_management
 289  * \brief Returns the list of storages attached to an host.
 290  * \return a dict containing all storages attached to the host
 291  */
 292 xbt_dynar_t Host::getAttachedStorageList()
 293 {
 294   return simgrid::simix::kernel(std::bind(
 295     SIMIX_host_get_attached_storage_list, this
 296   ));
 297 }
 298
 299 }