XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_maxmin, surf,
"Logging specific to SURF (maxmin)");
+typedef struct s_dyn_light {
+ int *data;
+ int pos;
+ int size;
+} s_dyn_light_t, *dyn_light_t;
+
double sg_maxmin_precision = 0.00001;
static void *lmm_variable_mallocator_new_f(void);
static void lmm_remove_all_modified_set(lmm_system_t sys);
static int Global_debug_id = 1;
static int Global_const_debug_id = 1;
-extern xbt_swag_t keep_track;
+
+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)
{
l->modified = 0;
l->selective_update_active = selective_update;
+ l->visited_counter = 1;
XBT_DEBUG("Setting selective_update_active flag to %d\n",
l->selective_update_active);
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);
}
var->weight = weight;
var->bound = bound;
var->value = 0.0;
-
+ var->visited = sys->visited_counter - 1;
var->mu = 0.0;
var->new_mu = 0.0;
var->func_f = func_f_def;
xbt_swag_insert_at_head(var, &(sys->variable_set));
else
xbt_swag_insert_at_tail(var, &(sys->variable_set));
- XBT_OUT();
+
+ XBT_OUT(" returns %p", var);
return var;
}
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 NULL;
}
+XBT_INLINE double lmm_get_cnst_weight_from_var(lmm_system_t sys,
+ lmm_variable_t var,
+ int num)
+{
+ if (num < var->cnsts_number)
+ return (var->cnsts[num].value);
+ else
+ return 0.0;
+}
+
XBT_INLINE int lmm_get_number_of_cnst_from_var(lmm_system_t sys,
lmm_variable_t var)
{
return var->id;
}
-static XBT_INLINE void 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;
- }
- if (cnst->remaining <= 0) {
- XBT_OUT();
- return;
- }
- if ((*min_usage < 0) || (*min_usage > cnst->remaining / cnst->usage)) {
- *min_usage = cnst->remaining / cnst->usage;
- XBT_LOG(xbt_log_priority_trace,
- "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();
}
-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 =
{
lmm_variable_t var = NULL;
lmm_constraint_t cnst = NULL;
+ lmm_constraint_t cnst_next = NULL;
lmm_element_t elem = NULL;
xbt_swag_t cnst_list = NULL;
xbt_swag_t var_list = NULL;
}
}
- xbt_swag_foreach(cnst, cnst_list) {
+ 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;
if (cnst->remaining == 0)
cnst->usage = elem->value / elem->variable->weight;
make_elem_active(elem);
- if(keep_track){
- xbt_swag_insert((elem->variable)->id, keep_track);
- }
+ if (sys->keep_track)
+ xbt_swag_insert(elem->variable->id, sys->keep_track);
}
}
XBT_DEBUG("Constraint Usage '%d' : %f", cnst->id_int, cnst->usage);
/* Saturated constraints update */
- saturated_constraint_set_update(sys, cnst, &min_usage);
+
+ 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_variable_set_update(sys);
+
+ saturated_variable_set_update( cnst_light_tab,
+ saturated_constraint_set,
+ sys);
/* Saturated variables update */
if (cnst->shared) {
double_update(&(cnst->remaining), elem->value * var->value);
double_update(&(cnst->usage), elem->value / var->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;
+ }
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)
+ if (elem->variable->weight <= 0 || elem->variable->value > 0)
break;
- if (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;
- xbt_swag_foreach(cnst, cnst_list) {
- saturated_constraint_set_update(sys, cnst, &min_usage);
- }
- saturated_variable_set_update(sys);
+ 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);
+
+ 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();
}
xbt_swag_insert_at_head(elem, &(elem->constraint->element_set));
else
xbt_swag_insert_at_tail(elem, &(elem->constraint->element_set));
+
+ if (i == 0)
+ lmm_update_modified_set(sys, elem->constraint);
}
if (!weight)
var->value = 0.0;
- if (var->cnsts_number)
- lmm_update_modified_set(sys, var->cnsts[0].constraint);
-
XBT_OUT();
}
* constraints that have changed. Each constraint change is propagated
* to the list of constraints for each variable.
*/
-static void lmm_update_modified_set(lmm_system_t sys,
- lmm_constraint_t cnst)
+static void lmm_update_modified_set_rec(lmm_system_t sys,
+ lmm_constraint_t cnst)
{
- lmm_element_t elem = NULL;
- lmm_variable_t var = NULL;
- xbt_swag_t elem_list = NULL;
- int i;
-
- /* return if selective update isn't active */
- if (!sys->selective_update_active)
- return;
-
- //XBT_DEBUG("Updating modified constraint set with constraint %d", cnst->id_int);
-
- if (xbt_swag_belongs(cnst, &(sys->modified_constraint_set)))
- return;
-
- //XBT_DEBUG("Inserting into modified constraint set %d", cnst->id_int);
-
- /* add to modified set */
- xbt_swag_insert(cnst, &(sys->modified_constraint_set));
+ lmm_element_t elem;
- elem_list = &(cnst->element_set);
- xbt_swag_foreach(elem, elem_list) {
- var = elem->variable;
- for (i = 0; i < var->cnsts_number; i++)
- if (cnst != var->cnsts[i].constraint) {
- //XBT_DEBUG("Updating modified %d calling for %d", cnst->id_int, var->cnsts[i].constraint->id_int);
- lmm_update_modified_set(sys, var->cnsts[i].constraint);
+ xbt_swag_foreach(elem, &cnst->element_set) {
+ lmm_variable_t var = elem->variable;
+ s_lmm_element_t *cnsts = var->cnsts;
+ int i;
+ for (i = 0; var->visited != sys->visited_counter
+ && i < var->cnsts_number ; i++) {
+ if (cnsts[i].constraint != cnst
+ && !xbt_swag_belongs(cnsts[i].constraint,
+ &sys->modified_constraint_set)) {
+ xbt_swag_insert(cnsts[i].constraint, &sys->modified_constraint_set);
+ lmm_update_modified_set_rec(sys, cnsts[i].constraint);
}
+ }
+ var->visited = sys->visited_counter;
+ }
+}
+
+static void lmm_update_modified_set(lmm_system_t sys,
+ lmm_constraint_t cnst)
+{
+ /* nothing to do if selective update isn't active */
+ if (sys->selective_update_active
+ && !xbt_swag_belongs(cnst, &sys->modified_constraint_set)) {
+ xbt_swag_insert(cnst, &sys->modified_constraint_set);
+ lmm_update_modified_set_rec(sys, cnst);
}
}
*/
static void lmm_remove_all_modified_set(lmm_system_t sys)
{
+ if (++sys->visited_counter == 1) {
+ /* the counter wrapped around, reset each variable->visited */
+ lmm_variable_t var;
+ xbt_swag_foreach(var, &sys->variable_set)
+ var->visited = 0;
+ }
xbt_swag_reset(&sys->modified_constraint_set);
}
