src/kernel/resource/FactorSet.cpp

   1 /* Copyright (c) 2016-2023. 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/kernel/resource/FactorSet.hpp"
   7 #include "xbt/ex.h"
   8 #include "xbt/file.hpp"
   9 #include "xbt/log.h"
  10 #include "xbt/parse_units.hpp"
  11 #include "xbt/str.h"
  12 #include "xbt/sysdep.h"
  13
  14 #include <algorithm>
  15 #include <boost/tokenizer.hpp>
  16
  17 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(ker_resource);
  18
  19 extern std::string simgrid_parsed_filename;
  20 extern int simgrid_parse_lineno;
  21
  22 namespace simgrid::kernel::resource {
  23
  24 void FactorSet::parse(const std::string& values)
  25 {
  26   initialized_    = true;
  27
  28   if (values.find_first_of(":;") == std::string::npos) { // Single value
  29     default_value_ = xbt_str_parse_double(values.c_str(), name_.c_str());
  30     return;
  31   }
  32
  33   /** Setup the tokenizer that parses the string **/
  34   using Tokenizer = boost::tokenizer<boost::char_separator<char>>;
  35   boost::char_separator<char> sep(";");
  36   boost::char_separator<char> factor_separator(":");
  37   Tokenizer tokens(values, sep);
  38
  39   /**
  40    * Iterate over patterns like A:B:C:D;E:F;G:H
  41    * These will be broken down into:
  42    * A --> B, C, D
  43    * E --> F
  44    * G --> H
  45    */
  46   for (auto token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter) {
  47     XBT_DEBUG("token: %s", token_iter->c_str());
  48     Tokenizer factor_values(*token_iter, factor_separator);
  49     s_smpi_factor_t fact;
  50     xbt_assert(factor_values.begin() != factor_values.end(), "Malformed radical for %s: '%s'", name_.c_str(),
  51                values.c_str());
  52     unsigned int iteration = 0;
  53     for (auto factor_iter = factor_values.begin(); factor_iter != factor_values.end(); ++factor_iter) {
  54       iteration++;
  55
  56       if (factor_iter == factor_values.begin()) { /* first element */
  57         try {
  58           fact.factor = std::stoi(*factor_iter);
  59         } catch (const std::invalid_argument&) {
  60           throw std::invalid_argument("Invalid factor in chunk " + std::to_string(factors_.size() + 1) + ": " +
  61                                       *factor_iter + " for " + name_);
  62         }
  63       } else {
  64         try {
  65           fact.values.push_back(xbt_parse_get_time(simgrid_parsed_filename, simgrid_parse_lineno, *factor_iter, ""));
  66         } catch (const std::invalid_argument&) {
  67           throw std::invalid_argument("Invalid factor value " + std::to_string(iteration) + " in chunk " +
  68                                       std::to_string(factors_.size() + 1) + ": " + *factor_iter + " for " + name_);
  69         }
  70       }
  71     }
  72
  73     factors_.push_back(fact);
  74     XBT_DEBUG("smpi_factor:\t%zu: %zu values, first: %f", fact.factor, factors_.size(), fact.values[0]);
  75   }
  76   std::sort(factors_.begin(), factors_.end(),
  77             [](const s_smpi_factor_t& pa, const s_smpi_factor_t& pb) { return (pa.factor < pb.factor); });
  78   for (auto const& fact : factors_) {
  79     XBT_DEBUG("smpi_factor:\t%zu: %zu values, first: %f", fact.factor, factors_.size(), fact.values[0]);
  80   }
  81   factors_.shrink_to_fit();
  82 }
  83
  84 FactorSet::FactorSet(const std::string& name, double default_value,
  85                      std::function<double(std::vector<double> const&, double)> const& lambda)
  86     : name_(name), default_value_(default_value), lambda_(lambda)
  87 {
  88 }
  89
  90 double FactorSet::operator()() const
  91 {
  92   return default_value_;
  93 }
  94
  95 double FactorSet::operator()(double size) const
  96 {
  97   if (factors_.empty())
  98     return default_value_;
  99
 100   for (long unsigned i = 0; i < factors_.size(); i++) {
 101     auto const& fact = factors_[i];
 102
 103     if (size <= fact.factor) { // Too large already, use the previous value
 104       if (i == 0) { // Before the first boundary: use the default value
 105         XBT_DEBUG("%s: %f <= %zu return default %f", name_.c_str(), size, fact.factor, default_value_);
 106         return default_value_;
 107       }
 108       double val = lambda_(factors_[i - 1].values, size);
 109       XBT_DEBUG("%s: %f <= %zu return %f", name_.c_str(), size, fact.factor, val);
 110       return val;
 111     }
 112   }
 113   double val = lambda_(factors_.back().values, size);
 114
 115   XBT_DEBUG("%s: %f > %zu return %f", name_.c_str(), size, factors_.back().factor, val);
 116   return val;
 117 }
 118 } // namespace simgrid::kernel::resource