src/instr/jedule/jedule_platform.cpp

   1 /* Copyright (c) 2010-2016. 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/jedule/jedule.hpp"
   8 #include "simgrid/jedule/jedule_platform.hpp"
   9 #include "simgrid/s4u/NetZone.hpp"
  10 #include "xbt/asserts.h"
  11 #include "xbt/dynar.h"
  12 #include <algorithm>
  13
  14 #if HAVE_JEDULE
  15
  16 namespace simgrid {
  17 namespace jedule {
  18 Subset::Subset(int start_idx, int end_idx, Container* parent)
  19 : start_idx(start_idx), parent(parent)
  20 {
  21   nres=end_idx-start_idx+1;
  22 }
  23
  24
  25 Container::Container(std::string name): name(name)
  26 {
  27   container_name2container.insert({this->name, this});
  28 }
  29
  30 Container::~Container()
  31 {
  32   if(!this->children.empty())
  33     for (auto child: this->children)
  34       delete child;
  35 }
  36
  37 void Container::addChild(jed_container_t child)
  38 {
  39   xbt_assert(this != nullptr);
  40   xbt_assert(child != nullptr);
  41   this->children.push_back(child);
  42   child->parent = this;
  43 }
  44
  45 void Container::addResources(std::vector<sg_host_t> hosts)
  46 {
  47   this->is_lowest = 1;
  48   this->children.clear();
  49   this->last_id = 0;
  50
  51   //FIXME do we need to sort?: xbt_dynar_sort_strings(host_names);
  52
  53   for (auto host : hosts) {
  54     const char *host_name = sg_host_get_name(host);
  55     this->name2id.insert({host_name, this->last_id});
  56     (this->last_id)++;
  57     host2_simgrid_parent_container.insert({host_name, this});
  58     this->resource_list.push_back(host);
  59   }
  60 }
  61
  62 void Container::createHierarchy(sg_netzone_t from_as)
  63 {
  64   xbt_dict_cursor_t cursor = nullptr;
  65   char* key;
  66   sg_netzone_t elem;
  67   xbt_dict_t routing_sons = from_as->children();
  68
  69   if (xbt_dict_is_empty(routing_sons)) {
  70     // I am no AS
  71     // add hosts to jedule platform
  72     this->addResources(*from_as->hosts());
  73   } else {
  74     xbt_dict_foreach(routing_sons, cursor, key, elem) {
  75       jed_container_t child_container = new simgrid::jedule::Container(std::string(elem->name()));
  76       this->addChild(child_container);
  77       child_container->createHierarchy(elem);
  78     }
  79   }
  80 }
  81
  82 std::vector<int> Container::getHierarchy()
  83 {
  84   xbt_assert( this!= nullptr );
  85
  86   if(this->parent != nullptr ) {
  87
  88     if(!this->parent->children.empty()) {
  89       // we are in the last level
  90       return this->parent->getHierarchy();
  91     } else {
  92       unsigned int i =0;
  93       int child_nb = -1;
  94
  95       for (auto child : this->parent->children) {
  96         if( child == this) {
  97           child_nb = i;
  98           break;
  99         }
 100         i++;
 101       }
 102
 103       xbt_assert( child_nb > - 1);
 104       std::vector<int> heir_list = this->parent->getHierarchy();
 105       heir_list.insert(heir_list.begin(), child_nb);
 106       return heir_list;
 107     }
 108   } else {
 109     int top_level = 0;
 110     std::vector<int> heir_list = {top_level};
 111     return heir_list;
 112   }
 113 }
 114
 115 std::string Container::getHierarchyAsString()
 116 {
 117   std::string output("");
 118
 119   std::vector<int> heir_list = this->getHierarchy();
 120
 121   unsigned int length = heir_list.size();
 122   unsigned int i = 0;
 123   for (auto id : heir_list) {
 124     output += std::to_string(id);
 125     if( i != length-1 ) {
 126       output += ".";
 127     }
 128   }
 129
 130   return output;
 131 }
 132
 133 void Container::printResources(FILE * jed_file)
 134 {
 135   unsigned int i=0;
 136   xbt_assert(!this->resource_list.empty());
 137
 138   unsigned int res_nb = this->resource_list.size();
 139   std::string resid = this->getHierarchyAsString();
 140
 141   fprintf(jed_file, "      <rset id=\"%s\" nb=\"%u\" names=\"", resid.c_str(), res_nb);
 142   for (auto res: this->resource_list) {
 143     const char * res_name = sg_host_get_name(res);
 144     fprintf(jed_file, "%s", res_name);
 145     if( i != res_nb-1 ) {
 146       fprintf(jed_file, "|");
 147     }
 148     i++;
 149   }
 150   fprintf(jed_file, "\" />\n");
 151 }
 152
 153 void Container::print(FILE* jed_file)
 154 {
 155   xbt_assert( this != nullptr );
 156   fprintf(jed_file, "    <res name=\"%s\">\n", this->name.c_str());
 157   if( !this->children.empty()){
 158     for (auto child: this->children) {
 159       child->print(jed_file);
 160     }
 161   } else {
 162     this->printResources(jed_file);
 163   }
 164   fprintf(jed_file, "    </res>\n");
 165 }
 166
 167 }
 168 }
 169
 170 static void add_subsets_to(std::vector<jed_subset_t> *subset_list, std::vector<const char*> hostgroup, jed_container_t parent)
 171 {
 172   // get ids for each host
 173   // sort ids
 174   // compact ids
 175   // create subset for each id group
 176
 177   xbt_assert( parent != nullptr );
 178
 179   std::vector<unsigned int> id_list;
 180
 181   for (auto host_name : hostgroup) {
 182     xbt_assert( host_name != nullptr );
 183     jed_container_t parent = host2_simgrid_parent_container.at(host_name);
 184     unsigned int id = parent->name2id.at(host_name);
 185     id_list.push_back(id);
 186   }
 187   unsigned int nb_ids = id_list.size();
 188   std::sort(id_list.begin(), id_list.end());
 189
 190   if( nb_ids > 0 ) {
 191     int start = 0;
 192     int pos = start;
 193     for(unsigned int i=0; i<nb_ids; i++) {
 194       if( id_list[i] - id_list[pos] > 1 ) {
 195         subset_list->push_back(new simgrid::jedule::Subset(id_list[start], id_list[pos], parent));
 196         start = i;
 197
 198         if( i == nb_ids-1 ) {
 199          subset_list->push_back(new simgrid::jedule::Subset(id_list[i], id_list[i], parent));
 200         }
 201       } else {
 202         if( i == nb_ids-1 ) {
 203           subset_list->push_back(new simgrid::jedule::Subset(id_list[start], id_list[i], parent));
 204         }
 205       }
 206       pos = i;
 207     }
 208   }
 209
 210 }
 211
 212 void get_resource_selection_by_hosts(std::vector<jed_subset_t> *subset_list, std::vector<sg_host_t> *host_list)
 213 {
 214   xbt_assert( host_list != nullptr );
 215   // for each host name
 216   //  find parent container
 217   //  group by parent container
 218   std::unordered_map<const char*, std::vector<const char*>> parent2hostgroup;
 219   for (auto host: *host_list) {
 220     const char *host_name = sg_host_get_name(host);
 221     jed_container_t parent = host2_simgrid_parent_container.at(host_name);
 222     xbt_assert( parent != nullptr );
 223
 224     auto host_group = parent2hostgroup.find(parent->name.c_str());
 225     if (host_group == parent2hostgroup.end())
 226       parent2hostgroup.insert({parent->name.c_str(), std::vector<const char*>(1,host_name)});
 227     else
 228       host_group->second.push_back(host_name);
 229   }
 230
 231   for (auto elm: parent2hostgroup) {
 232     jed_container_t parent = container_name2container.at(elm.first);
 233     add_subsets_to(subset_list, elm.second, parent);
 234   }
 235 }
 236
 237 #endif