XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_maxmin, surf,
"Logging specific to SURF (maxmin)");
-double sg_maxmin_precision = 0.00001;
+typedef struct s_dyn_light {
+ int *data;
+ int pos;
+ int size;
+} s_dyn_light_t, *dyn_light_t;
+
+XBT_EXPORT_NO_IMPORT(double) sg_maxmin_precision = 0.00001;
static void *lmm_variable_mallocator_new_f(void);
static void lmm_variable_mallocator_free_f(void *var);
static int Global_debug_id = 1;
static int Global_const_debug_id = 1;
+static void lmm_var_free(lmm_system_t sys, lmm_variable_t var);
+static XBT_INLINE void lmm_cnst_free(lmm_system_t sys,
+ lmm_constraint_t cnst);
+
lmm_system_t lmm_system_new(int selective_update)
{
lmm_system_t l = NULL;
lmm_constraint_t cnst)
{
/* xbt_assert(xbt_swag_size(&(cnst->element_set)), */
-/* "This list should be empty!"); */
+/* "This list should be empty!"); */
make_constraint_inactive(sys, cnst);
free(cnst);
}
xbt_swag_insert_at_head(elem, &(elem->constraint->element_set));
else
xbt_swag_insert_at_tail(elem, &(elem->constraint->element_set));
-
- make_constraint_active(sys, cnst);
- lmm_update_modified_set(sys, cnst);
- if (var->cnsts_number > 1)
- lmm_update_modified_set(sys, var->cnsts[0].constraint);
+ if(!sys->selective_update_active) {
+ make_constraint_active(sys, cnst);
+ } else if(elem->value>0 || var->weight >0) {
+ make_constraint_active(sys, cnst);
+ lmm_update_modified_set(sys, cnst);
+ if (var->cnsts_number > 1)
+ lmm_update_modified_set(sys, var->cnsts[0].constraint);
+ }
}
void lmm_expand_add(lmm_system_t sys, lmm_constraint_t cnst,
return var->id;
}
-static XBT_INLINE int saturated_constraint_set_update(lmm_system_t sys,
- lmm_constraint_t
- cnst,
- double *min_usage)
+static XBT_INLINE void saturated_constraint_set_update(double usage,
+ int cnst_light_num,
+ dyn_light_t saturated_constraint_set,
+ double *min_usage)
{
- lmm_constraint_t useless_cnst = NULL;
+ xbt_assert(usage > 0,"Impossible");
- XBT_IN("sys=%p, cnst=%p, min_usage=%f", sys, cnst, *min_usage);
- if (cnst->usage <= 0) {
- XBT_OUT();
- return 1;
- }
- if (cnst->remaining <= 0) {
- XBT_OUT();
- return 1;
- }
- if ((*min_usage < 0) || (*min_usage > cnst->remaining / cnst->usage)) {
- *min_usage = cnst->remaining / cnst->usage;
- XBT_HERE(" min_usage=%f (cnst->remaining=%f, cnst->usage=%f)",
- *min_usage, cnst->remaining, cnst->usage);
- while ((useless_cnst =
- xbt_swag_getFirst(&(sys->saturated_constraint_set))))
- xbt_swag_remove(useless_cnst, &(sys->saturated_constraint_set));
-
- xbt_swag_insert(cnst, &(sys->saturated_constraint_set));
- } else if (*min_usage == cnst->remaining / cnst->usage) {
- xbt_swag_insert(cnst, &(sys->saturated_constraint_set));
+ if (*min_usage < 0 || *min_usage > usage) {
+ *min_usage = usage;
+ // XBT_HERE(" min_usage=%f (cnst->remaining / cnst->usage =%f)", *min_usage, usage);
+ saturated_constraint_set->data[0] = cnst_light_num;
+ saturated_constraint_set->pos = 1;
+ } else if (*min_usage == usage) {
+ if(saturated_constraint_set->pos == saturated_constraint_set->size) { // realloc the size
+ saturated_constraint_set->size *= 2;
+ saturated_constraint_set->data = realloc(saturated_constraint_set->data, (saturated_constraint_set->size) * sizeof(int));
+ }
+ saturated_constraint_set->data[saturated_constraint_set->pos] = cnst_light_num;
+ saturated_constraint_set->pos++;
}
- XBT_OUT();
- return 0;
}
-static XBT_INLINE void saturated_variable_set_update(lmm_system_t sys)
+static XBT_INLINE void saturated_variable_set_update(
+ s_lmm_constraint_light_t *cnst_light_tab,
+ dyn_light_t saturated_constraint_set,
+ lmm_system_t sys)
{
- lmm_constraint_t cnst = NULL;
- xbt_swag_t cnst_list = NULL;
+ lmm_constraint_light_t cnst = NULL;
lmm_element_t elem = NULL;
xbt_swag_t elem_list = NULL;
-
- cnst_list = &(sys->saturated_constraint_set);
- while ((cnst = xbt_swag_getFirst(cnst_list))) {
- elem_list = &(cnst->active_element_set);
+ int i;
+ for(i = 0; i< saturated_constraint_set->pos; i++){
+ cnst = &cnst_light_tab[saturated_constraint_set->data[i]];
+ elem_list = &(cnst->cnst->active_element_set);
xbt_swag_foreach(elem, elem_list) {
if (elem->variable->weight <= 0)
break;
if ((elem->value > 0))
xbt_swag_insert(elem->variable, &(sys->saturated_variable_set));
}
- xbt_swag_remove(cnst, cnst_list);
}
}
sprintf(print_buf, "%s(",(cnst->shared)?"":"max");
trace_buf =
xbt_realloc(trace_buf,
- strlen(trace_buf) + strlen(print_buf) + 1);
+ strlen(trace_buf) + strlen(print_buf) + 1);
strcat(trace_buf, print_buf);
xbt_swag_foreach(elem, elem_list) {
sprintf(print_buf, "%f.'%d'(%f) %s ", elem->value,
strlen(trace_buf) + strlen(print_buf) + 1);
strcat(trace_buf, print_buf);
if(cnst->shared)
- sum += elem->value * elem->variable->value;
+ sum += elem->value * elem->variable->value;
else
- sum = MAX(sum,elem->value * elem->variable->value);
+ sum = MAX(sum,elem->value * elem->variable->value);
}
sprintf(print_buf, "0) <= %f ('%d')", cnst->bound, cnst->id_int);
trace_buf =
}
}
+ s_lmm_constraint_light_t *cnst_light_tab = (s_lmm_constraint_light_t *)xbt_malloc0(xbt_swag_size(cnst_list)*sizeof(s_lmm_constraint_light_t));
+ int cnst_light_num = 0;
+ dyn_light_t saturated_constraint_set = xbt_new0(s_dyn_light_t,1);
+ saturated_constraint_set->size = 5;
+ saturated_constraint_set->data = xbt_new0(int, saturated_constraint_set->size);
+
xbt_swag_foreach_safe(cnst, cnst_next, cnst_list) {
/* INIT */
cnst->remaining = cnst->bound;
}
XBT_DEBUG("Constraint Usage '%d' : %f", cnst->id_int, cnst->usage);
/* Saturated constraints update */
- if(cnst->usage>0) {
- xbt_swag_remove(cnst, cnst_list);
- xbt_swag_insert_at_head(cnst, cnst_list);
+
+ if(cnst->usage > 0) {
+ cnst_light_tab[cnst_light_num].cnst = cnst;
+ cnst->cnst_light = &(cnst_light_tab[cnst_light_num]);
+ cnst_light_tab[cnst_light_num].remaining_over_usage = cnst->remaining / cnst->usage;
+ saturated_constraint_set_update(cnst_light_tab[cnst_light_num].remaining_over_usage,
+ cnst_light_num, saturated_constraint_set, &min_usage);
+ cnst_light_num++;
}
- saturated_constraint_set_update(sys, cnst, &min_usage);
}
- saturated_variable_set_update(sys);
+
+ saturated_variable_set_update( cnst_light_tab,
+ saturated_constraint_set,
+ sys);
/* Saturated variables update */
double_update(&(cnst->remaining), elem->value * var->value);
double_update(&(cnst->usage), elem->value / var->weight);
if(cnst->usage<=0 || cnst->remaining<=0) {
- xbt_swag_remove(cnst, cnst_list);
- xbt_swag_insert_at_tail(cnst, cnst_list);
+ if (cnst->cnst_light) {
+ int index = (cnst->cnst_light-cnst_light_tab);
+ XBT_DEBUG("index: %d \t cnst_light_num: %d \t || \t cnst: %p \t cnst->cnst_light: %p \t cnst_light_tab: %p ",
+ index,cnst_light_num, cnst, cnst->cnst_light, cnst_light_tab);
+ cnst_light_tab[index]=cnst_light_tab[cnst_light_num-1];
+ cnst_light_tab[index].cnst->cnst_light = &cnst_light_tab[index];
+ cnst_light_num--;
+ cnst->cnst_light = NULL;
+ }
+ } else {
+ cnst->cnst_light->remaining_over_usage = cnst->remaining / cnst->usage;
}
make_elem_inactive(elem);
- } else { /* FIXME one day: We recompute usage.... :( */
+ } else {
cnst->usage = 0.0;
make_elem_inactive(elem);
elem_list = &(cnst->element_set);
xbt_swag_foreach(elem, elem_list) {
- if (elem->variable->weight <= 0)
- break;
- if (elem->variable->value > 0)
+ if (elem->variable->weight <= 0 || elem->variable->value > 0)
break;
- if ((elem->value > 0)) {
- cnst->usage =
- MAX(cnst->usage, elem->value / elem->variable->weight);
- XBT_DEBUG("Constraint Usage %d : %f", cnst->id_int,
- cnst->usage);
- make_elem_active(elem);
+ if (elem->value > 0)
+ cnst->usage = MAX(cnst->usage, elem->value / elem->variable->weight);
+ }
+ if (cnst->usage<=0 || cnst->remaining<=0) {
+ if(cnst->cnst_light) {
+ int index = (cnst->cnst_light-cnst_light_tab);
+ XBT_DEBUG("index: %d \t cnst_light_num: %d \t || \t cnst: %p \t cnst->cnst_light: %p \t cnst_light_tab: %p ",
+ index,cnst_light_num, cnst, cnst->cnst_light, cnst_light_tab);
+ cnst_light_tab[index]=cnst_light_tab[cnst_light_num-1];
+ cnst_light_tab[index].cnst->cnst_light = &cnst_light_tab[index];
+ cnst_light_num--;
+ cnst->cnst_light = NULL;
}
+ } else {
+ cnst->cnst_light->remaining_over_usage = cnst->remaining / cnst->usage;
}
}
}
/* Find out which variables reach the maximum */
min_usage = -1;
min_bound = -1;
+ saturated_constraint_set->pos = 0;
+ int pos;
+ for(pos=0; pos<cnst_light_num; pos++)
+ saturated_constraint_set_update(
+ cnst_light_tab[pos].remaining_over_usage,
+ pos,
+ saturated_constraint_set,
+ &min_usage);
- xbt_swag_foreach(cnst, cnst_list) {
- if(saturated_constraint_set_update(sys, cnst, &min_usage)) break;
- }
- saturated_variable_set_update(sys);
+ saturated_variable_set_update( cnst_light_tab,
+ saturated_constraint_set,
+ sys);
- } while (xbt_swag_size(&(sys->saturated_variable_set)));
+ } while (cnst_light_num > 0);
sys->modified = 0;
if (sys->selective_update_active)
if (XBT_LOG_ISENABLED(surf_maxmin, xbt_log_priority_debug)) {
lmm_print(sys);
}
+
+ xbt_free(saturated_constraint_set->data);
+ xbt_free(saturated_constraint_set);
+ xbt_free(cnst_light_tab);
XBT_OUT();
}