src/surf/host_clm03.cpp

   1 /* Copyright (c) 2013-2015. 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 "host_clm03.hpp"
   8
   9 #include "cpu_cas01.hpp"
  10 #include "simgrid/sg_config.h"
  11 #include "virtual_machine.hpp"
  12
  13 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_host);
  14
  15 /*************
  16  * CallBacks *
  17  *************/
  18
  19 /*********
  20  * Model *
  21  *********/
  22
  23 void surf_host_model_init_current_default(void)
  24 {
  25   surf_host_model = new HostCLM03Model();
  26   xbt_cfg_setdefault_boolean(_sg_cfg_set, "network/crosstraffic", "yes");
  27   surf_cpu_model_init_Cas01();
  28   surf_network_model_init_LegrandVelho();
  29
  30   Model *model = surf_host_model;
  31   xbt_dynar_push(all_existing_models, &model);
  32 }
  33
  34 void surf_host_model_init_compound()
  35 {
  36   xbt_assert(surf_cpu_model_pm, "No CPU model defined yet!");
  37   xbt_assert(surf_network_model, "No network model defined yet!");
  38
  39   surf_host_model = new HostCLM03Model();
  40   xbt_dynar_push(all_existing_models, &surf_host_model);
  41 }
  42
  43 Host *HostCLM03Model::createHost(const char *name,RoutingEdge *netElm, Cpu *cpu){
  44   Host *host = new HostCLM03(surf_host_model, name, NULL,
  45                   (xbt_dynar_t)xbt_lib_get_or_null(storage_lib, name, ROUTING_STORAGE_HOST_LEVEL),
  46                   netElm, cpu);
  47   surf_callback_emit(hostCreatedCallbacks, host);
  48   XBT_DEBUG("Create host %s with %ld mounted disks", name, xbt_dynar_length(host->p_storage));
  49   xbt_lib_set(host_lib, name, SURF_HOST_LEVEL, host);
  50   return host;
  51 }
  52
  53 double HostCLM03Model::shareResources(double now){
  54   adjustWeightOfDummyCpuActions();
  55
  56   double min_by_cpu = surf_cpu_model_pm->shareResources(now);
  57   double min_by_net = surf_network_model->shareResourcesIsIdempotent() ? surf_network_model->shareResources(now) : -1;
  58   double min_by_sto = surf_storage_model->shareResources(now);
  59
  60   XBT_DEBUG("model %p, %s min_by_cpu %f, %s min_by_net %f, %s min_by_sto %f",
  61       this, typeid(surf_cpu_model_pm).name(), min_by_cpu,
  62                 typeid(surf_network_model).name(), min_by_net,
  63                         typeid(surf_storage_model).name(), min_by_sto);
  64
  65   double res = max(max(min_by_cpu, min_by_net), min_by_sto);
  66   if (min_by_cpu >= 0.0 && min_by_cpu < res)
  67         res = min_by_cpu;
  68   if (min_by_net >= 0.0 && min_by_net < res)
  69         res = min_by_net;
  70   if (min_by_sto >= 0.0 && min_by_sto < res)
  71         res = min_by_sto;
  72   return res;
  73 }
  74
  75 void HostCLM03Model::updateActionsState(double /*now*/, double /*delta*/){
  76   return;
  77 }
  78
  79 Action *HostCLM03Model::executeParallelTask(int host_nb,
  80                                         sg_host_t *host_list,
  81                                         double *flops_amount,
  82                                         double *bytes_amount,
  83                                         double rate){
  84 #define cost_or_zero(array,pos) ((array)?(array)[pos]:0.0)
  85   Action *action =NULL;
  86   if ((host_nb == 1)
  87       && (cost_or_zero(bytes_amount, 0) == 0.0)){
  88     action = surf_host_execute(host_list[0],flops_amount[0]);
  89   } else if ((host_nb == 1)
  90            && (cost_or_zero(flops_amount, 0) == 0.0)) {
  91     action = surf_network_model->communicate(sg_host_edge(host_list[0]),
  92                                                  sg_host_edge(host_list[0]),
  93                                                                                          bytes_amount[0], rate);
  94   } else if ((host_nb == 2)
  95              && (cost_or_zero(flops_amount, 0) == 0.0)
  96              && (cost_or_zero(flops_amount, 1) == 0.0)) {
  97     int i,nb = 0;
  98     double value = 0.0;
  99
 100     for (i = 0; i < host_nb * host_nb; i++) {
 101       if (cost_or_zero(bytes_amount, i) > 0.0) {
 102         nb++;
 103         value = cost_or_zero(bytes_amount, i);
 104       }
 105     }
 106     if (nb == 1){
 107       action = surf_network_model->communicate(sg_host_edge(host_list[0]),
 108                                                    sg_host_edge(host_list[1]),
 109                                                                                            value, rate);
 110     }
 111   } else
 112     THROW_UNIMPLEMENTED;      /* This model does not implement parallel tasks for more than 2 hosts */
 113 #undef cost_or_zero
 114   xbt_free(host_list);
 115   return action;
 116 }
 117
 118 /************
 119  * Resource *
 120  ************/
 121 HostCLM03::HostCLM03(HostModel *model, const char* name, xbt_dict_t properties, xbt_dynar_t storage, RoutingEdge *netElm, Cpu *cpu)
 122   : Host(model, name, properties, storage, netElm, cpu) {}
 123
 124 bool HostCLM03::isUsed(){
 125   THROW_IMPOSSIBLE;             /* This model does not implement parallel tasks */
 126   return -1;
 127 }
 128
 129 void HostCLM03::updateState(tmgr_trace_event_t /*event_type*/, double /*value*/, double /*date*/){
 130   THROW_IMPOSSIBLE;             /* This model does not implement parallel tasks */
 131 }
 132
 133 Action *HostCLM03::execute(double size) {
 134   return p_cpu->execute(size);
 135 }
 136
 137 Action *HostCLM03::sleep(double duration) {
 138   return p_cpu->sleep(duration);
 139 }
 140
 141 e_surf_resource_state_t HostCLM03::getState() {
 142   return p_cpu->getState();
 143 }
 144
 145 /**********
 146  * Action *
 147  **********/