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->p_cpu->isOn();
 142 }
 143
 144 /** @brief Returns the total energy consumed by the host (in Joules).
 145  *
 146  *  See also @ref SURF_plugin_energy.
 147  */
 148 double sg_host_get_consumed_energy(sg_host_t host) {
 149         return surf_host_get_consumed_energy(host);
 150 }
 151
 152 /** @brief Returns the number of power states for a host.
 153  *
 154  *  See also @ref SURF_plugin_energy.
 155  */
 156 int sg_host_get_nb_pstates(sg_host_t host) {
 157   return host->p_cpu->getNbPStates();
 158 }
 159
 160 /** @brief Gets the pstate at which that host currently runs.
 161  *
 162  *  See also @ref SURF_plugin_energy.
 163  */
 164 int sg_host_get_pstate(sg_host_t host) {
 165         return host->p_cpu->getPState();
 166 }
 167
 168 namespace simgrid {
 169
 170 Host::Host(std::string const& id)
 171   : name_(id)
 172 {
 173 }
 174
 175 Host::~Host()
 176 {
 177 }
 178
 179 /** Start the host if it is off */
 180 void Host::turnOn()
 181 {
 182   simgrid::simix::kernel(std::bind(SIMIX_host_on, this));
 183 }
 184
 185 /** Stop the host if it is on */
 186 void Host::turnOff()
 187 {
 188   /* Go to that function to follow the code flow through the simcall barrier */
 189   if (0) simcall_HANDLER_host_off(&SIMIX_process_self()->simcall, this);
 190   simgrid::simix::simcall<void>(SIMCALL_HOST_OFF, this);
 191 }
 192
 193 bool Host::isOn() {
 194   return p_cpu->isOn();
 195 }
 196 bool Host::isOff() {
 197   return ! p_cpu->isOn();
 198 }
 199
 200
 201 /** Get the properties assigned to a host */
 202 xbt_dict_t Host::getProperties()
 203 {
 204   return simgrid::simix::kernel(std::bind(SIMIX_host_get_properties, this));
 205 }
 206
 207 /** Get the processes attached to the host */
 208 xbt_swag_t Host::getProcessList()
 209 {
 210   return simgrid::simix::kernel(std::bind(SIMIX_host_get_process_list, this));
 211 }
 212
 213 /** Get the peak power of a host */
 214 double Host::getCurrentPowerPeak()
 215 {
 216   return simgrid::simix::kernel(
 217     std::bind(SIMIX_host_get_current_power_peak, this));
 218 }
 219
 220 /** Get one power peak (in flops/s) of a host at a given pstate */
 221 double Host::getPowerPeakAt(int pstate_index)
 222 {
 223   return simgrid::simix::kernel(
 224     std::bind(SIMIX_host_get_power_peak_at, this, pstate_index));
 225 }
 226
 227 /** @brief Get the speed of the cpu associated to a host */
 228 double Host::getSpeed() {
 229         return p_cpu->getSpeed(1.0);
 230 }
 231 /** @brief Returns the number of core of the processor. */
 232 int Host::getCoreAmount() {
 233         return p_cpu->getCore();
 234 }
 235
 236 Host* Host::by_name_or_null(const char* name)
 237 {
 238   return (Host*) xbt_dict_get_or_null(host_list, name);
 239 }
 240
 241 Host* Host::by_name_or_create(const char* name)
 242 {
 243   Host* host = by_name_or_null(name);
 244   if (host == nullptr) {
 245     host = new Host(name);
 246     xbt_dict_set(host_list, name, host, NULL);
 247   }
 248   return host;
 249 }
 250
 251 /** Set the pstate at which the host should run */
 252 void Host::setPstate(int pstate_index)
 253 {
 254   simgrid::simix::kernel(
 255     std::bind(SIMIX_host_set_pstate, this, pstate_index));
 256 }
 257
 258 /** Get the amount of watt dissipated at the given pstate when the host is idling */
 259 double Host::getWattMinAt(int pstate)
 260 {
 261   return simgrid::simix::kernel(
 262     std::bind(SIMIX_host_get_wattmin_at, this, pstate));
 263 }
 264
 265 /** Get the amount of watt dissipated at the given pstate when the host burns CPU at 100% */
 266 double Host::getWattMaxAt(int pstate)
 267 {
 268   return simgrid::simix::kernel(
 269     std::bind(SIMIX_host_get_wattmax_at, this, pstate));
 270 }
 271
 272 void Host::getParams(vm_params_t params)
 273 {
 274   simgrid::simix::kernel(std::bind(SIMIX_host_get_params, this, params));
 275 }
 276
 277 void Host::setParams(vm_params_t params)
 278 {
 279   simgrid::simix::kernel(std::bind(SIMIX_host_set_params, this, params));
 280 }
 281
 282 /**
 283  * \ingroup simix_storage_management
 284  * \brief Returns the list of storages mounted on an host.
 285  * \return a dict containing all storages mounted on the host
 286  */
 287 xbt_dict_t Host::getMountedStorageList()
 288 {
 289   return simgrid::simix::kernel(std::bind(
 290     SIMIX_host_get_mounted_storage_list, this
 291   ));
 292 }
 293
 294 /**
 295  * \ingroup simix_storage_management
 296  * \brief Returns the list of storages attached to an host.
 297  * \return a dict containing all storages attached to the host
 298  */
 299 xbt_dynar_t Host::getAttachedStorageList()
 300 {
 301   return simgrid::simix::kernel(std::bind(
 302     SIMIX_host_get_attached_storage_list, this
 303   ));
 304 }
 305
 306 }