X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/c788771aa7185d8f45f0f9705c5460d9749b6303..0c539f5e2d25206246bb12e6dc036b108ea778e5:/src/surf/maxmin.c diff --git a/src/surf/maxmin.c b/src/surf/maxmin.c index 1f1609eba7..014457ba6b 100644 --- a/src/surf/maxmin.c +++ b/src/surf/maxmin.c @@ -1,6 +1,5 @@ -/* $Id$ */ - -/* Copyright (c) 2004 Arnaud Legrand. All rights reserved. */ +/* Copyright (c) 2004, 2005, 2006, 2007, 2008, 2009, 2010. The SimGrid Team. + * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ @@ -16,14 +15,19 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_maxmin, surf, "Logging specific to SURF (maxmin)"); +double sg_maxmin_precision = 0.00001; + static void *lmm_variable_mallocator_new_f(void); static void lmm_variable_mallocator_free_f(void *var); static void lmm_variable_mallocator_reset_f(void *var); -static void lmm_update_modified_set(lmm_system_t sys, lmm_constraint_t cnst); +static void lmm_update_modified_set(lmm_system_t sys, + lmm_constraint_t cnst); static void lmm_remove_all_modified_set(lmm_system_t sys); int sg_maxmin_selective_update = 1; static int Global_debug_id = 1; static int Global_const_debug_id = 1; +extern xbt_swag_t keep_track; + lmm_system_t lmm_system_new(void) { lmm_system_t l = NULL; @@ -53,7 +57,7 @@ lmm_system_t lmm_system_new(void) xbt_swag_init(&(l->saturated_constraint_set), xbt_swag_offset(cnst, saturated_constraint_set_hookup)); - l->variable_mallocator = xbt_mallocator_new(64, + l->variable_mallocator = xbt_mallocator_new(65536, lmm_variable_mallocator_new_f, lmm_variable_mallocator_free_f, lmm_variable_mallocator_reset_f); @@ -66,8 +70,12 @@ void lmm_system_free(lmm_system_t sys) lmm_variable_t var = NULL; lmm_constraint_t cnst = NULL; - while ((var = extract_variable(sys))) + while ((var = extract_variable(sys))) { + WARN2 + ("Variable %p (%d) still in LMM system when freing it: this may be a bug", + var, var->id_int); lmm_var_free(sys, var); + } while ((cnst = extract_constraint(sys))) lmm_cnst_free(sys, cnst); @@ -101,11 +109,11 @@ static void lmm_var_free(lmm_system_t sys, lmm_variable_t var) { lmm_variable_disable(sys, var); - free(var->cnsts); xbt_mallocator_release(sys->variable_mallocator, var); } -static XBT_INLINE void lmm_cnst_free(lmm_system_t sys, lmm_constraint_t cnst) +static XBT_INLINE void lmm_cnst_free(lmm_system_t sys, + lmm_constraint_t cnst) { /* xbt_assert0(xbt_swag_size(&(cnst->element_set)), */ /* "This list should be empty!"); */ @@ -145,7 +153,8 @@ XBT_INLINE int lmm_constraint_is_shared(lmm_constraint_t cnst) return (cnst->shared); } -XBT_INLINE void lmm_constraint_free(lmm_system_t sys, lmm_constraint_t cnst) +XBT_INLINE void lmm_constraint_free(lmm_system_t sys, + lmm_constraint_t cnst) { remove_constraint(sys, cnst); lmm_cnst_free(sys, cnst); @@ -153,18 +162,20 @@ XBT_INLINE void lmm_constraint_free(lmm_system_t sys, lmm_constraint_t cnst) static void *lmm_variable_mallocator_new_f(void) { - return xbt_new(s_lmm_variable_t, 1); + lmm_variable_t var = xbt_new(s_lmm_variable_t, 1); + var->cnsts = NULL; /* will be created by realloc */ + return var; } static void lmm_variable_mallocator_free_f(void *var) { + xbt_free(((lmm_variable_t) var)->cnsts); xbt_free(var); } static void lmm_variable_mallocator_reset_f(void *var) { - /* memset to zero like calloc */ - memset(var, 0, sizeof(s_lmm_variable_t)); + /* lmm_variable_new() initializes everything */ } lmm_variable_t lmm_variable_new(lmm_system_t sys, void *id, @@ -180,10 +191,8 @@ lmm_variable_t lmm_variable_new(lmm_system_t sys, void *id, var = xbt_mallocator_get(sys->variable_mallocator); var->id = id; var->id_int = Global_debug_id++; - var->cnsts = xbt_new0(s_lmm_element_t, number_of_constraints); + var->cnsts = xbt_realloc(var->cnsts, number_of_constraints * sizeof(s_lmm_element_t)); for (i = 0; i < number_of_constraints; i++) { - /* Should be useless because of the - calloc but it seems to help valgrind... */ var->cnsts[i].element_set_hookup.next = NULL; var->cnsts[i].element_set_hookup.prev = NULL; var->cnsts[i].active_element_set_hookup.next = NULL; @@ -193,17 +202,22 @@ lmm_variable_t lmm_variable_new(lmm_system_t sys, void *id, var->cnsts[i].value = 0.0; } var->cnsts_size = number_of_constraints; - var->cnsts_number = 0; /* Should be useless because of the - calloc but it seems to help valgrind... */ + var->cnsts_number = 0; var->weight = weight; var->bound = bound; var->value = 0.0; - + var->mu = 0.0; + var->new_mu = 0.0; var->func_f = func_f_def; var->func_fp = func_fp_def; var->func_fpi = func_fpi_def; + var->variable_set_hookup.next = NULL; + var->variable_set_hookup.prev = NULL; + var->saturated_variable_set_hookup.next = NULL; + var->saturated_variable_set_hookup.prev = NULL; + if (weight) xbt_swag_insert_at_head(var, &(sys->variable_set)); else @@ -290,7 +304,8 @@ void lmm_elem_set_value(lmm_system_t sys, lmm_constraint_t cnst, } XBT_INLINE lmm_constraint_t lmm_get_cnst_from_var(lmm_system_t sys, - lmm_variable_t var, int num) + lmm_variable_t var, + int num) { if (num < var->cnsts_number) return (var->cnsts[num].constraint); @@ -298,7 +313,8 @@ XBT_INLINE lmm_constraint_t lmm_get_cnst_from_var(lmm_system_t sys, return NULL; } -XBT_INLINE int lmm_get_number_of_cnst_from_var(lmm_system_t sys, lmm_variable_t var) +XBT_INLINE int lmm_get_number_of_cnst_from_var(lmm_system_t sys, + lmm_variable_t var) { return (var->cnsts_number); } @@ -328,8 +344,9 @@ XBT_INLINE void *lmm_variable_id(lmm_variable_t var) } static XBT_INLINE void saturated_constraint_set_update(lmm_system_t sys, - lmm_constraint_t cnst, - double *min_usage) + lmm_constraint_t + cnst, + double *min_usage) { lmm_constraint_t useless_cnst = NULL; @@ -394,17 +411,17 @@ void lmm_print(lmm_system_t sys) var_list = &(sys->variable_set); sprintf(print_buf, "MAX-MIN ( "); trace_buf = - xbt_realloc(trace_buf, strlen(trace_buf) + strlen(print_buf) + 1); + xbt_realloc(trace_buf, strlen(trace_buf) + strlen(print_buf) + 1); strcat(trace_buf, print_buf); xbt_swag_foreach(var, var_list) { sprintf(print_buf, "'%d'(%f) ", var->id_int, var->weight); trace_buf = - xbt_realloc(trace_buf, strlen(trace_buf) + strlen(print_buf) + 1); + xbt_realloc(trace_buf, strlen(trace_buf) + strlen(print_buf) + 1); strcat(trace_buf, print_buf); } sprintf(print_buf, ")"); trace_buf = - xbt_realloc(trace_buf, strlen(trace_buf) + strlen(print_buf) + 1); + xbt_realloc(trace_buf, strlen(trace_buf) + strlen(print_buf) + 1); strcat(trace_buf, print_buf); fprintf(stderr, "%s", trace_buf); //DEBUG1("%20s", trace_buf); FIXME @@ -418,29 +435,39 @@ void lmm_print(lmm_system_t sys) elem_list = &(cnst->element_set); sprintf(print_buf, "\t"); trace_buf = - xbt_realloc(trace_buf, strlen(trace_buf) + strlen(print_buf) + 1); + xbt_realloc(trace_buf, strlen(trace_buf) + strlen(print_buf) + 1); strcat(trace_buf, print_buf); + sprintf(print_buf, "%s(",(cnst->shared)?"":"max"); + trace_buf = + xbt_realloc(trace_buf, + strlen(trace_buf) + strlen(print_buf) + 1); + strcat(trace_buf, print_buf); xbt_swag_foreach(elem, elem_list) { - sprintf(print_buf, "%f.'%d'(%f) + ", elem->value, - elem->variable->id_int, elem->variable->value); + sprintf(print_buf, "%f.'%d'(%f) %s ", elem->value, + elem->variable->id_int, elem->variable->value,(cnst->shared)?"+":","); trace_buf = - xbt_realloc(trace_buf, strlen(trace_buf) + strlen(print_buf) + 1); + xbt_realloc(trace_buf, + strlen(trace_buf) + strlen(print_buf) + 1); strcat(trace_buf, print_buf); - sum += elem->value * elem->variable->value; + if(cnst->shared) + sum += elem->value * elem->variable->value; + else + sum = MAX(sum,elem->value * elem->variable->value); } - sprintf(print_buf, "0 <= %f ('%d')", cnst->bound, cnst->id_int); + sprintf(print_buf, "0) <= %f ('%d')", cnst->bound, cnst->id_int); trace_buf = - xbt_realloc(trace_buf, strlen(trace_buf) + strlen(print_buf) + 1); + xbt_realloc(trace_buf, strlen(trace_buf) + strlen(print_buf) + 1); strcat(trace_buf, print_buf); if (!cnst->shared) { sprintf(print_buf, " [MAX-Constraint]"); trace_buf = - xbt_realloc(trace_buf, strlen(trace_buf) + strlen(print_buf) + 1); + xbt_realloc(trace_buf, + strlen(trace_buf) + strlen(print_buf) + 1); strcat(trace_buf, print_buf); } // DEBUG1("%s", trace_buf); - fprintf(stderr, "%s", trace_buf); + fprintf(stderr, "%s\n", trace_buf); trace_buf[0] = '\000'; xbt_assert3(!double_positive(sum - cnst->bound), "Incorrect value (%f is not smaller than %f): %g", @@ -478,11 +505,15 @@ void lmm_solve(lmm_system_t sys) if (!(sys->modified)) return; + XBT_IN1("(sys=%p)", sys); + /* * Compute Usage and store the variables that reach the maximum. */ - cnst_list = sys->selective_update_active ? &(sys->modified_constraint_set) : - &(sys->active_constraint_set); + cnst_list = + sys-> + selective_update_active ? &(sys->modified_constraint_set) : + &(sys->active_constraint_set); DEBUG1("Active constraints : %d", xbt_swag_size(cnst_list)); /* Init: Only modified code portions */ @@ -497,10 +528,11 @@ void lmm_solve(lmm_system_t sys) } } - DEBUG1("Active constraints : %d", xbt_swag_size(cnst_list)); xbt_swag_foreach(cnst, cnst_list) { /* INIT */ cnst->remaining = cnst->bound; + if (cnst->remaining == 0) + continue; cnst->usage = 0; elem_list = &(cnst->element_set); xbt_swag_foreach(elem, elem_list) { @@ -514,9 +546,12 @@ void lmm_solve(lmm_system_t sys) cnst->usage = elem->value / elem->variable->weight; make_elem_active(elem); + if(keep_track){ + xbt_swag_insert((elem->variable)->id, keep_track); + } } } - DEBUG2("Constraint Usage %d : %f", cnst->id_int, cnst->usage); + DEBUG2("Constraint Usage '%d' : %f", cnst->id_int, cnst->usage); /* Saturated constraints update */ saturated_constraint_set_update(sys, cnst, &min_usage); } @@ -534,9 +569,9 @@ void lmm_solve(lmm_system_t sys) /* First check if some of these variables have reach their upper bound and update min_usage accordingly. */ DEBUG5 - ("var=%d, var->bound=%f, var->weight=%f, min_usage=%f, var->bound*var->weight=%f", - var->id_int, var->bound, var->weight, min_usage, - var->bound * var->weight); + ("var=%d, var->bound=%f, var->weight=%f, min_usage=%f, var->bound*var->weight=%f", + var->id_int, var->bound, var->weight, min_usage, + var->bound * var->weight); if ((var->bound > 0) && (var->bound * var->weight < min_usage)) { if (min_bound < 0) min_bound = var->bound; @@ -576,15 +611,17 @@ void lmm_solve(lmm_system_t sys) } else { /* FIXME one day: We recompute usage.... :( */ 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) break; if ((elem->value > 0)) { - if (cnst->usage < elem->value / elem->variable->weight) - cnst->usage = elem->value / elem->variable->weight; - DEBUG2("Constraint Usage %d : %f", cnst->id_int, cnst->usage); + cnst->usage = + MAX(cnst->usage, elem->value / elem->variable->weight); + DEBUG2("Constraint Usage %d : %f", cnst->id_int, + cnst->usage); make_elem_active(elem); } } @@ -595,8 +632,8 @@ void lmm_solve(lmm_system_t sys) /* Find out which variables reach the maximum */ cnst_list = - sys->selective_update_active ? &(sys->modified_constraint_set) : - &(sys->active_constraint_set); + sys->selective_update_active ? &(sys->modified_constraint_set) : + &(sys->active_constraint_set); min_usage = -1; min_bound = -1; xbt_swag_foreach(cnst, cnst_list) { @@ -613,6 +650,7 @@ void lmm_solve(lmm_system_t sys) if (XBT_LOG_ISENABLED(surf_maxmin, xbt_log_priority_debug)) { lmm_print(sys); } + XBT_OUT; } /* Not a O(1) function */ @@ -695,8 +733,9 @@ XBT_INLINE double lmm_get_variable_weight(lmm_variable_t var) return var->weight; } -XBT_INLINE void lmm_update_constraint_bound(lmm_system_t sys, lmm_constraint_t cnst, - double bound) +XBT_INLINE void lmm_update_constraint_bound(lmm_system_t sys, + lmm_constraint_t cnst, + double bound) { sys->modified = 1; lmm_update_modified_set(sys, cnst); @@ -708,17 +747,28 @@ XBT_INLINE int lmm_constraint_used(lmm_system_t sys, lmm_constraint_t cnst) return xbt_swag_belongs(cnst, &(sys->active_constraint_set)); } -XBT_INLINE lmm_constraint_t lmm_get_first_active_constraint(lmm_system_t sys) +XBT_INLINE lmm_constraint_t lmm_get_first_active_constraint(lmm_system_t + sys) { return xbt_swag_getFirst(&(sys->active_constraint_set)); } -XBT_INLINE lmm_constraint_t lmm_get_next_active_constraint(lmm_system_t sys, - lmm_constraint_t cnst) +XBT_INLINE lmm_constraint_t lmm_get_next_active_constraint(lmm_system_t + sys, + lmm_constraint_t + cnst) { return xbt_swag_getNext(cnst, (sys->active_constraint_set).offset); } +#ifdef HAVE_LATENCY_BOUND_TRACKING +XBT_INLINE int lmm_is_variable_limited_by_latency(lmm_variable_t var) +{ + return (double_equals(var->bound, var->value)); +} +#endif + + /** \brief Update the constraint set propagating recursively to * other constraints so the system should not be entirely computed. * @@ -729,7 +779,8 @@ XBT_INLINE lmm_constraint_t lmm_get_next_active_constraint(lmm_system_t sys, * 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(lmm_system_t sys, + lmm_constraint_t cnst) { lmm_element_t elem = NULL; lmm_variable_t var = NULL;