}
namespace lmm {
class s_lmm_element_t;
-class s_lmm_variable_t;
+class Variable;
class s_lmm_constraint_t;
class s_lmm_constraint_light_t;
class s_lmm_system_t;
typedef simgrid::kernel::lmm::s_lmm_element_t* lmm_element_t;
typedef const simgrid::kernel::lmm::s_lmm_element_t* const_lmm_element_t;
-typedef simgrid::kernel::lmm::s_lmm_variable_t* lmm_variable_t;
+typedef simgrid::kernel::lmm::Variable* lmm_variable_t;
typedef simgrid::kernel::lmm::s_lmm_constraint_t* lmm_constraint_t;
typedef simgrid::kernel::lmm::s_lmm_constraint_light_t* lmm_constraint_light_t;
typedef simgrid::kernel::lmm::s_lmm_system_t* lmm_system_t;
return;
XBT_DEBUG("Variable set : %zu", sys->variable_set.size());
- for (s_lmm_variable_t& var : sys->variable_set) {
+ for (Variable& var : sys->variable_set) {
var.value = 0.0;
XBT_DEBUG("Handling variable %p", &var);
if (var.sharing_weight > 0.0 && std::find_if(begin(var.cnsts), end(var.cnsts), [](s_lmm_element_t const& x) {
}
for (auto iter = std::begin(var_list); iter != std::end(var_list);) {
- s_lmm_variable_t& var = *iter;
+ Variable& var = *iter;
double min_inc = DBL_MAX;
for (s_lmm_element_t const& elm : var.cnsts) {
if (elm.consumption_weight > 0)
namespace kernel {
namespace lmm {
-double (*func_f_def)(const s_lmm_variable_t&, double);
-double (*func_fp_def)(const s_lmm_variable_t&, double);
-double (*func_fpi_def)(const s_lmm_variable_t&, double);
+double (*func_f_def)(const Variable&, double);
+double (*func_fp_def)(const Variable&, double);
+double (*func_fpi_def)(const Variable&, double);
/*
* Local prototypes to implement the Lagrangian optimization with optimal step, also called dichotomy.
XBT_DEBUG("Checking feasability for constraint (%p): sat = %f, lambda = %f ", &cnst, tmp - cnst.bound, cnst.lambda);
}
- for (s_lmm_variable_t const& var : var_list) {
+ for (Variable const& var : var_list) {
if (not var.sharing_weight)
break;
if (var.bound < 0)
return 1;
}
-static double new_value(const s_lmm_variable_t& var)
+static double new_value(const Variable& var)
{
double tmp = 0;
return var.func_fpi(var, tmp);
}
-static double new_mu(const s_lmm_variable_t& var)
+static double new_mu(const Variable& var)
{
double mu_i = 0.0;
double sigma_i = 0.0;
{
double obj = 0.0;
- for (s_lmm_variable_t const& var : var_list) {
+ for (Variable const& var : var_list) {
double sigma_i = 0.0;
if (not var.sharing_weight)
* Initialize the var_list variable with only the active variables. Initialize mu.
*/
auto& var_list = sys->variable_set;
- for (s_lmm_variable_t& var : var_list) {
+ for (Variable& var : var_list) {
if (not var.sharing_weight)
var.value = 0.0;
else {
XBT_DEBUG("-------------- Gradient Descent ----------");
/* Improve the value of mu_i */
- for (s_lmm_variable_t& var : var_list) {
+ for (Variable& var : var_list) {
if (var.sharing_weight && var.bound >= 0) {
XBT_DEBUG("Working on var (%p)", &var);
var.new_mu = new_mu(var);
/* Now computes the values of each variable (\rho) based on the values of \lambda and \mu. */
XBT_DEBUG("-------------- Check convergence ----------");
overall_modification = 0;
- for (s_lmm_variable_t& var : var_list) {
+ for (Variable& var : var_list) {
if (var.sharing_weight <= 0)
var.value = 0.0;
else {
XBT_CDEBUG(surf_lagrange_dichotomy, "Computing diff of cnst (%p)", &cnst);
for (s_lmm_element_t const& elem : cnst.enabled_element_set) {
- s_lmm_variable_t& var = *elem.variable;
+ Variable& var = *elem.variable;
xbt_assert(var.sharing_weight > 0);
XBT_CDEBUG(surf_lagrange_dichotomy, "Computing sigma_i for var (%p)", &var);
// Initialize the summation variable
* programming.
*
*/
-void lmm_set_default_protocol_function(double (*func_f)(const s_lmm_variable_t& var, double x),
- double (*func_fp)(const s_lmm_variable_t& var, double x),
- double (*func_fpi)(const s_lmm_variable_t& var, double x))
+void lmm_set_default_protocol_function(double (*func_f)(const Variable& var, double x),
+ double (*func_fp)(const Variable& var, double x),
+ double (*func_fpi)(const Variable& var, double x))
{
func_f_def = func_f;
func_fp_def = func_fp;
* Therefore: $fp(x) = \frac{\alpha D_f}{x}$
* Therefore: $fpi(x) = \frac{\alpha D_f}{x}$
*/
-double func_vegas_f(const s_lmm_variable_t& var, double x)
+double func_vegas_f(const Variable& var, double x)
{
xbt_assert(x > 0.0, "Don't call me with stupid values! (%1.20f)", x);
return VEGAS_SCALING * var.sharing_weight * log(x);
}
-double func_vegas_fp(const s_lmm_variable_t& var, double x)
+double func_vegas_fp(const Variable& var, double x)
{
xbt_assert(x > 0.0, "Don't call me with stupid values! (%1.20f)", x);
return VEGAS_SCALING * var.sharing_weight / x;
}
-double func_vegas_fpi(const s_lmm_variable_t& var, double x)
+double func_vegas_fpi(const Variable& var, double x)
{
xbt_assert(x > 0.0, "Don't call me with stupid values! (%1.20f)", x);
return var.sharing_weight / (x / VEGAS_SCALING);
* Therefore: $fp(x) = \frac{3}{3 D_f^2 x^2+2}$
* Therefore: $fpi(x) = \sqrt{\frac{1}{{D_f}^2 x} - \frac{2}{3{D_f}^2}}$
*/
-double func_reno_f(const s_lmm_variable_t& var, double x)
+double func_reno_f(const Variable& var, double x)
{
xbt_assert(var.sharing_weight > 0.0, "Don't call me with stupid values!");
return RENO_SCALING * sqrt(3.0 / 2.0) / var.sharing_weight * atan(sqrt(3.0 / 2.0) * var.sharing_weight * x);
}
-double func_reno_fp(const s_lmm_variable_t& var, double x)
+double func_reno_fp(const Variable& var, double x)
{
return RENO_SCALING * 3.0 / (3.0 * var.sharing_weight * var.sharing_weight * x * x + 2.0);
}
-double func_reno_fpi(const s_lmm_variable_t& var, double x)
+double func_reno_fpi(const Variable& var, double x)
{
double res_fpi;
* Therefore: $fp(x) = 2/(Weight*x + 2)
* Therefore: $fpi(x) = (2*Weight)/x - 4
*/
-double func_reno2_f(const s_lmm_variable_t& var, double x)
+double func_reno2_f(const Variable& var, double x)
{
xbt_assert(var.sharing_weight > 0.0, "Don't call me with stupid values!");
return RENO2_SCALING * (1.0 / var.sharing_weight) *
log((x * var.sharing_weight) / (2.0 * x * var.sharing_weight + 3.0));
}
-double func_reno2_fp(const s_lmm_variable_t& var, double x)
+double func_reno2_fp(const Variable& var, double x)
{
return RENO2_SCALING * 3.0 / (var.sharing_weight * x * (2.0 * var.sharing_weight * x + 3.0));
}
-double func_reno2_fpi(const s_lmm_variable_t& var, double x)
+double func_reno2_fpi(const Variable& var, double x)
{
xbt_assert(x > 0.0, "Don't call me with stupid values!");
double tmp = x * var.sharing_weight * var.sharing_weight;
typedef std::vector<int> dyn_light_t;
-int s_lmm_variable_t::Global_debug_id = 1;
+int Variable::Global_debug_id = 1;
int s_lmm_constraint_t::Global_debug_id = 1;
int s_lmm_element_t::get_concurrency() const
}
// Check that for each variable, all corresponding elements are in the same state (i.e. same element sets)
- for (s_lmm_variable_t const& var : variable_set) {
+ for (Variable const& var : variable_set) {
if (var.cnsts.empty())
continue;
void* s_lmm_system_t::variable_mallocator_new_f()
{
- return new s_lmm_variable_t;
+ return new Variable;
}
void s_lmm_system_t::variable_mallocator_free_f(void* var)
std::string buf = std::string("MAX-MIN ( ");
/* Printing Objective */
- for (s_lmm_variable_t const& var : variable_set)
+ for (Variable const& var : variable_set)
buf += "'" + std::to_string(var.id_int) + "'(" + std::to_string(var.sharing_weight) + ") ";
buf += ")";
XBT_DEBUG("%20s", buf.c_str());
XBT_DEBUG("Variables");
/* Printing Result */
- for (s_lmm_variable_t const& var : variable_set) {
+ for (Variable const& var : variable_set) {
if (var.bound > 0) {
XBT_DEBUG("'%d'(%f) : %f (<=%f)", var.id_int, var.sharing_weight, var.value, var.bound);
xbt_assert(not double_positive(var.value - var.bound, var.bound * sg_maxmin_precision),
do {
/* Fix the variables that have to be */
auto& var_list = saturated_variable_set;
- for (s_lmm_variable_t const& var : var_list) {
+ for (Variable const& var : var_list) {
if (var.sharing_weight <= 0.0)
DIE_IMPOSSIBLE;
/* First check if some of these variables could reach their upper bound and update min_bound accordingly. */
}
while (not var_list.empty()) {
- s_lmm_variable_t& var = var_list.front();
+ Variable& var = var_list.front();
if (min_bound < 0) {
// If no variable could reach its bound, deal iteratively the constraints usage ( at worst one constraint is
// saturated at each cycle)
update_modified_set(var->cnsts[0].constraint);
}
-void s_lmm_variable_t::initialize(simgrid::surf::Action* id_value, double sharing_weight_value, double bound_value,
- int number_of_constraints, unsigned visited_value)
+void Variable::initialize(simgrid::surf::Action* id_value, double sharing_weight_value, double bound_value,
+ int number_of_constraints, unsigned visited_value)
{
id = id_value;
id_int = Global_debug_id++;
xbt_assert(not saturated_variable_set_hook.is_linked());
}
-int s_lmm_variable_t::get_min_concurrency_slack() const
+int Variable::get_min_concurrency_slack() const
{
int minslack = std::numeric_limits<int>::max();
for (s_lmm_element_t const& elem : cnsts) {
// (i.e. not readibily reproducible, and requiring a lot of run time before happening).
if (++visited_counter == 1) {
/* the counter wrapped around, reset each variable->visited */
- for (s_lmm_variable_t& var : variable_set)
+ for (Variable& var : variable_set)
var.visited = 0;
}
modified_constraint_set.clear();
/** Default functions associated to the chosen protocol. When using the lagrangian approach. */
XBT_PUBLIC(void)
-lmm_set_default_protocol_function(double (*func_f)(const s_lmm_variable_t& var, double x),
- double (*func_fp)(const s_lmm_variable_t& var, double x),
- double (*func_fpi)(const s_lmm_variable_t& var, double x));
+lmm_set_default_protocol_function(double (*func_f)(const Variable& var, double x),
+ double (*func_fp)(const Variable& var, double x),
+ double (*func_fpi)(const Variable& var, double x));
-XBT_PUBLIC(double) func_reno_f(const s_lmm_variable_t& var, double x);
-XBT_PUBLIC(double) func_reno_fp(const s_lmm_variable_t& var, double x);
-XBT_PUBLIC(double) func_reno_fpi(const s_lmm_variable_t& var, double x);
+XBT_PUBLIC(double) func_reno_f(const Variable& var, double x);
+XBT_PUBLIC(double) func_reno_fp(const Variable& var, double x);
+XBT_PUBLIC(double) func_reno_fpi(const Variable& var, double x);
-XBT_PUBLIC(double) func_reno2_f(const s_lmm_variable_t& var, double x);
-XBT_PUBLIC(double) func_reno2_fp(const s_lmm_variable_t& var, double x);
-XBT_PUBLIC(double) func_reno2_fpi(const s_lmm_variable_t& var, double x);
+XBT_PUBLIC(double) func_reno2_f(const Variable& var, double x);
+XBT_PUBLIC(double) func_reno2_fp(const Variable& var, double x);
+XBT_PUBLIC(double) func_reno2_fpi(const Variable& var, double x);
-XBT_PUBLIC(double) func_vegas_f(const s_lmm_variable_t& var, double x);
-XBT_PUBLIC(double) func_vegas_fp(const s_lmm_variable_t& var, double x);
-XBT_PUBLIC(double) func_vegas_fpi(const s_lmm_variable_t& var, double x);
+XBT_PUBLIC(double) func_vegas_f(const Variable& var, double x);
+XBT_PUBLIC(double) func_vegas_fp(const Variable& var, double x);
+XBT_PUBLIC(double) func_vegas_fpi(const Variable& var, double x);
/**
* @brief LMM element
* When something prevents us from enabling a variable, we "stage" the weight that we would have like to set, so that as
* soon as possible we enable the variable with desired weight
*/
-XBT_PUBLIC_CLASS s_lmm_variable_t
+XBT_PUBLIC_CLASS Variable
{
public:
- void initialize(simgrid::surf::Action * id_value, double sharing_weight_value, double bound_value,
+ void initialize(simgrid::surf::Action* id_value, double sharing_weight_value, double bound_value,
int number_of_constraints, unsigned visited_value);
/**
/* \begin{For Lagrange only} */
double mu;
double new_mu;
- double (*func_f)(const s_lmm_variable_t& var, double x); /* (f) */
- double (*func_fp)(const s_lmm_variable_t& var, double x); /* (f') */
- double (*func_fpi)(const s_lmm_variable_t& var, double x); /* (f')^{-1} */
+ double (*func_f)(const Variable& var, double x); /* (f) */
+ double (*func_fp)(const Variable& var, double x); /* (f') */
+ double (*func_fpi)(const Variable& var, double x); /* (f')^{-1} */
/* \end{For Lagrange only} */
private:
* @param bound The maximum value of the variable (-1.0 if no maximum value)
* @param number_of_constraints The maximum number of constraint to associate to the variable
*/
- lmm_variable_t variable_new(simgrid::surf::Action * id, double weight_value, double bound, int number_of_constraints);
+ lmm_variable_t variable_new(simgrid::surf::Action* id, double weight_value, double bound, int number_of_constraints);
/**
* @brief Free a variable
template <class CnstList> void solve(CnstList& cnst_list);
public:
bool modified;
- boost::intrusive::list<s_lmm_variable_t,
- boost::intrusive::member_hook<s_lmm_variable_t, boost::intrusive::list_member_hook<>,
- &s_lmm_variable_t::variable_set_hook>>
+ boost::intrusive::list<Variable, boost::intrusive::member_hook<Variable, boost::intrusive::list_member_hook<>,
+ &Variable::variable_set_hook>>
variable_set;
boost::intrusive::list<s_lmm_constraint_t,
boost::intrusive::member_hook<s_lmm_constraint_t, boost::intrusive::list_member_hook<>,
&s_lmm_constraint_t::active_constraint_set_hook>>
active_constraint_set;
- boost::intrusive::list<s_lmm_variable_t,
- boost::intrusive::member_hook<s_lmm_variable_t, boost::intrusive::list_member_hook<>,
- &s_lmm_variable_t::saturated_variable_set_hook>>
+ boost::intrusive::list<Variable, boost::intrusive::member_hook<Variable, boost::intrusive::list_member_hook<>,
+ &Variable::saturated_variable_set_hook>>
saturated_variable_set;
boost::intrusive::list<s_lmm_constraint_t,
boost::intrusive::member_hook<s_lmm_constraint_t, boost::intrusive::list_member_hook<>,
xbt_mallocator_t variable_mallocator;
};
-extern XBT_PRIVATE double (*func_f_def)(const s_lmm_variable_t&, double);
-extern XBT_PRIVATE double (*func_fp_def)(const s_lmm_variable_t&, double);
-extern XBT_PRIVATE double (*func_fpi_def)(const s_lmm_variable_t&, double);
+extern XBT_PRIVATE double (*func_f_def)(const Variable&, double);
+extern XBT_PRIVATE double (*func_fp_def)(const Variable&, double);
+extern XBT_PRIVATE double (*func_fpi_def)(const Variable&, double);
/** @} */
}
/** @brief take into account changes of speed (either load or max) */
void CpuCas01::onSpeedChange() {
- lmm_variable_t var = nullptr;
+ lmm_variable_t var = nullptr;
const_lmm_element_t elem = nullptr;
model()->getMaxminSystem()->update_constraint_bound(constraint(), coresAmount_ * speed_.scale * speed_.peak);
host_that_restart.push_back(getHost());
turnOn();
} else {
- lmm_constraint_t cnst = constraint();
- lmm_variable_t var = nullptr;
+ lmm_constraint_t cnst = constraint();
+ lmm_variable_t var = nullptr;
const_lmm_element_t elem = nullptr;
- double date = surf_get_clock();
+ double date = surf_get_clock();
turnOff();
* @brief A CpuAction represents the execution of code on one or several Cpus
*/
XBT_PUBLIC_CLASS CpuAction : public simgrid::surf::Action {
-friend XBT_PUBLIC(Cpu*) getActionCpu(CpuAction *action);
+ friend XBT_PUBLIC(Cpu*) getActionCpu(CpuAction* action);
+
public:
-/** @brief Signal emitted when the action state changes (ready/running/done, etc)
- * Signature: `void(CpuAction *action, simgrid::surf::Action::State previous)`
- */
-static simgrid::xbt::signal<void(simgrid::surf::CpuAction*, simgrid::surf::Action::State)> onStateChange;
-/** @brief Signal emitted when the action share changes (amount of flops it gets)
- * Signature: `void(CpuAction *action)`
- */
-static simgrid::xbt::signal<void(simgrid::surf::CpuAction*)> onShareChange;
+ /** @brief Signal emitted when the action state changes (ready/running/done, etc)
+ * Signature: `void(CpuAction *action, simgrid::surf::Action::State previous)`
+ */
+ static simgrid::xbt::signal<void(simgrid::surf::CpuAction*, simgrid::surf::Action::State)> onStateChange;
+ /** @brief Signal emitted when the action share changes (amount of flops it gets)
+ * Signature: `void(CpuAction *action)`
+ */
+ static simgrid::xbt::signal<void(simgrid::surf::CpuAction*)> onShareChange;
- CpuAction(simgrid::surf::Model *model, double cost, bool failed)
- : Action(model, cost, failed) {}
- CpuAction(simgrid::surf::Model *model, double cost, bool failed, lmm_variable_t var)
- : Action(model, cost, failed, var) {}
+ CpuAction(simgrid::surf::Model* model, double cost, bool failed) : Action(model, cost, failed) {}
+ CpuAction(simgrid::surf::Model* model, double cost, bool failed, lmm_variable_t var)
+ : Action(model, cost, failed, var)
+ {
+ }
void setState(simgrid::surf::Action::State state) override;
if (value > 0)
turnOn();
else {
- lmm_variable_t var = nullptr;
+ lmm_variable_t var = nullptr;
const_lmm_element_t elem = nullptr;
- double now = surf_get_clock();
+ double now = surf_get_clock();
turnOff();
while ((var = constraint()->get_variable(&elem))) {
lmm_variable_t var = nullptr;
const_lmm_element_t elem = nullptr;
const_lmm_element_t nextelem = nullptr;
- int numelem = 0;
+ int numelem = 0;
latency_.peak = value;
/** @brief take into account changes of speed (either load or max) */
void CpuL07::onSpeedChange() {
- lmm_variable_t var = nullptr;
+ lmm_variable_t var = nullptr;
const_lmm_element_t elem = nullptr;
model()->getMaxminSystem()->update_constraint_bound(constraint(), speed_.peak * speed_.scale);
* @param cost The cost of the Action
* @param failed If the action is impossible (e.g.: execute something on a switched off host)
*/
- Action(simgrid::surf::Model *model, double cost, bool failed);
+ Action(simgrid::surf::Model* model, double cost, bool failed);
/**
* @brief Action constructor
* @param failed If the action is impossible (e.g.: execute something on a switched off host)
* @param var The lmm variable associated to this Action if it is part of a LMM component
*/
- Action(simgrid::surf::Model *model, double cost, bool failed, lmm_variable_t var);
+ Action(simgrid::surf::Model* model, double cost, bool failed, lmm_variable_t var);
/** @brief Destructor */
virtual ~Action();
void *data_ = nullptr; /**< for your convenience */
/* LMM */
- double lastUpdate_ = 0;
- double lastValue_ = 0;
- lmm_variable_t variable_ = nullptr;
- enum heap_action_type hat_ = NOTSET;
+ double lastUpdate_ = 0;
+ double lastValue_ = 0;
+ lmm_variable_t variable_ = nullptr;
+ enum heap_action_type hat_ = NOTSET;
boost::optional<heap_type::handle_type> heapHandle_ = boost::none;
public: