* under the terms of the license (GNU LGPL) which comes with this package. */
#include "src/kernel/lmm/maxmin.hpp"
-#include "src/surf/surf_interface.hpp"
#include "xbt/backtrace.hpp"
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_maxmin, surf, "Logging specific to SURF (maxmin)");
continue;
const Element& elem = var.cnsts_[0];
- int belong_to_enabled = elem.enabled_element_set_hook.is_linked();
- int belong_to_disabled = elem.disabled_element_set_hook.is_linked();
- int belong_to_active = elem.active_element_set_hook.is_linked();
+ bool belong_to_enabled = elem.enabled_element_set_hook.is_linked();
+ bool belong_to_disabled = elem.disabled_element_set_hook.is_linked();
+ bool belong_to_active = elem.active_element_set_hook.is_linked();
for (Element const& elem2 : var.cnsts_) {
xbt_assert(belong_to_enabled == elem2.enabled_element_set_hook.is_linked(),
XBT_OUT();
}
-System::System(bool selective_update) : cnst_light_tab(NULL),cnst_light_max_size(0),
- selective_update_active(selective_update)
+System::System(bool selective_update) : selective_update_active(selective_update)
{
XBT_DEBUG("Setting selective_update_active flag to %d", selective_update_active);
while ((cnst = extract_constraint()))
cnst_free(cnst);
- if(cnst_light_tab)
- delete[] cnst_light_tab;
-
xbt_mallocator_free(variable_mallocator_);
delete modified_set_;
}
Constraint::Constraint(resource::Resource* id_value, double bound_value) : bound_(bound_value), id_(id_value)
{
rank_ = next_rank_++;
-
- remaining_ = 0.0;
- usage_ = 0.0;
- concurrency_limit_ = sg_concurrency_limit;
- concurrency_current_ = 0;
- concurrency_maximum_ = 0;
- sharing_policy_ = s4u::Link::SharingPolicy::SHARED;
-
- lambda_ = 0.0;
- new_lambda_ = 0.0;
- cnst_light_ = nullptr;
}
Constraint* System::constraint_new(resource::Resource* id, double bound_value)
// If it does, subtract it from the required slack
int current_share = 0;
if (var->concurrency_share_ > 1) {
- for (Element& elem : var->cnsts_) {
+ for (const Element& elem : var->cnsts_) {
if (elem.constraint == cnst && elem.enabled_element_set_hook.is_linked())
current_share += elem.get_concurrency();
}
}
}
-static inline void saturated_variable_set_update(ConstraintLight* cnst_light_tab,
+static inline void saturated_variable_set_update(const ConstraintLight* cnst_light_tab,
const dyn_light_t& saturated_constraints, System* sys)
{
/* Add active variables (i.e. variables that need to be set) from the set of constraints to saturate
* (cnst_light_tab)*/
for (int const& saturated_cnst : saturated_constraints) {
- ConstraintLight& cnst = cnst_light_tab[saturated_cnst];
+ const ConstraintLight& cnst = cnst_light_tab[saturated_cnst];
for (Element const& elem : cnst.cnst->active_element_set_) {
xbt_assert(elem.variable->sharing_penalty_ > 0); // All elements of active_element_set should be active
if (elem.consumption_weight > 0 && not elem.variable->saturated_variable_set_hook_.is_linked())
double min_usage = -1;
double min_bound = -1;
- if(cnst_list.size()>cnst_light_max_size){
- cnst_light_max_size=cnst_list.size()*2;
- if(cnst_light_tab)
- delete [] cnst_light_tab;
- cnst_light_tab=new ConstraintLight[cnst_light_max_size]();
- }
-
+ XBT_DEBUG("Active constraints : %zu", cnst_list.size());
+ cnst_light_vec.reserve(cnst_list.size());
+ ConstraintLight* cnst_light_tab = cnst_light_vec.data();
int cnst_light_num = 0;
for (Constraint& cnst : cnst_list) {
continue;
cnst.usage_ = 0;
for (Element& elem : cnst.enabled_element_set_) {
- xbt_assert(elem.variable->sharing_penalty_ > 0);
+ xbt_assert(elem.variable->sharing_penalty_ > 0.0);
elem.variable->value_ = 0.0;
if (elem.consumption_weight > 0) {
if (cnst.sharing_policy_ != s4u::Link::SharingPolicy::FATPIPE)
}
}
-#if MAXMIN_PROF==CSV_PROF
- start_init2 = high_resolution_clock::now();//FABIENDBG
-#endif
-
saturated_variable_set_update(cnst_light_tab, saturated_constraints, this);
-
-
-#if MAXMIN_PROF==CSV_PROF
- high_resolution_clock::time_point start_main = high_resolution_clock::now();//FABIENDBG
- int NVars=saturated_variable_set.size();//FABIENDBG
- float init_duration1=duration_cast<duration<float> >(start_init2 - start_init).count();//FABIENDBG
- float init_duration2=duration_cast<duration<float> >(start_main - start_init2).count();//FABIENDBG
- float loop_duration;//FABIENDBG
- float loop_max=0;//FABIENDBG
- float loop_min=1E9;//FABIENDBG
- float loop_avg=0;//FABIENDBG
- float loop_std=0;//FABIENDBG
- int loop_count=0;//FABIENDBG
- high_resolution_clock::time_point start_loop,end_loop;//FABIENDBG
-#endif
/* Saturated variables update */
do {
- high_resolution_clock::time_point start_loop = high_resolution_clock::now();//FABIENDBG
-
/* Fix the variables that have to be */
auto& var_list = saturated_variable_set;
for (Variable const& var : var_list) {
// Remember: non-shared constraints only require that max(elem.value * var.value) < cnst->bound
cnst->usage_ = 0.0;
elem.make_inactive();
- for (Element& elem2 : cnst->enabled_element_set_) {
+ for (const Element& elem2 : cnst->enabled_element_set_) {
xbt_assert(elem2.variable->sharing_penalty_ > 0);
if (elem2.variable->value_ > 0)
continue;
}
saturated_variable_set_update(cnst_light_tab, saturated_constraints, this);
-
} while (cnst_light_num > 0);
modified_ = false;
}
check_concurrency();
-
}
/** @brief Attribute the value bound to var->bound.
// Cannot use foreach loop, because System::enable_var() will modify disabled_element_set.. within the loop
while (numelem-- && elem) {
-
Element* nextelem;
if (elem->disabled_element_set_hook.is_linked()) {
auto iter = std::next(cnstr->disabled_element_set_.iterator_to(*elem));
if (penalty == var->sharing_penalty_)
return;
- int enabling_var = (penalty > 0 && var->sharing_penalty_ <= 0);
- int disabling_var = (penalty <= 0 && var->sharing_penalty_ > 0);
+ bool enabling_var = (penalty > 0 && var->sharing_penalty_ <= 0);
+ bool disabling_var = (penalty <= 0 && var->sharing_penalty_ > 0);
XBT_IN("(sys=%p, var=%p, penalty=%f)", this, var, penalty);
* A recursive algorithm to optimize the system recalculation selecting only constraints that have changed. Each
* constraint change is propagated to the list of constraints for each variable.
*/
-void System::update_modified_set_rec(Constraint* cnst)
+void System::update_modified_set_rec(const Constraint* cnst)
{
for (Element const& elem : cnst->enabled_element_set_) {
Variable* var = elem.variable;
return std::count_if(std::begin(enabled_element_set_), std::end(enabled_element_set_),
[](const Element& elem) { return elem.consumption_weight > 0; });
}
-}
-}
-}
+
+} // namespace lmm
+} // namespace kernel
+} // namespace simgrid
