static void cpu_free(void *cpu)
{
- free(((cpu_Cas01_t)cpu)->name);
+ free(((cpu_Cas01_t) cpu)->name);
free(cpu);
}
static cpu_Cas01_t cpu_new(char *name, double power_scale,
- double power_initial,
- tmgr_trace_t power_trace,
- e_surf_cpu_state_t state_initial,
- tmgr_trace_t state_trace)
+ double power_initial,
+ tmgr_trace_t power_trace,
+ e_surf_cpu_state_t state_initial,
+ tmgr_trace_t state_trace)
{
cpu_Cas01_t cpu = xbt_new0(s_cpu_Cas01_t, 1);
cpu->resource = (surf_resource_t) surf_cpu_resource;
cpu->name = name;
cpu->power_scale = power_scale;
- xbt_assert0(cpu->power_scale>0,"Power has to be >0");
+ xbt_assert0(cpu->power_scale > 0, "Power has to be >0");
cpu->power_current = power_initial;
if (power_trace)
cpu->power_event =
tmgr_trace_t state_trace = NULL;
name = xbt_strdup(A_surfxml_cpu_name);
- surf_parse_get_double(&power_scale,A_surfxml_cpu_power);
- surf_parse_get_double(&power_initial,A_surfxml_cpu_availability);
- surf_parse_get_trace(&power_trace,A_surfxml_cpu_availability_file);
+ surf_parse_get_double(&power_scale, A_surfxml_cpu_power);
+ surf_parse_get_double(&power_initial, A_surfxml_cpu_availability);
+ surf_parse_get_trace(&power_trace, A_surfxml_cpu_availability_file);
- xbt_assert0((A_surfxml_cpu_state==A_surfxml_cpu_state_ON)||
- (A_surfxml_cpu_state==A_surfxml_cpu_state_OFF),
+ xbt_assert0((A_surfxml_cpu_state == A_surfxml_cpu_state_ON) ||
+ (A_surfxml_cpu_state == A_surfxml_cpu_state_OFF),
"Invalid state");
- if (A_surfxml_cpu_state==A_surfxml_cpu_state_ON) state_initial = SURF_CPU_ON;
- if (A_surfxml_cpu_state==A_surfxml_cpu_state_OFF) state_initial = SURF_CPU_OFF;
- surf_parse_get_trace(&state_trace,A_surfxml_cpu_state_file);
+ if (A_surfxml_cpu_state == A_surfxml_cpu_state_ON)
+ state_initial = SURF_CPU_ON;
+ if (A_surfxml_cpu_state == A_surfxml_cpu_state_OFF)
+ state_initial = SURF_CPU_OFF;
+ surf_parse_get_trace(&state_trace, A_surfxml_cpu_state_file);
cpu_new(name, power_scale, power_initial, power_trace, state_initial,
state_trace);
static void parse_file(const char *file)
{
surf_parse_reset_parser();
- ETag_surfxml_cpu_fun=parse_cpu;
+ ETag_surfxml_cpu_fun = parse_cpu;
surf_parse_open(file);
- xbt_assert1((!surf_parse()),"Parse error in %s",file);
+ xbt_assert1((!surf_parse()), "Parse error in %s", file);
surf_parse_close();
}
static int action_free(surf_action_t action)
{
action->using--;
- if(!action->using) {
+ if (!action->using) {
xbt_swag_remove(action, action->state_set);
- if(((surf_action_cpu_Cas01_t)action)->variable)
- lmm_variable_free(cpu_maxmin_system, ((surf_action_cpu_Cas01_t)action)->variable);
+ if (((surf_action_cpu_Cas01_t) action)->variable)
+ lmm_variable_free(cpu_maxmin_system,
+ ((surf_action_cpu_Cas01_t) action)->variable);
free(action);
return 1;
}
xbt_swag_t running_actions =
surf_cpu_resource->common_public->states.running_action_set;
/* FIXME: UNUSED
- xbt_swag_t failed_actions =
- surf_cpu_resource->common_public->states.failed_action_set;
- */
+ xbt_swag_t failed_actions =
+ surf_cpu_resource->common_public->states.failed_action_set;
+ */
xbt_swag_foreach_safe(action, next_action, running_actions) {
double_update(&(action->generic_action.remains),
- lmm_variable_getvalue(action->variable) * delta);
+ lmm_variable_getvalue(action->variable) * delta);
if (action->generic_action.max_duration != NO_MAX_DURATION)
double_update(&(action->generic_action.max_duration), delta);
- if ((action->generic_action.remains <= 0) &&
- (lmm_get_variable_weight(action->variable)>0)) {
+ if ((action->generic_action.remains <= 0) &&
+ (lmm_get_variable_weight(action->variable) > 0)) {
action->generic_action.finish = surf_get_clock();
action_change_state((surf_action_t) action, SURF_ACTION_DONE);
} else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
surf_action_cpu_Cas01_t action = NULL;
cpu_Cas01_t CPU = cpu;
- XBT_IN2("(%s,%g)",CPU->name,size);
+ XBT_IN2("(%s,%g)", CPU->name, size);
action = xbt_new0(s_surf_action_cpu_Cas01_t, 1);
action->generic_action.using = 1;
action->generic_action.finish = -1.0;
action->generic_action.resource_type =
(surf_resource_t) surf_cpu_resource;
- action->suspended = 0; /* Should be useless because of the
- calloc but it seems to help valgrind... */
+ action->suspended = 0; /* Should be useless because of the
+ calloc but it seems to help valgrind... */
if (CPU->state_current == SURF_CPU_ON)
action->generic_action.state_set =
surf_cpu_resource->common_public->states.failed_action_set;
xbt_swag_insert(action, action->generic_action.state_set);
- action->variable = lmm_variable_new(cpu_maxmin_system, action,
- action->generic_action.priority, -1.0, 1);
- lmm_expand(cpu_maxmin_system, CPU->constraint, action->variable,
- 1.0);
+ action->variable = lmm_variable_new(cpu_maxmin_system, action,
+ action->generic_action.priority,
+ -1.0, 1);
+ lmm_expand(cpu_maxmin_system, CPU->constraint, action->variable, 1.0);
XBT_OUT;
return (surf_action_t) action;
}
{
surf_action_cpu_Cas01_t action = NULL;
- XBT_IN2("(%s,%g)",((cpu_Cas01_t)cpu)->name,duration);
+ XBT_IN2("(%s,%g)", ((cpu_Cas01_t) cpu)->name, duration);
action = (surf_action_cpu_Cas01_t) execute(cpu, 1.0);
action->generic_action.max_duration = duration;
action->suspended = 2;
static void action_suspend(surf_action_t action)
{
- XBT_IN1("(%p)",action);
- if(((surf_action_cpu_Cas01_t) action)->suspended != 2) {
+ XBT_IN1("(%p)", action);
+ if (((surf_action_cpu_Cas01_t) action)->suspended != 2) {
lmm_update_variable_weight(cpu_maxmin_system,
- ((surf_action_cpu_Cas01_t) action)->variable, 0.0);
+ ((surf_action_cpu_Cas01_t) action)->
+ variable, 0.0);
((surf_action_cpu_Cas01_t) action)->suspended = 1;
}
XBT_OUT;
static void action_resume(surf_action_t action)
{
- XBT_IN1("(%p)",action);
- if(((surf_action_cpu_Cas01_t) action)->suspended != 2) {
+ XBT_IN1("(%p)", action);
+ if (((surf_action_cpu_Cas01_t) action)->suspended != 2) {
lmm_update_variable_weight(cpu_maxmin_system,
- ((surf_action_cpu_Cas01_t) action)->variable,
- action->priority);
- ((surf_action_cpu_Cas01_t) action)->suspended=0;
+ ((surf_action_cpu_Cas01_t) action)->
+ variable, action->priority);
+ ((surf_action_cpu_Cas01_t) action)->suspended = 0;
}
XBT_OUT;
}
static int action_is_suspended(surf_action_t action)
{
- return (((surf_action_cpu_Cas01_t) action)->suspended==1);
+ return (((surf_action_cpu_Cas01_t) action)->suspended == 1);
}
static void action_set_max_duration(surf_action_t action, double duration)
{
- XBT_IN2("(%p,%g)",action,duration);
+ XBT_IN2("(%p,%g)", action, duration);
action->max_duration = duration;
XBT_OUT;
}
static void action_set_priority(surf_action_t action, double priority)
{
- XBT_IN2("(%p,%g)",action,priority);
+ XBT_IN2("(%p,%g)", action, priority);
action->priority = priority;
XBT_OUT;
}
static double get_speed(void *cpu, double load)
{
- return load*(((cpu_Cas01_t) cpu)->power_scale);
+ return load * (((cpu_Cas01_t) cpu)->power_scale);
}
static double get_available_speed(void *cpu)
surf_cpu_resource->common_public->suspend = action_suspend;
surf_cpu_resource->common_public->resume = action_resume;
surf_cpu_resource->common_public->is_suspended = action_is_suspended;
- surf_cpu_resource->common_public->set_max_duration = action_set_max_duration;
+ surf_cpu_resource->common_public->set_max_duration =
+ action_set_max_duration;
surf_cpu_resource->common_public->set_priority = action_set_priority;
surf_cpu_resource->extension_public->execute = execute;
surf_cpu_resource->extension_public->sleep = action_sleep;
surf_cpu_resource->extension_public->get_state = get_state;
surf_cpu_resource->extension_public->get_speed = get_speed;
- surf_cpu_resource->extension_public->get_available_speed = get_available_speed;
+ surf_cpu_resource->extension_public->get_available_speed =
+ get_available_speed;
cpu_set = xbt_dict_new();
- if(!cpu_maxmin_system)
+ if (!cpu_maxmin_system)
cpu_maxmin_system = lmm_system_new();
}
/*
* Compute Usage and store the variables that reach the maximum.
*/
- while(1){
+ while (1) {
DEBUG1("Constraints to process: %d", xbt_swag_size(cnst_list));
xbt_swag_foreach_safe(cnst, cnst_next, cnst_list) {
int nb = 0;
elem_list = &(cnst->element_set);
cnst->usage = 0.0;
xbt_swag_foreach(elem, elem_list) {
- if(elem->variable->weight <=0) break;
+ if (elem->variable->weight <= 0)
+ break;
if ((elem->value > 0)) {
nb++;
- if(cnst->usage>0)
- cnst->usage = MIN(cnst->usage, elem->value / elem->variable->weight);
- else
+ if (cnst->usage > 0)
+ cnst->usage =
+ MIN(cnst->usage, elem->value / elem->variable->weight);
+ else
cnst->usage = elem->value / elem->variable->weight;
- }
- DEBUG2("Constraint Usage %p : %f",cnst,cnst->usage);
- // make_elem_active(elem);
+ }
+ DEBUG2("Constraint Usage %p : %f", cnst, cnst->usage);
+ // make_elem_active(elem);
}
- if(!cnst->shared) nb=1;
+ if (!cnst->shared)
+ nb = 1;
cnst->usage = cnst->usage * nb;
/* Saturated constraints update */
- if(min_usage<0 || min_usage > cnst->remaining / cnst->usage) {
+ if (min_usage < 0 || min_usage > cnst->remaining / cnst->usage) {
min_usage = cnst->remaining / cnst->usage;
while ((useless_cnst = xbt_swag_extract(&(cnst_to_update)))) {
xbt_swag_insert_at_head(useless_cnst, cnst_list);
xbt_swag_insert(cnst, &(cnst_to_update));
}
}
-
- if(!xbt_swag_size(&cnst_to_update)) break;
-
- while((cnst = xbt_swag_extract(&cnst_to_update))) {
+
+ if (!xbt_swag_size(&cnst_to_update))
+ break;
+
+ while ((cnst = xbt_swag_extract(&cnst_to_update))) {
int nb = 0;
xbt_swag_foreach(elem, elem_list) {
- if(elem->variable->weight <=0) break;
- if ((elem->value > 0)) nb++;
+ if (elem->variable->weight <= 0)
+ break;
+ if ((elem->value > 0))
+ nb++;
}
- if(!cnst->shared) nb=1;
+ if (!cnst->shared)
+ nb = 1;
xbt_swag_foreach(elem, elem_list) {
- var=elem->variable;
- if(var->weight <=0) break;
- if(var->value == 0.0) {
+ var = elem->variable;
+ if (var->weight <= 0)
+ break;
+ if (var->value == 0.0) {
int i;
- var->value = cnst->remaining / nb * var->weight /
- elem->value;
-
+ var->value = cnst->remaining / nb * var->weight / elem->value;
+
/* Update usage */
-
+
for (i = 0; i < var->cnsts_number; i++) {
lmm_element_t elm = &var->cnsts[i];
cnst = elm->constraint;
- double_update(&(cnst->remaining), elm->value * var->value);
- double_update(&(cnst->usage), elm->value / var->weight);
- // make_elem_inactive(elm);
- }
+ double_update(&(cnst->remaining), elm->value * var->value);
+ double_update(&(cnst->usage), elm->value / var->weight);
+ // make_elem_inactive(elm);
}
}
+ }
}
- }
+ }
sys->modified = 0;
- if(XBT_LOG_ISENABLED(surf_maxmin, xbt_log_priority_debug)) {
+ if (XBT_LOG_ISENABLED(surf_maxmin, xbt_log_priority_debug)) {
lmm_print(sys);
}
}
-
#define SHOW_EXPR(expr) CDEBUG1(surf_lagrange,#expr " = %g",expr);
-double (* func_f_def ) (lmm_variable_t , double);
-double (* func_fp_def ) (lmm_variable_t , double);
-double (* func_fpi_def )(lmm_variable_t , double);
+double (*func_f_def) (lmm_variable_t, double);
+double (*func_fp_def) (lmm_variable_t, double);
+double (*func_fpi_def) (lmm_variable_t, double);
/*
* Local prototypes to implement the lagrangian optimization with optimal step, also called dichotomy.
//solves the proportional fairness using a lagrange optimizition with dichotomy step
void lagrange_solve(lmm_system_t sys);
//computes the value of the dichotomy using a initial values, init, with a specific variable or constraint
-static double dichotomy(double init, double diff(double, void *), void *var_cnst,
- double min_error);
+static double dichotomy(double init, double diff(double, void *),
+ void *var_cnst, double min_error);
//computes the value of the differential of variable param_var applied to mu
static double partial_diff_mu(double mu, void *param_var);
//computes the value of the differential of constraint param_cnst applied to lambda
static double partial_diff_lambda(double lambda, void *param_cnst);
-static int __check_feasible(xbt_swag_t cnst_list, xbt_swag_t var_list, int warn)
+static int __check_feasible(xbt_swag_t cnst_list, xbt_swag_t var_list,
+ int warn)
{
xbt_swag_t elem_list = NULL;
lmm_element_t elem = NULL;
cnst, cnst->bound, tmp);
return 0;
}
- DEBUG3("Checking feasability for constraint (%p): sat = %f, lambda = %f ",
- cnst, tmp - cnst->bound, cnst->lambda);
+ DEBUG3
+ ("Checking feasability for constraint (%p): sat = %f, lambda = %f ",
+ cnst, tmp - cnst->bound, cnst->lambda);
}
xbt_swag_foreach(var, var_list) {
- if(!var->weight) break;
+ if (!var->weight)
+ break;
if (var->bound < 0)
continue;
DEBUG3("Checking feasability for variable (%p): sat = %f mu = %f", var,
}
if (var->bound > 0)
tmp += var->mu;
- DEBUG3("\t Working on var (%p). cost = %e; Df = %e", var, tmp,
- var->df);
+ DEBUG3("\t Working on var (%p). cost = %e; Df = %e", var, tmp, var->df);
//uses the partial differential inverse function
return var->func_fpi(var, tmp);
}
for (j = 0; j < var->cnsts_number; j++) {
sigma_i += (var->cnsts[j].constraint)->lambda;
}
- mu_i = var->func_fp(var,var->bound)-sigma_i;
- if(mu_i<0.0) return 0.0;
+ mu_i = var->func_fp(var, var->bound) - sigma_i;
+ if (mu_i < 0.0)
+ return 0.0;
return mu_i;
}
{
lmm_constraint_t cnst = NULL;
lmm_variable_t var = NULL;
-
+
double obj = 0.0;
xbt_swag_foreach(var, var_list) {
- double sigma_i=0.0;
+ double sigma_i = 0.0;
int j;
- if(!var->weight) break;
+ if (!var->weight)
+ break;
for (j = 0; j < var->cnsts_number; j++)
sigma_i += (var->cnsts[j].constraint)->lambda;
if (var->bound > 0)
sigma_i += var->mu;
- DEBUG2("var %p : sigma_i = %1.20f",var,sigma_i);
+ DEBUG2("var %p : sigma_i = %1.20f", var, sigma_i);
- obj += var->func_f(var,var->func_fpi(var,sigma_i)) -
- sigma_i*var->func_fpi(var,sigma_i);
+ obj += var->func_f(var, var->func_fpi(var, sigma_i)) -
+ sigma_i * var->func_fpi(var, sigma_i);
if (var->bound > 0)
- obj += var->mu*var->bound;
+ obj += var->mu * var->bound;
}
xbt_swag_foreach(cnst, cnst_list)
- obj += cnst->lambda*cnst->bound;
+ obj += cnst->lambda * cnst->bound;
return obj;
}
int iteration = 0;
double tmp = 0;
int i;
- double obj,new_obj;
+ double obj, new_obj;
DEBUG0("Iterative method configuration snapshot =====>");
DEBUG1("#### Maximum number of iterations : %d", max_iterations);
var_list = &(sys->variable_set);
i = 0;
xbt_swag_foreach(var, var_list) {
- if(!var->weight)
+ if (!var->weight)
var->value = 0.0;
else {
if (var->bound < 0.0) {
/*
* Compute dual objective.
*/
- obj = dual_objective(var_list,cnst_list);
+ obj = dual_objective(var_list, cnst_list);
/*
* While doesn't reach a minimun error or a number maximum of iterations.
*/
- while (overall_modification > epsilon_min_error && iteration < max_iterations) {
+ while (overall_modification > epsilon_min_error
+ && iteration < max_iterations) {
/* int dual_updated=0; */
iteration++;
* Improve the value of mu_i
*/
xbt_swag_foreach(var, var_list) {
- if(!var->weight) break;
+ if (!var->weight)
+ break;
if (var->bound >= 0) {
DEBUG1("Working on var (%p)", var);
var->new_mu = new_mu(var);
/* dual_updated += (fabs(var->new_mu-var->mu)>dichotomy_min_error); */
/* DEBUG2("dual_updated (%d) : %1.20f",dual_updated,fabs(var->new_mu-var->mu)); */
- DEBUG3("Updating mu : var->mu (%p) : %1.20f -> %1.20f", var, var->mu, var->new_mu);
+ DEBUG3("Updating mu : var->mu (%p) : %1.20f -> %1.20f", var,
+ var->mu, var->new_mu);
var->mu = var->new_mu;
- new_obj=dual_objective(var_list,cnst_list);
+ new_obj = dual_objective(var_list, cnst_list);
DEBUG3("Improvement for Objective (%g -> %g) : %g", obj, new_obj,
- obj-new_obj);
- xbt_assert1(obj-new_obj>=-epsilon_min_error,"Our gradient sucks! (%1.20f)",obj-new_obj);
+ obj - new_obj);
+ xbt_assert1(obj - new_obj >= -epsilon_min_error,
+ "Our gradient sucks! (%1.20f)", obj - new_obj);
obj = new_obj;
}
}
dichotomy_min_error);
/* dual_updated += (fabs(cnst->new_lambda-cnst->lambda)>dichotomy_min_error); */
/* DEBUG2("dual_updated (%d) : %1.20f",dual_updated,fabs(cnst->new_lambda-cnst->lambda)); */
- DEBUG3("Updating lambda : cnst->lambda (%p) : %1.20f -> %1.20f", cnst, cnst->lambda, cnst->new_lambda);
+ DEBUG3("Updating lambda : cnst->lambda (%p) : %1.20f -> %1.20f",
+ cnst, cnst->lambda, cnst->new_lambda);
cnst->lambda = cnst->new_lambda;
- new_obj=dual_objective(var_list,cnst_list);
+ new_obj = dual_objective(var_list, cnst_list);
DEBUG3("Improvement for Objective (%g -> %g) : %g", obj, new_obj,
- obj-new_obj);
- xbt_assert1(obj-new_obj>=-epsilon_min_error,"Our gradient sucks! (%1.20f)",obj-new_obj);
+ obj - new_obj);
+ xbt_assert1(obj - new_obj >= -epsilon_min_error,
+ "Our gradient sucks! (%1.20f)", obj - new_obj);
obj = new_obj;
}
else {
tmp = new_value(var);
- overall_modification = MAX(overall_modification, fabs(var->value - tmp));
+ overall_modification =
+ MAX(overall_modification, fabs(var->value - tmp));
var->value = tmp;
- DEBUG3("New value of var (%p) = %e, overall_modification = %e", var,
- var->value, overall_modification);
+ DEBUG3("New value of var (%p) = %e, overall_modification = %e",
+ var, var->value, overall_modification);
}
}
DEBUG0("-------------- Check feasability ----------");
if (!__check_feasible(cnst_list, var_list, 0))
overall_modification = 1.0;
- DEBUG2("Iteration %d: overall_modification : %f", iteration, overall_modification);
+ DEBUG2("Iteration %d: overall_modification : %f", iteration,
+ overall_modification);
/* if(!dual_updated) { */
/* WARN1("Could not improve the convergence at iteration %d. Drop it!",iteration); */
/* break; */
*
* @return a double correponding to the result of the dichotomyal process
*/
-static double dichotomy(double init, double diff(double, void *), void *var_cnst,
- double min_error)
+static double dichotomy(double init, double diff(double, void *),
+ void *var_cnst, double min_error)
{
double min, max;
double overall_error;
overall_error = 1;
if ((diff_0 = diff(1e-16, var_cnst)) >= 0) {
- CDEBUG1(surf_lagrange_dichotomy, "returning 0.0 (diff = %e)",
- diff_0);
+ CDEBUG1(surf_lagrange_dichotomy, "returning 0.0 (diff = %e)", diff_0);
XBT_OUT;
return 0.0;
}
while (overall_error > min_error) {
CDEBUG4(surf_lagrange_dichotomy,
- "[min, max] = [%1.20f, %1.20f] || diffmin, diffmax = %1.20f, %1.20f", min, max,
- min_diff,max_diff);
+ "[min, max] = [%1.20f, %1.20f] || diffmin, diffmax = %1.20f, %1.20f",
+ min, max, min_diff, max_diff);
if (min_diff > 0 && max_diff > 0) {
if (min == max) {
}
} else if (min_diff < 0 && max_diff > 0) {
middle = (max + min) / 2.0;
- CDEBUG1(surf_lagrange_dichotomy, "Trying (max+min)/2 : %1.20f",middle);
+ CDEBUG1(surf_lagrange_dichotomy, "Trying (max+min)/2 : %1.20f",
+ middle);
- if((min==middle) || (max==middle)) {
- CWARN4(surf_lagrange_dichotomy,"Cannot improve the convergence! min=max=middle=%1.20f, diff = %1.20f."
+ if ((min == middle) || (max == middle)) {
+ CWARN4(surf_lagrange_dichotomy,
+ "Cannot improve the convergence! min=max=middle=%1.20f, diff = %1.20f."
" Reaching the 'double' limits. Maybe scaling your function would help ([%1.20f,%1.20f]).",
- min, max-min, min_diff,max_diff);
+ min, max - min, min_diff, max_diff);
break;
}
middle_diff = diff(middle, var_cnst);
if (middle_diff < 0) {
CDEBUG0(surf_lagrange_dichotomy, "Increasing min");
min = middle;
- overall_error = max_diff-middle_diff;
+ overall_error = max_diff - middle_diff;
min_diff = middle_diff;
/* SHOW_EXPR(overall_error); */
} else if (middle_diff > 0) {
CDEBUG0(surf_lagrange_dichotomy, "Decreasing max");
max = middle;
- overall_error = max_diff-middle_diff;
+ overall_error = max_diff - middle_diff;
max_diff = middle_diff;
/* SHOW_EXPR(overall_error); */
} else {
/* SHOW_EXPR(overall_error); */
}
} else if (min_diff == 0) {
- max=min;
+ max = min;
overall_error = 0;
/* SHOW_EXPR(overall_error); */
} else if (max_diff == 0) {
- min=max;
+ min = max;
overall_error = 0;
/* SHOW_EXPR(overall_error); */
} else if (min_diff > 0 && max_diff < 0) {
XBT_IN;
elem_list = &(cnst->element_set);
- CDEBUG1(surf_lagrange_dichotomy,"Computing diff of cnst (%p)", cnst);
+ CDEBUG1(surf_lagrange_dichotomy, "Computing diff of cnst (%p)", cnst);
xbt_swag_foreach(elem, elem_list) {
var = elem->variable;
if (var->weight <= 0)
continue;
- CDEBUG1(surf_lagrange_dichotomy,"Computing sigma_i for var (%p)", var);
+ CDEBUG1(surf_lagrange_dichotomy, "Computing sigma_i for var (%p)",
+ var);
// Initialize the summation variable
sigma_i = 0.0;
//replace value of cnst->lambda by the value of parameter lambda
sigma_i = (sigma_i - cnst->lambda) + lambda;
- diff += -var->func_fpi(var, sigma_i);
+ diff += -var->func_fpi(var, sigma_i);
}
diff += cnst->bound;
- CDEBUG3(surf_lagrange_dichotomy,"d D/d lambda for cnst (%p) at %1.20f = %1.20f",
- cnst, lambda, diff);
+ CDEBUG3(surf_lagrange_dichotomy,
+ "d D/d lambda for cnst (%p) at %1.20f = %1.20f", cnst, lambda,
+ diff);
XBT_OUT;
return diff;
}
* Set default functions to the ones passed as parameters. This is a polimorfism in C pure, enjoy the roots of programming.
*
*/
-void lmm_set_default_protocol_function(double (* func_f) (lmm_variable_t var, double x),
- double (* func_fp) (lmm_variable_t var, double x),
- double (* func_fpi) (lmm_variable_t var, double x))
+void
+lmm_set_default_protocol_function(double (*func_f)
+ (lmm_variable_t var, double x),
+ double (*func_fp) (lmm_variable_t var,
+ double x),
+ double (*func_fpi) (lmm_variable_t var,
+ double x))
{
- func_f_def = func_f;
- func_fp_def = func_fp;
- func_fpi_def = func_fpi;
+ func_f_def = func_f;
+ func_fp_def = func_fp;
+ func_fpi_def = func_fpi;
}
*/
#define VEGAS_SCALING 1000.0
-double func_vegas_f(lmm_variable_t var, double x){
- xbt_assert1(x>0.0,"Don't call me with stupid values! (%1.20f)",x);
- return VEGAS_SCALING*var->df*log(x);
+double func_vegas_f(lmm_variable_t var, double x)
+{
+ xbt_assert1(x > 0.0, "Don't call me with stupid values! (%1.20f)", x);
+ return VEGAS_SCALING * var->df * log(x);
}
-double func_vegas_fp(lmm_variable_t var, double x){
- xbt_assert1(x>0.0,"Don't call me with stupid values! (%1.20f)",x);
- return VEGAS_SCALING*var->df/x;
+double func_vegas_fp(lmm_variable_t var, double x)
+{
+ xbt_assert1(x > 0.0, "Don't call me with stupid values! (%1.20f)", x);
+ return VEGAS_SCALING * var->df / x;
}
-double func_vegas_fpi(lmm_variable_t var, double x){
- xbt_assert1(x>0.0,"Don't call me with stupid values! (%1.20f)",x);
- return var->df/(x/VEGAS_SCALING);
+double func_vegas_fpi(lmm_variable_t var, double x)
+{
+ xbt_assert1(x > 0.0, "Don't call me with stupid values! (%1.20f)", x);
+ return var->df / (x / VEGAS_SCALING);
}
/*
* Therefore: $fpi(x) = \sqrt{\frac{1}{{D_f}^2 x} - \frac{2}{3{D_f}^2}}$
*/
#define RENO_SCALING 1.0
-double func_reno_f(lmm_variable_t var, double x){
- xbt_assert0(var->df>0.0,"Don't call me with stupid values!");
+double func_reno_f(lmm_variable_t var, double x)
+{
+ xbt_assert0(var->df > 0.0, "Don't call me with stupid values!");
- return RENO_SCALING*sqrt(3.0/2.0)/var->df*atan(sqrt(3.0/2.0)*var->df*x);
+ return RENO_SCALING * sqrt(3.0 / 2.0) / var->df * atan(sqrt(3.0 / 2.0) *
+ var->df * x);
}
-double func_reno_fp(lmm_variable_t var, double x){
- return RENO_SCALING*3.0/(3.0*var->df*var->df*x*x +2.0);
+double func_reno_fp(lmm_variable_t var, double x)
+{
+ return RENO_SCALING * 3.0 / (3.0 * var->df * var->df * x * x + 2.0);
}
-double func_reno_fpi(lmm_variable_t var, double x){
- double res_fpi;
+double func_reno_fpi(lmm_variable_t var, double x)
+{
+ double res_fpi;
- xbt_assert0(var->df>0.0,"Don't call me with stupid values!");
- xbt_assert0(x>0.0,"Don't call me with stupid values!");
+ xbt_assert0(var->df > 0.0, "Don't call me with stupid values!");
+ xbt_assert0(x > 0.0, "Don't call me with stupid values!");
- res_fpi = 1.0/(var->df*var->df*(x/RENO_SCALING)) - 2.0/(3.0*var->df*var->df);
- if(res_fpi<=0.0) return 0.0;
+ res_fpi =
+ 1.0 / (var->df * var->df * (x / RENO_SCALING)) -
+ 2.0 / (3.0 * var->df * var->df);
+ if (res_fpi <= 0.0)
+ return 0.0;
/* xbt_assert0(res_fpi>0.0,"Don't call me with stupid values!"); */
return sqrt(res_fpi);
}
-
-
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_maxmin, surf,
"Logging specific to SURF (maxmin)");
-static void* lmm_variable_mallocator_new_f(void);
+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);
int i;
lmm_element_t elem = NULL;
- XBT_IN2("(sys=%p, var=%p)",sys,var);
+ XBT_IN2("(sys=%p, var=%p)", sys, var);
sys->modified = 1;
for (i = 0; i < var->cnsts_number; i++) {
lmm_cnst_free(sys, cnst);
}
-static void* lmm_variable_mallocator_new_f(void) {
+static void *lmm_variable_mallocator_new_f(void)
+{
return xbt_new(s_lmm_variable_t, 1);
}
-static void lmm_variable_mallocator_free_f(void *var) {
+static void lmm_variable_mallocator_free_f(void *var)
+{
xbt_free(var);
}
-static void lmm_variable_mallocator_reset_f(void *var) {
+static void lmm_variable_mallocator_reset_f(void *var)
+{
/* memset to zero like calloc */
memset(var, 0, sizeof(s_lmm_variable_t));
}
int i;
XBT_IN5("(sys=%p, id=%p, weight=%f, bound=%f, num_cons =%d)",
- sys,id,weight,bound,number_of_constraints);
+ sys, id, weight, bound, number_of_constraints);
var = xbt_mallocator_get(sys->variable_mallocator);
var->id = id;
var->cnsts = xbt_new0(s_lmm_element_t, number_of_constraints);
- for(i=0; i<number_of_constraints; i++) {
+ 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].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; /* Should be useless because of the
+ calloc but it seems to help valgrind... */
var->weight = weight;
var->bound = bound;
var->value = 0.0;
- var->df = 0.0;
+ var->df = 0.0;
- var->func_f = func_f_def;
- var->func_fp = func_fp_def;
- var->func_fpi = func_fpi_def;
+ var->func_f = func_f_def;
+ var->func_fp = func_fp_def;
+ var->func_fpi = func_fpi_def;
- if(weight) xbt_swag_insert_at_head(var,&(sys->variable_set));
- else xbt_swag_insert_at_tail(var,&(sys->variable_set));
+ if (weight)
+ xbt_swag_insert_at_head(var, &(sys->variable_set));
+ else
+ xbt_swag_insert_at_tail(var, &(sys->variable_set));
XBT_OUT;
return var;
}
sys->modified = 1;
- xbt_assert0(var->cnsts_number < var->cnsts_size,
- "Too much constraints");
+ xbt_assert0(var->cnsts_number < var->cnsts_size, "Too much constraints");
elem = &(var->cnsts[var->cnsts_number++]);
elem->constraint = cnst;
elem->variable = var;
- if(var->weight) xbt_swag_insert_at_head(elem,&(elem->constraint->element_set));
- else xbt_swag_insert_at_tail(elem,&(elem->constraint->element_set));
+ if (var->weight)
+ 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);
}
void lmm_expand_add(lmm_system_t sys, lmm_constraint_t cnst,
lmm_variable_t var, double value)
{
- int i ;
+ int i;
sys->modified = 1;
- for(i=0; i< var->cnsts_number ; i++)
- if(var->cnsts[i].constraint == cnst) break;
-
- if(i<var->cnsts_number) var->cnsts[i].value +=value;
- else lmm_expand(sys,cnst,var,value);
+ for (i = 0; i < var->cnsts_number; i++)
+ if (var->cnsts[i].constraint == cnst)
+ break;
+
+ if (i < var->cnsts_number)
+ var->cnsts[i].value += value;
+ else
+ lmm_expand(sys, cnst, var, value);
}
void lmm_elem_set_value(lmm_system_t sys, lmm_constraint_t cnst,
lmm_variable_t var, double value)
{
- int i ;
+ int i;
- for(i=0; i< var->cnsts_number ; i++)
- if(var->cnsts[i].constraint == cnst) break;
+ for (i = 0; i < var->cnsts_number; i++)
+ if (var->cnsts[i].constraint == cnst)
+ break;
- if(i<var->cnsts_number) {
- var->cnsts[i].value =value;
+ if (i < var->cnsts_number) {
+ var->cnsts[i].value = value;
sys->modified = 1;
- } else DIE_IMPOSSIBLE;
+ } else
+ DIE_IMPOSSIBLE;
}
lmm_constraint_t lmm_get_cnst_from_var(lmm_system_t sys,
{
lmm_constraint_t useless_cnst = NULL;
- XBT_IN3("sys=%p, cnst=%p, min_usage=%f",sys,cnst,*min_usage);
+ XBT_IN3("sys=%p, cnst=%p, min_usage=%f", sys, cnst, *min_usage);
if (cnst->usage <= 0) {
XBT_OUT;
return;
}
if ((*min_usage < 0) || (*min_usage > cnst->remaining / cnst->usage)) {
*min_usage = cnst->remaining / cnst->usage;
- LOG3(xbt_log_priority_trace,
- "min_usage=%f (cnst->remaining=%f, cnst->usage=%f)",*min_usage,
+ LOG3(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))))
while ((cnst = xbt_swag_getFirst(cnst_list))) {
elem_list = &(cnst->active_element_set);
xbt_swag_foreach(elem, elem_list) {
- if(elem->variable->weight<=0) break;
+ if (elem->variable->weight <= 0)
+ break;
if ((elem->value > 0))
xbt_swag_insert(elem->variable, &(sys->saturated_variable_set));
}
}
void lmm_print(lmm_system_t sys)
-
{
lmm_constraint_t cnst = NULL;
lmm_element_t elem = NULL;
xbt_swag_t var_list = NULL;
xbt_swag_t elem_list = NULL;
char print_buf[1024];
- char *trace_buf=xbt_malloc0(sizeof(char));
- double sum=0.0;
+ char *trace_buf = xbt_malloc0(sizeof(char));
+ double sum = 0.0;
/* Printing Objective */
var_list = &(sys->variable_set);
- sprintf(print_buf,"MAX-MIN ( ");
- trace_buf = xbt_realloc(trace_buf,strlen(trace_buf)+strlen(print_buf)+1);
+ sprintf(print_buf, "MAX-MIN ( ");
+ trace_buf =
+ 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,"'%p'(%f) ",var,var->weight);
- trace_buf = xbt_realloc(trace_buf,strlen(trace_buf)+strlen(print_buf)+1);
+ sprintf(print_buf, "'%p'(%f) ", var, var->weight);
+ trace_buf =
+ 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);
+ sprintf(print_buf, ")");
+ trace_buf =
+ xbt_realloc(trace_buf, strlen(trace_buf) + strlen(print_buf) + 1);
strcat(trace_buf, print_buf);
- DEBUG1("%s",trace_buf);
- trace_buf[0]='\000';
+ DEBUG1("%s", trace_buf);
+ trace_buf[0] = '\000';
/* Printing Constraints */
cnst_list = &(sys->active_constraint_set);
xbt_swag_foreach(cnst, cnst_list) {
- sum=0.0;
+ sum = 0.0;
elem_list = &(cnst->element_set);
- sprintf(print_buf,"\t");
- trace_buf = xbt_realloc(trace_buf,strlen(trace_buf)+strlen(print_buf)+1);
+ sprintf(print_buf, "\t");
+ 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.'%p'(%f) + ",elem->value,
- elem->variable,elem->variable->value);
- trace_buf = xbt_realloc(trace_buf,strlen(trace_buf)+strlen(print_buf)+1);
+ sprintf(print_buf, "%f.'%p'(%f) + ", elem->value,
+ elem->variable, elem->variable->value);
+ trace_buf =
+ xbt_realloc(trace_buf,
+ strlen(trace_buf) + strlen(print_buf) + 1);
strcat(trace_buf, print_buf);
sum += elem->value * elem->variable->value;
}
- sprintf(print_buf,"0 <= %f ('%p')",cnst->bound,cnst);
- trace_buf = xbt_realloc(trace_buf,strlen(trace_buf)+strlen(print_buf)+1);
+ sprintf(print_buf, "0 <= %f ('%p')", cnst->bound, cnst);
+ trace_buf =
+ 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);
+ if (!cnst->shared) {
+ sprintf(print_buf, " [MAX-Constraint]");
+ trace_buf =
+ xbt_realloc(trace_buf,
+ strlen(trace_buf) + strlen(print_buf) + 1);
strcat(trace_buf, print_buf);
}
- DEBUG1("%s",trace_buf);
- trace_buf[0]='\000';
- if(double_positive(sum-cnst->bound))
+ DEBUG1("%s", trace_buf);
+ trace_buf[0] = '\000';
+ if (double_positive(sum - cnst->bound))
WARN3("Incorrect value (%f is not smaller than %f): %g",
- sum,cnst->bound,sum-cnst->bound);
+ sum, cnst->bound, sum - cnst->bound);
}
/* Printing Result */
xbt_swag_foreach(var, var_list) {
- if(var->bound>0) {
- DEBUG4("'%p'(%f) : %f (<=%f)",var,var->weight,var->value, var->bound);
- if(double_positive(var->value-var->bound))
- WARN2("Incorrect value (%f is not smaller than %f",
- var->value, var->bound);
- }
- else
- DEBUG3("'%p'(%f) : %f",var,var->weight,var->value);
+ if (var->bound > 0) {
+ DEBUG4("'%p'(%f) : %f (<=%f)", var, var->weight, var->value,
+ var->bound);
+ if (double_positive(var->value - var->bound))
+ WARN2("Incorrect value (%f is not smaller than %f",
+ var->value, var->bound);
+ } else
+ DEBUG3("'%p'(%f) : %f", var, var->weight, var->value);
}
free(trace_buf);
elem_list = &(cnst->element_set);
cnst->usage = 0.0;
xbt_swag_foreach(elem, elem_list) {
- if(elem->variable->weight <=0) break;
+ if (elem->variable->weight <= 0)
+ break;
if ((elem->value > 0)) {
- if(cnst->shared)
+ if (cnst->shared)
cnst->usage += elem->value / elem->variable->weight;
- else
- if(cnst->usage<elem->value / elem->variable->weight)
- cnst->usage = elem->value / elem->variable->weight;
- DEBUG2("Constraint Usage %p : %f",cnst,cnst->usage);
+ else if (cnst->usage < elem->value / elem->variable->weight)
+ cnst->usage = elem->value / elem->variable->weight;
+ DEBUG2("Constraint Usage %p : %f", cnst, cnst->usage);
make_elem_active(elem);
}
}
xbt_swag_foreach(var, var_list) {
/* First check if some of these variables have reach their upper
bound and update min_usage accordingly. */
- DEBUG5("var=%p, var->bound=%f, var->weight=%f, min_usage=%f, var->bound*var->weight=%f",
- var, var->bound, var->weight, min_usage,var->bound * var->weight);
+ DEBUG5
+ ("var=%p, var->bound=%f, var->weight=%f, min_usage=%f, var->bound*var->weight=%f",
+ var, var->bound, var->weight, min_usage,
+ var->bound * var->weight);
if ((var->bound > 0) && (var->bound * var->weight < min_usage)) {
min_usage = var->bound * var->weight;
- DEBUG1("Updated min_usage=%f",min_usage);
+ DEBUG1("Updated min_usage=%f", min_usage);
}
}
int i;
var->value = min_usage / var->weight;
- DEBUG5("Min usage: %f, Var(%p)->weight: %f, Var(%p)->value: %f ",min_usage,var,var->weight,var,var->value);
+ DEBUG5("Min usage: %f, Var(%p)->weight: %f, Var(%p)->value: %f ",
+ min_usage, var, var->weight, var, var->value);
/* Update usage */
for (i = 0; i < var->cnsts_number; i++) {
elem = &var->cnsts[i];
cnst = elem->constraint;
- if(cnst->shared) {
+ if (cnst->shared) {
double_update(&(cnst->remaining), elem->value * var->value);
double_update(&(cnst->usage), elem->value / var->weight);
make_elem_inactive(elem);
- } else { /* FIXME one day: We recompute usage.... :( */
+ } else { /* FIXME one day: We recompute usage.... :( */
cnst->usage = 0.0;
make_elem_inactive(elem);
xbt_swag_foreach(elem, elem_list) {
- if(elem->variable->weight <=0) break;
- if(elem->variable->value > 0) break;
+ if (elem->variable->weight <= 0)
+ break;
+ if (elem->variable->value > 0)
+ break;
if ((elem->value > 0)) {
- if(cnst->usage<elem->value / elem->variable->weight)
+ if (cnst->usage < elem->value / elem->variable->weight)
cnst->usage = elem->value / elem->variable->weight;
- DEBUG2("Constraint Usage %p : %f",cnst,cnst->usage);
+ DEBUG2("Constraint Usage %p : %f", cnst, cnst->usage);
make_elem_active(elem);
}
- }
+ }
}
}
xbt_swag_remove(var, var_list);
} while (xbt_swag_size(&(sys->saturated_variable_set)));
sys->modified = 0;
- if(XBT_LOG_ISENABLED(surf_maxmin, xbt_log_priority_debug)) {
+ if (XBT_LOG_ISENABLED(surf_maxmin, xbt_log_priority_debug)) {
lmm_print(sys);
}
}
*
*/
void lmm_update_variable_latency(lmm_system_t sys, lmm_variable_t var,
- double delta)
+ double delta)
{
sys->modified = 1;
var->df += delta;
void lmm_update_variable_weight(lmm_system_t sys, lmm_variable_t var,
double weight)
{
- int i ;
+ int i;
lmm_element_t elem;
- XBT_IN3("(sys=%p, var=%p, weight=%f)",sys,var,weight);
+ XBT_IN3("(sys=%p, var=%p, weight=%f)", sys, var, weight);
sys->modified = 1;
var->weight = weight;
- xbt_swag_remove(var,&(sys->variable_set));
- if(weight) xbt_swag_insert_at_head(var,&(sys->variable_set));
- else xbt_swag_insert_at_tail(var,&(sys->variable_set));
+ xbt_swag_remove(var, &(sys->variable_set));
+ if (weight)
+ xbt_swag_insert_at_head(var, &(sys->variable_set));
+ else
+ xbt_swag_insert_at_tail(var, &(sys->variable_set));
for (i = 0; i < var->cnsts_number; i++) {
elem = &var->cnsts[i];
xbt_swag_remove(elem, &(elem->constraint->element_set));
- if(weight) xbt_swag_insert_at_head(elem, &(elem->constraint->element_set));
- else xbt_swag_insert_at_tail(elem, &(elem->constraint->element_set));
+ if (weight)
+ xbt_swag_insert_at_head(elem, &(elem->constraint->element_set));
+ else
+ xbt_swag_insert_at_tail(elem, &(elem->constraint->element_set));
}
XBT_OUT;
}
double lmm_get_variable_weight(lmm_variable_t var)
-
{
return var->weight;
}
return xbt_swag_getFirst(&(sys->active_constraint_set));
}
-lmm_constraint_t lmm_get_next_active_constraint(lmm_system_t sys, lmm_constraint_t cnst)
+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);
+ return xbt_swag_getNext(cnst, (sys->active_constraint_set).offset);
}
-
-
surf_network_resource_t surf_network_resource = NULL;
static lmm_system_t network_maxmin_system = NULL;
-static void (*network_solve)(lmm_system_t) = NULL;
+static void (*network_solve) (lmm_system_t) = NULL;
xbt_dict_t network_link_set = NULL;
xbt_dict_t network_card_set = NULL;
static void create_routing_table(void)
{
- routing_table = xbt_new0(network_link_CM02_t *, card_number * card_number);
+ routing_table =
+ xbt_new0(network_link_CM02_t *, card_number * card_number);
routing_table_size = xbt_new0(int, card_number * card_number);
}
static void network_link_free(void *nw_link)
{
- free(((network_link_CM02_t)nw_link)->name);
+ free(((network_link_CM02_t) nw_link)->name);
free(nw_link);
}
static network_link_CM02_t network_link_new(char *name,
- double bw_initial,
- tmgr_trace_t bw_trace,
- double lat_initial,
- tmgr_trace_t lat_trace,
- e_surf_network_link_state_t
- state_initial,
- tmgr_trace_t state_trace,
- e_surf_network_link_sharing_policy_t policy)
+ double bw_initial,
+ tmgr_trace_t bw_trace,
+ double lat_initial,
+ tmgr_trace_t lat_trace,
+ e_surf_network_link_state_t
+ state_initial,
+ tmgr_trace_t state_trace,
+ e_surf_network_link_sharing_policy_t
+ policy)
{
network_link_CM02_t nw_link = xbt_new0(s_network_link_CM02_t, 1);
tmgr_history_add_trace(history, state_trace, 0.0, 0, nw_link);
nw_link->constraint =
- lmm_constraint_new(network_maxmin_system, nw_link, nw_link->bw_current);
+ lmm_constraint_new(network_maxmin_system, nw_link,
+ nw_link->bw_current);
- if(policy == SURF_NETWORK_LINK_FATPIPE)
+ if (policy == SURF_NETWORK_LINK_FATPIPE)
lmm_constraint_shared(nw_link->constraint);
xbt_dict_set(network_link_set, name, nw_link, network_link_free);
static void network_card_free(void *nw_card)
{
- free(((network_card_CM02_t)nw_card)->name);
+ free(((network_card_CM02_t) nw_card)->name);
free(nw_card);
}
static int network_card_new(const char *card_name)
{
- network_card_CM02_t card = xbt_dict_get_or_null(network_card_set, card_name);
+ network_card_CM02_t card =
+ xbt_dict_get_or_null(network_card_set, card_name);
if (!card) {
card = xbt_new0(s_network_card_CM02_t, 1);
return card->id;
}
-static void route_new(int src_id, int dst_id, network_link_CM02_t *link_list, int nb_link)
+static void route_new(int src_id, int dst_id,
+ network_link_CM02_t * link_list, int nb_link)
{
ROUTE_SIZE(src_id, dst_id) = nb_link;
- ROUTE(src_id, dst_id) = link_list = xbt_realloc(link_list, sizeof(network_link_CM02_t) * nb_link);
+ ROUTE(src_id, dst_id) = link_list =
+ xbt_realloc(link_list, sizeof(network_link_CM02_t) * nb_link);
}
static void parse_network_link(void)
double lat_initial;
tmgr_trace_t lat_trace;
e_surf_network_link_state_t state_initial = SURF_NETWORK_LINK_ON;
- e_surf_network_link_sharing_policy_t policy_initial = SURF_NETWORK_LINK_SHARED;
+ e_surf_network_link_sharing_policy_t policy_initial =
+ SURF_NETWORK_LINK_SHARED;
tmgr_trace_t state_trace;
name = xbt_strdup(A_surfxml_network_link_name);
- surf_parse_get_double(&bw_initial,A_surfxml_network_link_bandwidth);
+ surf_parse_get_double(&bw_initial, A_surfxml_network_link_bandwidth);
surf_parse_get_trace(&bw_trace, A_surfxml_network_link_bandwidth_file);
- surf_parse_get_double(&lat_initial,A_surfxml_network_link_latency);
+ surf_parse_get_double(&lat_initial, A_surfxml_network_link_latency);
surf_parse_get_trace(&lat_trace, A_surfxml_network_link_latency_file);
- xbt_assert0((A_surfxml_network_link_state==A_surfxml_network_link_state_ON)||
- (A_surfxml_network_link_state==A_surfxml_network_link_state_OFF),
- "Invalid state");
- if (A_surfxml_network_link_state==A_surfxml_network_link_state_ON)
+ xbt_assert0((A_surfxml_network_link_state ==
+ A_surfxml_network_link_state_ON)
+ || (A_surfxml_network_link_state ==
+ A_surfxml_network_link_state_OFF), "Invalid state");
+ if (A_surfxml_network_link_state == A_surfxml_network_link_state_ON)
state_initial = SURF_NETWORK_LINK_ON;
- else if (A_surfxml_network_link_state==A_surfxml_network_link_state_OFF)
+ else if (A_surfxml_network_link_state ==
+ A_surfxml_network_link_state_OFF)
state_initial = SURF_NETWORK_LINK_OFF;
- if (A_surfxml_network_link_sharing_policy==A_surfxml_network_link_sharing_policy_SHARED)
+ if (A_surfxml_network_link_sharing_policy ==
+ A_surfxml_network_link_sharing_policy_SHARED)
policy_initial = SURF_NETWORK_LINK_SHARED;
- else if (A_surfxml_network_link_sharing_policy==A_surfxml_network_link_sharing_policy_FATPIPE)
+ else if (A_surfxml_network_link_sharing_policy ==
+ A_surfxml_network_link_sharing_policy_FATPIPE)
policy_initial = SURF_NETWORK_LINK_FATPIPE;
- surf_parse_get_trace(&state_trace,A_surfxml_network_link_state_file);
+ surf_parse_get_trace(&state_trace, A_surfxml_network_link_state_file);
network_link_new(name, bw_initial, bw_trace,
lat_initial, lat_trace, state_initial, state_trace,
{
if (nb_link == link_list_capacity) {
link_list_capacity *= 2;
- link_list = xbt_realloc(link_list, (link_list_capacity) * sizeof(network_link_CM02_t));
+ link_list =
+ xbt_realloc(link_list,
+ (link_list_capacity) * sizeof(network_link_CM02_t));
}
- link_list[nb_link++] = xbt_dict_get_or_null(network_link_set, A_surfxml_route_element_name);
+ link_list[nb_link++] =
+ xbt_dict_get_or_null(network_link_set, A_surfxml_route_element_name);
}
static void parse_route_set_route(void)
/* Figuring out the network links */
surf_parse_reset_parser();
- ETag_surfxml_network_link_fun=parse_network_link;
+ ETag_surfxml_network_link_fun = parse_network_link;
surf_parse_open(file);
- xbt_assert1((!surf_parse()),"Parse error in %s",file);
+ xbt_assert1((!surf_parse()), "Parse error in %s", file);
surf_parse_close();
/* Figuring out the network cards used */
surf_parse_reset_parser();
- STag_surfxml_route_fun=parse_route_set_endpoints;
+ STag_surfxml_route_fun = parse_route_set_endpoints;
surf_parse_open(file);
- xbt_assert1((!surf_parse()),"Parse error in %s",file);
+ xbt_assert1((!surf_parse()), "Parse error in %s", file);
surf_parse_close();
create_routing_table();
/* Building the routes */
surf_parse_reset_parser();
- STag_surfxml_route_fun=parse_route_set_endpoints;
- ETag_surfxml_route_element_fun=parse_route_elem;
- ETag_surfxml_route_fun=parse_route_set_route;
+ STag_surfxml_route_fun = parse_route_set_endpoints;
+ ETag_surfxml_route_element_fun = parse_route_elem;
+ ETag_surfxml_route_fun = parse_route_set_route;
surf_parse_open(file);
- xbt_assert1((!surf_parse()),"Parse error in %s",file);
+ xbt_assert1((!surf_parse()), "Parse error in %s", file);
surf_parse_close();
/* Adding loopback if needed */
-
- for (i = 0; i < card_number; i++)
- if(!ROUTE_SIZE(i,i)) {
- if(!loopback)
- loopback = network_link_new(xbt_strdup("__MSG_loopback__"),
- 498000000, NULL, 0.000015, NULL,
- SURF_NETWORK_LINK_ON, NULL,
- SURF_NETWORK_LINK_FATPIPE);
- ROUTE_SIZE(i,i)=1;
- ROUTE(i,i) = xbt_new0(network_link_CM02_t, 1);
- ROUTE(i,i)[0] = loopback;
+
+ for (i = 0; i < card_number; i++)
+ if (!ROUTE_SIZE(i, i)) {
+ if (!loopback)
+ loopback = network_link_new(xbt_strdup("__MSG_loopback__"),
+ 498000000, NULL, 0.000015, NULL,
+ SURF_NETWORK_LINK_ON, NULL,
+ SURF_NETWORK_LINK_FATPIPE);
+ ROUTE_SIZE(i, i) = 1;
+ ROUTE(i, i) = xbt_new0(network_link_CM02_t, 1);
+ ROUTE(i, i)[0] = loopback;
}
}
static int resource_used(void *resource_id)
{
return lmm_constraint_used(network_maxmin_system,
- ((network_link_CM02_t) resource_id)->constraint);
+ ((network_link_CM02_t) resource_id)->
+ constraint);
}
static int action_free(surf_action_t action)
{
action->using--;
- if(!action->using) {
+ if (!action->using) {
xbt_swag_remove(action, action->state_set);
- if(((surf_action_network_CM02_t)action)->variable)
- lmm_variable_free(network_maxmin_system, ((surf_action_network_CM02_t)action)->variable);
+ if (((surf_action_network_CM02_t) action)->variable)
+ lmm_variable_free(network_maxmin_system,
+ ((surf_action_network_CM02_t) action)->variable);
free(action);
return 1;
}
{
s_surf_action_network_CM02_t s_action;
surf_action_network_CM02_t action = NULL;
- xbt_swag_t running_actions = surf_network_resource->common_public->states.running_action_set;
+ xbt_swag_t running_actions =
+ surf_network_resource->common_public->states.running_action_set;
double min;
-
+
min = generic_maxmin_share_resources2(running_actions,
- xbt_swag_offset(s_action, variable),
- network_maxmin_system, network_solve);
+ xbt_swag_offset(s_action,
+ variable),
+ network_maxmin_system,
+ network_solve);
xbt_swag_foreach(action, running_actions) {
- if(action->latency>0) {
- if(min<0) min = action->latency;
- else if (action->latency<min) min = action->latency;
+ if (action->latency > 0) {
+ if (min < 0)
+ min = action->latency;
+ else if (action->latency < min)
+ min = action->latency;
}
}
xbt_swag_t running_actions =
surf_network_resource->common_public->states.running_action_set;
/*
- xbt_swag_t failed_actions =
- surf_network_resource->common_public->states.failed_action_set;
- */
+ xbt_swag_t failed_actions =
+ surf_network_resource->common_public->states.failed_action_set;
+ */
xbt_swag_foreach_safe(action, next_action, running_actions) {
deltap = delta;
if (action->latency > 0) {
if (action->latency > deltap) {
- double_update(&(action->latency),deltap);
+ double_update(&(action->latency), deltap);
deltap = 0.0;
} else {
double_update(&(deltap), action->latency);
action->latency = 0.0;
}
- if ((action->latency == 0.0) && !(action->suspended))
- lmm_update_variable_weight(network_maxmin_system, action->variable,
+ if ((action->latency == 0.0) && !(action->suspended))
+ lmm_update_variable_weight(network_maxmin_system, action->variable,
action->lat_current);
}
double_update(&(action->generic_action.remains),
- lmm_variable_getvalue(action->variable) * deltap);
+ lmm_variable_getvalue(action->variable) * deltap);
if (action->generic_action.max_duration != NO_MAX_DURATION)
double_update(&(action->generic_action.max_duration), delta);
/* if(action->generic_action.remains<.00001) action->generic_action.remains=0; */
- if ((action->generic_action.remains <= 0) &&
- (lmm_get_variable_weight(action->variable)>0)) {
+ if ((action->generic_action.remains <= 0) &&
+ (lmm_get_variable_weight(action->variable) > 0)) {
action->generic_action.finish = surf_get_clock();
action_change_state((surf_action_t) action, SURF_ACTION_DONE);
} else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
network_link_CM02_t nw_link = NULL;
while ((cnst =
- lmm_get_cnst_from_var(network_maxmin_system, action->variable,
- i++))) {
+ lmm_get_cnst_from_var(network_maxmin_system,
+ action->variable, i++))) {
nw_link = lmm_constraint_id(cnst);
if (nw_link->state_current == SURF_NETWORK_LINK_OFF) {
action->generic_action.finish = surf_get_clock();
{
network_link_CM02_t nw_link = id;
/* printf("[" "%lg" "] Asking to update network card \"%s\" with value " */
- /* "%lg" " for event %p\n", surf_get_clock(), nw_link->name, */
- /* value, event_type); */
+ /* "%lg" " for event %p\n", surf_get_clock(), nw_link->name, */
+ /* value, event_type); */
if (event_type == nw_link->bw_event) {
nw_link->bw_current = value;
surf_action_network_CM02_t action = NULL;
nw_link->lat_current = value;
- while (lmm_get_var_from_cnst(network_maxmin_system, nw_link->constraint, &var)) {
+ while (lmm_get_var_from_cnst
+ (network_maxmin_system, nw_link->constraint, &var)) {
action = lmm_variable_id(var);
action->lat_current += delta;
- if(action->rate<0)
+ if (action->rate < 0)
lmm_update_variable_bound(network_maxmin_system, action->variable,
- SG_TCP_CTE_GAMMA / (2.0 * action->lat_current));
- else
+ SG_TCP_CTE_GAMMA / (2.0 *
+ action->
+ lat_current));
+ else
lmm_update_variable_bound(network_maxmin_system, action->variable,
- min(action->rate,SG_TCP_CTE_GAMMA / (2.0 * action->lat_current)));
- if(!(action->suspended))
- lmm_update_variable_weight(network_maxmin_system, action->variable,
+ min(action->rate,
+ SG_TCP_CTE_GAMMA / (2.0 *
+ action->
+ lat_current)));
+ if (!(action->suspended))
+ lmm_update_variable_weight(network_maxmin_system, action->variable,
action->lat_current);
- lmm_update_variable_latency(network_maxmin_system, action->variable, delta);
+ lmm_update_variable_latency(network_maxmin_system, action->variable,
+ delta);
}
} else if (event_type == nw_link->state_event) {
if (value > 0)
return;
}
-static surf_action_t communicate(void *src, void *dst, double size, double rate)
+static surf_action_t communicate(void *src, void *dst, double size,
+ double rate)
{
surf_action_network_CM02_t action = NULL;
network_card_CM02_t card_src = src;
network_link_CM02_t *route = ROUTE(card_src->id, card_dst->id);
int i;
- XBT_IN4("(%s,%s,%g,%g)",card_src->name,card_dst->name,size,rate);
- xbt_assert2(route_size,"You're trying to send data from %s to %s but there is no connexion between these two cards.", card_src->name, card_dst->name);
+ XBT_IN4("(%s,%s,%g,%g)", card_src->name, card_dst->name, size, rate);
+ xbt_assert2(route_size,
+ "You're trying to send data from %s to %s but there is no connexion between these two cards.",
+ card_src->name, card_dst->name);
action = xbt_new0(s_surf_action_network_CM02_t, 1);
action->generic_action.finish = -1.0;
action->generic_action.resource_type =
(surf_resource_t) surf_network_resource;
- action->suspended = 0; /* Should be useless because of the
- calloc but it seems to help valgrind... */
+ action->suspended = 0; /* Should be useless because of the
+ calloc but it seems to help valgrind... */
action->generic_action.state_set =
surf_network_resource->common_public->states.running_action_set;
action->latency += route[i]->lat_current;
action->lat_current = action->latency;
- if(action->latency>0)
- action->variable = lmm_variable_new(network_maxmin_system, action, 0.0, -1.0,
- route_size);
- else
- action->variable = lmm_variable_new(network_maxmin_system, action, 1.0, -1.0,
- route_size);
-
- if(action->rate<0) {
- if(action->lat_current>0)
+ if (action->latency > 0)
+ action->variable =
+ lmm_variable_new(network_maxmin_system, action, 0.0, -1.0,
+ route_size);
+ else
+ action->variable =
+ lmm_variable_new(network_maxmin_system, action, 1.0, -1.0,
+ route_size);
+
+ if (action->rate < 0) {
+ if (action->lat_current > 0)
lmm_update_variable_bound(network_maxmin_system, action->variable,
- SG_TCP_CTE_GAMMA / (2.0 * action->lat_current));
+ SG_TCP_CTE_GAMMA / (2.0 *
+ action->lat_current));
else
- lmm_update_variable_bound(network_maxmin_system, action->variable, -1.0);
+ lmm_update_variable_bound(network_maxmin_system, action->variable,
+ -1.0);
} else {
- if(action->lat_current>0)
+ if (action->lat_current > 0)
lmm_update_variable_bound(network_maxmin_system, action->variable,
- min(action->rate,SG_TCP_CTE_GAMMA / (2.0 * action->lat_current)));
+ min(action->rate,
+ SG_TCP_CTE_GAMMA / (2.0 *
+ action->
+ lat_current)));
else
- lmm_update_variable_bound(network_maxmin_system, action->variable, action->rate);
+ lmm_update_variable_bound(network_maxmin_system, action->variable,
+ action->rate);
}
- lmm_update_variable_latency(maxmin_system, action->variable, action->latency);
+ lmm_update_variable_latency(maxmin_system, action->variable,
+ action->latency);
for (i = 0; i < route_size; i++)
- lmm_expand(network_maxmin_system, route[i]->constraint, action->variable, 1.0);
+ lmm_expand(network_maxmin_system, route[i]->constraint,
+ action->variable, 1.0);
XBT_OUT;
return (surf_action_t) action;
}
/* returns an array of network_link_CM02_t */
-static const void** get_route(void *src, void *dst) {
+static const void **get_route(void *src, void *dst)
+{
network_card_CM02_t card_src = src;
network_card_CM02_t card_dst = dst;
- return (const void**) ROUTE(card_src->id, card_dst->id);
+ return (const void **) ROUTE(card_src->id, card_dst->id);
}
-static int get_route_size(void *src, void *dst) {
+static int get_route_size(void *src, void *dst)
+{
network_card_CM02_t card_src = src;
network_card_CM02_t card_dst = dst;
return ROUTE_SIZE(card_src->id, card_dst->id);
}
-static const char *get_link_name(const void *link) {
+static const char *get_link_name(const void *link)
+{
return ((network_link_CM02_t) link)->name;
}
-static double get_link_bandwidth(const void *link) {
+static double get_link_bandwidth(const void *link)
+{
return ((network_link_CM02_t) link)->bw_current;
}
-static double get_link_latency(const void *link) {
- return ((network_link_CM02_t) link)->lat_current;
+static double get_link_latency(const void *link)
+{
+ return ((network_link_CM02_t) link)->lat_current;
}
static void action_suspend(surf_action_t action)
{
((surf_action_network_CM02_t) action)->suspended = 1;
lmm_update_variable_weight(network_maxmin_system,
- ((surf_action_network_CM02_t) action)->variable, 0.0);
+ ((surf_action_network_CM02_t) action)->
+ variable, 0.0);
}
static void action_resume(surf_action_t action)
{
- if(((surf_action_network_CM02_t) action)->suspended) {
+ if (((surf_action_network_CM02_t) action)->suspended) {
lmm_update_variable_weight(network_maxmin_system,
- ((surf_action_network_CM02_t) action)->variable,
- ((surf_action_network_CM02_t) action)->lat_current);
+ ((surf_action_network_CM02_t) action)->
+ variable,
+ ((surf_action_network_CM02_t) action)->
+ lat_current);
((surf_action_network_CM02_t) action)->suspended = 0;
}
}
static void finalize(void)
{
- int i,j;
+ int i, j;
xbt_dict_free(&network_card_set);
xbt_dict_free(&network_link_set);
surf_network_resource = NULL;
loopback = NULL;
- for (i = 0; i < card_number; i++)
- for (j = 0; j < card_number; j++)
- free(ROUTE(i,j));
+ for (i = 0; i < card_number; i++)
+ for (j = 0; j < card_number; j++)
+ free(ROUTE(i, j));
free(routing_table);
routing_table = NULL;
free(routing_table_size);
surf_network_resource->common_public->action_recycle = action_recycle;
surf_network_resource->common_public->action_change_state =
action_change_state;
- surf_network_resource->common_public->action_set_data = surf_action_set_data;
+ surf_network_resource->common_public->action_set_data =
+ surf_action_set_data;
surf_network_resource->common_public->name = "network";
surf_network_resource->common_private->resource_used = resource_used;
surf_network_resource->common_public->suspend = action_suspend;
surf_network_resource->common_public->resume = action_resume;
surf_network_resource->common_public->is_suspended = action_is_suspended;
- surf_cpu_resource->common_public->set_max_duration = action_set_max_duration;
+ surf_cpu_resource->common_public->set_max_duration =
+ action_set_max_duration;
surf_network_resource->extension_public->communicate = communicate;
surf_network_resource->extension_public->get_route = get_route;
surf_network_resource->extension_public->get_route_size = get_route_size;
surf_network_resource->extension_public->get_link_name = get_link_name;
- surf_network_resource->extension_public->get_link_bandwidth = get_link_bandwidth;
- surf_network_resource->extension_public->get_link_latency = get_link_latency;
+ surf_network_resource->extension_public->get_link_bandwidth =
+ get_link_bandwidth;
+ surf_network_resource->extension_public->get_link_latency =
+ get_link_latency;
network_link_set = xbt_dict_new();
network_card_set = xbt_dict_new();
- if(!network_maxmin_system)
+ if (!network_maxmin_system)
network_maxmin_system = lmm_system_new();
}
parse_file(filename);
xbt_dynar_push(resource_list, &surf_network_resource);
- lmm_set_default_protocol_function(func_reno_f, func_reno_fp, func_reno_fpi);
+ lmm_set_default_protocol_function(func_reno_f, func_reno_fp,
+ func_reno_fpi);
network_solve = lagrange_solve;
update_resource_description(surf_network_resource_description,
parse_file(filename);
xbt_dynar_push(resource_list, &surf_network_resource);
- lmm_set_default_protocol_function(func_vegas_f, func_vegas_fp, func_vegas_fpi);
+ lmm_set_default_protocol_function(func_vegas_f, func_vegas_fp,
+ func_vegas_fpi);
network_solve = lagrange_solve;
update_resource_description(surf_network_resource_description,
/* Free memory for a network link */
static void network_link_free(void *nw_link)
{
- free(((network_link_GTNETS_t)nw_link)->name);
+ free(((network_link_GTNETS_t) nw_link)->name);
free(nw_link);
}
/* name: some name for the link, from the XML */
/* bw: The bandwidth value */
/* lat: The latency value */
-static void network_link_new(char *name,
- double bw,
- double lat)
+static void network_link_new(char *name, double bw, double lat)
{
- static int link_count=-1;
+ static int link_count = -1;
network_link_GTNETS_t gtnets_link;
/* KF: Check that the link wasn't added before */
/* KF: Add the link to the GTNetS simulation */
if (gtnets_add_link(link_count, bw, lat)) {
- xbt_assert0(0,"Cannot create GTNetS link");
+ xbt_assert0(0, "Cannot create GTNetS link");
}
/* KF: Insert entry in the dictionary */
- gtnets_link = xbt_new0(s_network_link_GTNETS_t,1);
+ gtnets_link = xbt_new0(s_network_link_GTNETS_t, 1);
gtnets_link->name = name;
gtnets_link->bw_current = bw;
gtnets_link->lat_current = lat;
/* free the network card */
static void network_card_free(void *nw_card)
{
- free(((network_card_GTNETS_t)nw_card)->name);
+ free(((network_card_GTNETS_t) nw_card)->name);
free(nw_card);
}
/* Instantiate a new network card: MODIFYED BY KF */
static int network_card_new(const char *name)
{
- static int card_count=-1;
+ static int card_count = -1;
- /* KF: Check that we haven't seen the network card before */
- network_card_GTNETS_t card = xbt_dict_get_or_null(network_card_set, name);
+ /* KF: Check that we haven't seen the network card before */
+ network_card_GTNETS_t card =
+ xbt_dict_get_or_null(network_card_set, name);
- if (!card){
+ if (!card) {
/* KF: Increment the card counter for GTNetS */
card_count++;
/* KF: just use the dictionary to map link names to link indices */
- card = xbt_new0(s_network_card_GTNETS_t,1);
+ card = xbt_new0(s_network_card_GTNETS_t, 1);
card->name = xbt_strdup(name);
card->id = card_count;
xbt_dict_set(network_card_set, name, card, network_card_free);
int i;
ROUTE_SIZE(src_id, dst_id) = nb_link;
- link_list = (ROUTE(src_id, dst_id) = xbt_new0(network_link_GTNETS_t, nb_link));
+ link_list = (ROUTE(src_id, dst_id) =
+ xbt_new0(network_link_GTNETS_t, nb_link));
for (i = 0; i < nb_link; i++) {
link_list[i] = xbt_dict_get_or_null(network_link_set, links[i]);
free(links[i]);
int *gtnets_links;
/* KF: Build the list of gtnets link IDs */
- gtnets_links = (int *)calloc(nb_link, sizeof(int));
- for (i=0; i<nb_link; i++) {
- gtnets_links[i]=
- ((network_link_GTNETS_t)(xbt_dict_get(network_link_set, links[i])))->id;
+ gtnets_links = (int *) calloc(nb_link, sizeof(int));
+ for (i = 0; i < nb_link; i++) {
+ gtnets_links[i] =
+ ((network_link_GTNETS_t)
+ (xbt_dict_get(network_link_set, links[i])))->id;
}
/* KF: Create the GTNets route */
if (gtnets_add_route(src_id, dst_id, gtnets_links, nb_link)) {
- xbt_assert0(0,"Cannot create GTNetS route");
+ xbt_assert0(0, "Cannot create GTNetS route");
}
}
/* Instantiate a new route: MODIFY BY KF */
-static void route_onehop_new(int src_id, int dst_id, char **links, int nb_link)
+static void route_onehop_new(int src_id, int dst_id, char **links,
+ int nb_link)
{
int linkid;
- if (nb_link != 1){
+ if (nb_link != 1) {
xbt_assert0(0, "In onehop_new, nb_link should be 1");
}
/* KF: Build the list of gtnets link IDs */
- linkid =
- ((network_link_GTNETS_t)(xbt_dict_get(network_link_set, links[0])))->id;
+ linkid =
+ ((network_link_GTNETS_t)
+ (xbt_dict_get(network_link_set, links[0])))->id;
/* KF: Create the GTNets route */
if (gtnets_add_onehop_route(src_id, dst_id, linkid)) {
- xbt_assert0(0,"Cannot create GTNetS route");
+ xbt_assert0(0, "Cannot create GTNetS route");
}
}
e_surf_network_link_state_t state;
name = xbt_strdup(A_surfxml_network_link_name);
- surf_parse_get_double(&bw,A_surfxml_network_link_bandwidth);
- surf_parse_get_double(&lat,A_surfxml_network_link_latency);
+ surf_parse_get_double(&bw, A_surfxml_network_link_bandwidth);
+ surf_parse_get_double(&lat, A_surfxml_network_link_latency);
state = SURF_NETWORK_LINK_ON;
/* Print values when no traces are specified */
surf_parse_get_trace(&bw_trace, A_surfxml_network_link_bandwidth_file);
surf_parse_get_trace(&lat_trace, A_surfxml_network_link_latency_file);
- surf_parse_get_trace(&state_trace,A_surfxml_network_link_state_file);
+ surf_parse_get_trace(&state_trace, A_surfxml_network_link_state_file);
- /*TODO Where is WARNING0 defined???*/
-#if 0
- if (bw_trace)
- WARNING0("The GTNetS network model doesn't support bandwidth state traces");
+ /*TODO Where is WARNING0 defined??? */
+#if 0
+ if (bw_trace)
+ WARNING0
+ ("The GTNetS network model doesn't support bandwidth state traces");
if (lat_trace)
- WARNING0("The GTNetS network model doesn't support latency state traces");
+ WARNING0
+ ("The GTNetS network model doesn't support latency state traces");
if (state_trace)
- WARNING0("The GTNetS network model doesn't support link state traces");
+ WARNING0
+ ("The GTNetS network model doesn't support link state traces");
#endif
}
/* KF: Create the GTNets router */
if (gtnets_add_router(id)) {
- xbt_assert0(0,"Cannot add GTNetS router");
+ xbt_assert0(0, "Cannot add GTNetS router");
}
}
{
/* Figuring out the network links */
surf_parse_reset_parser();
- ETag_surfxml_network_link_fun=parse_network_link;
+ ETag_surfxml_network_link_fun = parse_network_link;
surf_parse_open(file);
- xbt_assert1((!surf_parse()),"Parse error in %s",file);
+ xbt_assert1((!surf_parse()), "Parse error in %s", file);
surf_parse_close();
/* Figuring out the network cards used */
/* KF
- surf_parse_reset_parser();
- STag_surfxml_route_fun=parse_route_set_endpoints;
- surf_parse_open(file);
- xbt_assert1((!surf_parse()),"Parse error in %s",file);
- surf_parse_close();
- */
+ surf_parse_reset_parser();
+ STag_surfxml_route_fun=parse_route_set_endpoints;
+ surf_parse_open(file);
+ xbt_assert1((!surf_parse()),"Parse error in %s",file);
+ surf_parse_close();
+ */
/* KF: Figuring out the router (considered as part of
- network cards) used.*/
+ network cards) used. */
surf_parse_reset_parser();
- STag_surfxml_router_fun=parse_route_set_routers;
+ STag_surfxml_router_fun = parse_route_set_routers;
surf_parse_open(file);
- xbt_assert1((!surf_parse()),"Parse error in %s",file);
- surf_parse_close();
+ xbt_assert1((!surf_parse()), "Parse error in %s", file);
+ surf_parse_close();
/* Building the one-hop routes */
surf_parse_reset_parser();
- STag_surfxml_route_fun=parse_route_set_endpoints;
- ETag_surfxml_route_element_fun=parse_route_elem;
- ETag_surfxml_route_fun=parse_route_set_onehop_route;
+ STag_surfxml_route_fun = parse_route_set_endpoints;
+ ETag_surfxml_route_element_fun = parse_route_elem;
+ ETag_surfxml_route_fun = parse_route_set_onehop_route;
surf_parse_open(file);
- xbt_assert1((!surf_parse()),"Parse error in %s",file);
+ xbt_assert1((!surf_parse()), "Parse error in %s", file);
surf_parse_close();
/* Building the routes */
surf_parse_reset_parser();
- STag_surfxml_route_fun=parse_route_set_endpoints;
- ETag_surfxml_route_element_fun=parse_route_elem;
- ETag_surfxml_route_fun=parse_route_set_route;
+ STag_surfxml_route_fun = parse_route_set_endpoints;
+ ETag_surfxml_route_element_fun = parse_route_elem;
+ ETag_surfxml_route_fun = parse_route_set_route;
surf_parse_open(file);
- xbt_assert1((!surf_parse()),"Parse error in %s",file);
+ xbt_assert1((!surf_parse()), "Parse error in %s", file);
surf_parse_close();
}
/* We do not care about this: only used for traces */
static int resource_used(void *resource_id)
{
- return 0; /* We don't care */
+ return 0; /* We don't care */
}
static int action_free(surf_action_t action)
{
action->using--;
- if(!action->using) {
+ if (!action->using) {
xbt_swag_remove(action, action->state_set);
/* KF: No explicit freeing needed for GTNeTS here */
free(action);
static void action_cancel(surf_action_t action)
{
- xbt_assert0(0,"Cannot cancel GTNetS flow");
+ xbt_assert0(0, "Cannot cancel GTNetS flow");
return;
}
static void action_recycle(surf_action_t action)
{
- xbt_assert0(0,"Cannot recycle GTNetS flow");
+ xbt_assert0(0, "Cannot recycle GTNetS flow");
return;
}
#if 0
s_surf_action_network_GTNETS_t s_action;
surf_action_network_GTNETS_t action = NULL;
- xbt_swag_t running_actions = surf_network_resource->common_public->states.running_action_set;
+ xbt_swag_t running_actions =
+ surf_network_resource->common_public->states.running_action_set;
#endif
return gtnets_get_time_to_next_flow_completion();
surf_network_resource->common_public->states.running_action_set;
#endif
- double time_to_next_flow_completion = gtnets_get_time_to_next_flow_completion();
+ double time_to_next_flow_completion =
+ gtnets_get_time_to_next_flow_completion();
/* If there are no renning flows, just return */
if (time_to_next_flow_completion < 0.0) {
return;
}
- /*KF: if delta == time_to_next_flow_completion, too.*/
- if (time_to_next_flow_completion <= delta) { /* run until the first flow completes */
+ /*KF: if delta == time_to_next_flow_completion, too. */
+ if (time_to_next_flow_completion <= delta) { /* run until the first flow completes */
void **metadata;
- int i,num_flows;
+ int i, num_flows;
num_flows = 0;
if (gtnets_run_until_next_flow_completion(&metadata, &num_flows)) {
- xbt_assert0(0,"Cannot run GTNetS simulation until next flow completion");
+ xbt_assert0(0,
+ "Cannot run GTNetS simulation until next flow completion");
}
if (num_flows < 1) {
- xbt_assert0(0,"GTNetS simulation couldn't find a flow that would complete");
+ xbt_assert0(0,
+ "GTNetS simulation couldn't find a flow that would complete");
}
- for (i=0; i<num_flows; i++) {
- surf_action_network_GTNETS_t action =
- (surf_action_network_GTNETS_t)(metadata[i]);
+ for (i = 0; i < num_flows; i++) {
+ surf_action_network_GTNETS_t action =
+ (surf_action_network_GTNETS_t) (metadata[i]);
action->generic_action.remains = 0;
- action->generic_action.finish = now + time_to_next_flow_completion;
+ action->generic_action.finish = now + time_to_next_flow_completion;
action_change_state((surf_action_t) action, SURF_ACTION_DONE);
/* TODO: Anything else here? */
}
- } else { /* run for a given number of seconds */
+ } else { /* run for a given number of seconds */
if (gtnets_run(delta)) {
- xbt_assert0(0,"Cannot run GTNetS simulation");
+ xbt_assert0(0, "Cannot run GTNetS simulation");
}
}
-
+
return;
}
tmgr_trace_event_t event_type,
double value)
{
- xbt_assert0(0,"Cannot update resource state for GTNetS simulation");
+ xbt_assert0(0, "Cannot update resource state for GTNetS simulation");
return;
}
/* KF: Rate not supported */
-static surf_action_t communicate(void *src, void *dst, double size, double rate)
+static surf_action_t communicate(void *src, void *dst, double size,
+ double rate)
{
surf_action_network_GTNETS_t action = NULL;
network_card_GTNETS_t card_src = src;
action = xbt_new0(s_surf_action_network_GTNETS_t, 1);
- action->generic_action.using = 1;
+ action->generic_action.using = 1;
action->generic_action.cost = size;
action->generic_action.remains = size;
/* Max durations are not supported */
action->generic_action.max_duration = NO_MAX_DURATION;
- action->generic_action.start = surf_get_clock();
- action->generic_action.finish = -1.0;
+ action->generic_action.start = surf_get_clock();
+ action->generic_action.finish = -1.0;
action->generic_action.resource_type =
(surf_resource_t) surf_network_resource;
xbt_swag_insert(action, action->generic_action.state_set);
/* KF: Add a flow to the GTNets Simulation, associated to this action */
- if (gtnets_create_flow(card_src->id, card_dst->id, size, (void *)action) < 0) {
- xbt_assert2(0,"Not route between host %s and host %s", card_src->name, card_dst->name);
+ if (gtnets_create_flow(card_src->id, card_dst->id, size, (void *) action)
+ < 0) {
+ xbt_assert2(0, "Not route between host %s and host %s", card_src->name,
+ card_dst->name);
}
return (surf_action_t) action;
/* Suspend a flow() */
static void action_suspend(surf_action_t action)
{
- xbt_assert0(0,"action_suspend() not supported for the GTNets network model");
+ xbt_assert0(0,
+ "action_suspend() not supported for the GTNets network model");
}
/* Resume a flow() */
static void action_resume(surf_action_t action)
{
- xbt_assert0(0,"action_resume() not supported for the GTNets network model");
+ xbt_assert0(0,
+ "action_resume() not supported for the GTNets network model");
}
/* Test whether a flow is suspended */
static void finalize(void)
{
#if 0
- int i,j;
+ int i, j;
#endif
xbt_dict_free(&network_card_set);
xbt_dict_free(&network_link_set);
surf_network_resource = NULL;
#if 0
- for (i = 0; i < card_number; i++)
- for (j = 0; j < card_number; j++)
- free(ROUTE(i,j));
+ for (i = 0; i < card_number; i++)
+ for (j = 0; j < card_number; j++)
+ free(ROUTE(i, j));
free(routing_table);
routing_table = NULL;
free(routing_table_size);
surf_network_resource->common_public->action_recycle = action_recycle;
surf_network_resource->common_public->action_change_state =
action_change_state;
- surf_network_resource->common_public->action_set_data = surf_action_set_data;
+ surf_network_resource->common_public->action_set_data =
+ surf_action_set_data;
surf_network_resource->common_public->name = "network";
surf_network_resource->common_private->resource_used = resource_used;
#include <declarations.h>
-static void create_cross_link(struct constraintmatrix *myconstraints, int k);
+static void create_cross_link(struct constraintmatrix *myconstraints,
+ int k);
-static void addentry(struct constraintmatrix *constraints,
- struct blockmatrix *, int matno, int blkno, int indexi, int indexj, double ent, int blocksize);
+static void addentry(struct constraintmatrix *constraints,
+ struct blockmatrix *, int matno, int blkno,
+ int indexi, int indexj, double ent, int blocksize);
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_sdp, surf,
"Logging specific to SURF (sdp)");
XBT_LOG_NEW_SUBCATEGORY(surf_sdp_out, surf,
- "Logging specific to SURF (sdp)");
+ "Logging specific to SURF (sdp)");
/*
########################################################################
######################## Simple Proportionnal fairness #################
//typedef struct lmm_system {
// int modified;
-// s_xbt_swag_t variable_set; /* a list of lmm_variable_t */
-// s_xbt_swag_t constraint_set; /* a list of lmm_constraint_t */
-// s_xbt_swag_t active_constraint_set; /* a list of lmm_constraint_t */
-// s_xbt_swag_t saturated_variable_set; /* a list of lmm_variable_t */
-// s_xbt_swag_t saturated_constraint_set; /* a list of lmm_constraint_t_t */
+// s_xbt_swag_t variable_set; /* a list of lmm_variable_t */
+// s_xbt_swag_t constraint_set; /* a list of lmm_constraint_t */
+// s_xbt_swag_t active_constraint_set; /* a list of lmm_constraint_t */
+// s_xbt_swag_t saturated_variable_set; /* a list of lmm_variable_t */
+// s_xbt_swag_t saturated_constraint_set; /* a list of lmm_constraint_t_t */
// xbt_mallocator_t variable_mallocator;
//} s_lmm_system_t;
/*
* SDP mapping variables.
*/
- int K=0;
+ int K = 0;
int nb_var = 0;
int nb_cnsts = 0;
int flows = 0;
int links = 0;
- int nb_cnsts_capacity=0;
- int nb_cnsts_struct=0;
- int nb_cnsts_positivy=0;
- int nb_cnsts_latency=0;
- int block_num=0;
- int block_size;
- int total_block_size=0;
- int *isdiag=NULL;
+ int nb_cnsts_capacity = 0;
+ int nb_cnsts_struct = 0;
+ int nb_cnsts_positivy = 0;
+ int nb_cnsts_latency = 0;
+ int block_num = 0;
+ int block_size;
+ int total_block_size = 0;
+ int *isdiag = NULL;
// FILE *sdpout = fopen("SDPA-printf.tmp","w");
int blocksz = 0;
double *tempdiag = NULL;
- int matno=0;
- int i=0;
- int j=0;
- int k=0;
-
+ int matno = 0;
+ int i = 0;
+ int j = 0;
+ int k = 0;
+
/*
* CSDP library specific variables.
*/
struct blockmatrix C;
- struct blockmatrix X,Z;
+ struct blockmatrix X, Z;
double *y;
double pobj, dobj;
double *a;
- struct constraintmatrix *constraints;
-
+ struct constraintmatrix *constraints;
+
/*
* Classic maxmin variables.
*/
char *tmp = NULL;
FILE *stdout_sav;
int ret;
-
- if ( !(sys->modified))
+
+ if (!(sys->modified))
return;
/*
* Associate an index in the swag variables.
*/
var_list = &(sys->variable_set);
- i=0;
+ i = 0;
xbt_swag_foreach(var, var_list) {
- if(var->weight != 0.0) i++;
+ if (var->weight != 0.0)
+ i++;
}
- flows=i;
+ flows = i;
DEBUG1("Variable set : %d", xbt_swag_size(var_list));
DEBUG1("Flows : %d", flows);
- if(flows == 0){
+ if (flows == 0) {
return;
}
xbt_swag_foreach(var, var_list) {
var->value = 0.0;
- if(var->weight) {
+ if (var->weight) {
var->index = i--;
}
}
- cnst_list=&(sys->active_constraint_set);
+ cnst_list = &(sys->active_constraint_set);
DEBUG1("Active constraints : %d", xbt_swag_size(cnst_list));
DEBUG1("Links : %d", links);
/*
* This number is found based on the tree structure explained on top.
*/
- tmp_k = (double) log((double)flows)/log(2.0);
+ tmp_k = (double) log((double) flows) / log(2.0);
K = (int) ceil(tmp_k);
//xbt_assert1(K!=0, "Invalide value of K (=%d) aborting.", K);
-
+
/*
* The number of variables in the SDP program.
*/
- nb_var = get_y(K, pow(2,K));
+ nb_var = get_y(K, pow(2, K));
DEBUG1("Number of variables in the SDP program : %d", nb_var);
-
-
+
+
/*
* Find the size of each group of constraints.
*/
- nb_cnsts_capacity = links + ((int)pow(2,K)) - flows;
- nb_cnsts_struct = (int)pow(2,K) - 1;
- nb_cnsts_positivy = (int)pow(2,K);
- nb_cnsts_latency = nb_var;
+ nb_cnsts_capacity = links + ((int) pow(2, K)) - flows;
+ nb_cnsts_struct = (int) pow(2, K) - 1;
+ nb_cnsts_positivy = (int) pow(2, K);
+ nb_cnsts_latency = nb_var;
/*
* The total number of constraints.
*/
- nb_cnsts = nb_cnsts_capacity + nb_cnsts_struct + nb_cnsts_positivy + nb_cnsts_latency;
- CDEBUG1(surf_sdp_out,"Number of constraints = %d", nb_cnsts);
+ nb_cnsts =
+ nb_cnsts_capacity + nb_cnsts_struct + nb_cnsts_positivy +
+ nb_cnsts_latency;
+ CDEBUG1(surf_sdp_out, "Number of constraints = %d", nb_cnsts);
DEBUG1("Number of constraints in the SDP program : %d", nb_cnsts);
/*
* Keep track of which blocks have off diagonal entries.
*/
- isdiag=(int *)calloc((nb_cnsts+1), sizeof(int));
- for (i=1; i<=nb_cnsts; i++)
- isdiag[i]=1;
+ isdiag = (int *) calloc((nb_cnsts + 1), sizeof(int));
+ for (i = 1; i <= nb_cnsts; i++)
+ isdiag[i] = 1;
C.nblocks = nb_cnsts;
- C.blocks = (struct blockrec *) calloc((C.nblocks+1),sizeof(struct blockrec));
- constraints = (struct constraintmatrix *)calloc((nb_var+1),sizeof(struct constraintmatrix));
-
- for(i = 1; i <= nb_var; i++){
- constraints[i].blocks=NULL;
+ C.blocks =
+ (struct blockrec *) calloc((C.nblocks + 1), sizeof(struct blockrec));
+ constraints =
+ (struct constraintmatrix *) calloc((nb_var + 1),
+ sizeof(struct constraintmatrix));
+
+ for (i = 1; i <= nb_var; i++) {
+ constraints[i].blocks = NULL;
}
-
- a = (double *)calloc(nb_var+1, sizeof(double));
+
+ a = (double *) calloc(nb_var + 1, sizeof(double));
/*
* Block sizes.
*/
- block_num=1;
- block_size=0;
+ block_num = 1;
+ block_size = 0;
/*
* For each constraint block do.
*/
- for(i = 1; i <= nb_cnsts; i++){
-
+ for (i = 1; i <= nb_cnsts; i++) {
+
/*
* Structured blocks are size 2 and all others are size 1.
*/
- if(i <= nb_cnsts_struct){
+ if (i <= nb_cnsts_struct) {
total_block_size += block_size = 2;
DEBUG0("2 ");
- }else{
+ } else {
total_block_size += block_size = 1;
- CDEBUG0(surf_sdp_out,"1 ");
+ CDEBUG0(surf_sdp_out, "1 ");
}
-
+
/*
* All blocks are matrices.
*/
C.blocks[block_num].blockcategory = MATRIX;
C.blocks[block_num].blocksize = block_size;
- C.blocks[block_num].data.mat = (double *)calloc(block_size * block_size, sizeof(double));
-
+ C.blocks[block_num].data.mat =
+ (double *) calloc(block_size * block_size, sizeof(double));
+
block_num++;
}
- CDEBUG0(surf_sdp_out," ");
+ CDEBUG0(surf_sdp_out, " ");
/*
* Creates de objective function array.
*/
- a = (double *)calloc((nb_var+1), sizeof(double));
-
- for(i = 1; i <= nb_var; i++){
- if(get_y(0,1)==i){
+ a = (double *) calloc((nb_var + 1), sizeof(double));
+
+ for (i = 1; i <= nb_var; i++) {
+ if (get_y(0, 1) == i) {
//CDEBUG0(surf_sdp_out,"-1 ");
- a[i]=-1;
- }else{
+ a[i] = -1;
+ } else {
//CDEBUG0(surf_sdp_out,"0 ");
- a[i]=0;
+ a[i] = 0;
}
}
*/
block_num = 1;
matno = 1;
- for(k = 1; k <= K; k++){
- for(i = 1; i <= pow(2,k-1); i++){
- matno=get_y(k,2*i-1);
- CDEBUG2(surf_sdp_out,"%d %d 1 1 1", matno , block_num);
- addentry(constraints, &C, matno, block_num, 1, 1, 1.0, C.blocks[block_num].blocksize);
-
- matno=get_y(k,2*i);
- CDEBUG2(surf_sdp_out,"%d %d 2 2 1", matno , block_num);
- addentry(constraints, &C, matno, block_num, 2, 2, 1.0, C.blocks[block_num].blocksize);
-
- matno=get_y(k-1,i);
- CDEBUG2(surf_sdp_out,"%d %d 1 2 1", matno , block_num);
- addentry(constraints, &C, matno, block_num, 1, 2, 1.0, C.blocks[block_num].blocksize);
-
- matno=get_y(k-1,i);
- CDEBUG2(surf_sdp_out,"%d %d 2 1 1", matno , block_num);
- addentry(constraints, &C, matno, block_num, 2, 1, 1.0, C.blocks[block_num].blocksize);
-
+ for (k = 1; k <= K; k++) {
+ for (i = 1; i <= pow(2, k - 1); i++) {
+ matno = get_y(k, 2 * i - 1);
+ CDEBUG2(surf_sdp_out, "%d %d 1 1 1", matno, block_num);
+ addentry(constraints, &C, matno, block_num, 1, 1, 1.0,
+ C.blocks[block_num].blocksize);
+
+ matno = get_y(k, 2 * i);
+ CDEBUG2(surf_sdp_out, "%d %d 2 2 1", matno, block_num);
+ addentry(constraints, &C, matno, block_num, 2, 2, 1.0,
+ C.blocks[block_num].blocksize);
+
+ matno = get_y(k - 1, i);
+ CDEBUG2(surf_sdp_out, "%d %d 1 2 1", matno, block_num);
+ addentry(constraints, &C, matno, block_num, 1, 2, 1.0,
+ C.blocks[block_num].blocksize);
+
+ matno = get_y(k - 1, i);
+ CDEBUG2(surf_sdp_out, "%d %d 2 1 1", matno, block_num);
+ addentry(constraints, &C, matno, block_num, 2, 1, 1.0,
+ C.blocks[block_num].blocksize);
+
isdiag[block_num] = 0;
block_num++;
}
}
-
+
/*
* Capacity constraint block.
*/
xbt_swag_foreach(cnst, cnst_list) {
- CDEBUG2(surf_sdp_out,"0 %d 1 1 %f", block_num, - (cnst->bound));
- addentry(constraints, &C, 0, block_num, 1, 1, - (cnst->bound) , C.blocks[block_num].blocksize);
+ CDEBUG2(surf_sdp_out, "0 %d 1 1 %f", block_num, -(cnst->bound));
+ addentry(constraints, &C, 0, block_num, 1, 1, -(cnst->bound),
+ C.blocks[block_num].blocksize);
elem_list = &(cnst->element_set);
- xbt_swag_foreach(elem, elem_list){
- if(elem->variable->weight <=0) break;
- matno=get_y(K,elem->variable->index);
- CDEBUG3(surf_sdp_out,"%d %d 1 1 %f", matno, block_num, - (elem->value));
- addentry(constraints, &C, matno, block_num, 1, 1, - (elem->value), C.blocks[block_num].blocksize);
-
+ xbt_swag_foreach(elem, elem_list) {
+ if (elem->variable->weight <= 0)
+ break;
+ matno = get_y(K, elem->variable->index);
+ CDEBUG3(surf_sdp_out, "%d %d 1 1 %f", matno, block_num,
+ -(elem->value));
+ addentry(constraints, &C, matno, block_num, 1, 1, -(elem->value),
+ C.blocks[block_num].blocksize);
+
}
block_num++;
}
-
+
/*
* Positivy constraint blocks.
*/
- for(i = 1; i <= pow(2,K); i++){
- matno=get_y(K, i);
- CDEBUG2(surf_sdp_out,"%d %d 1 1 1", matno, block_num);
- addentry(constraints, &C, matno, block_num, 1, 1, 1.0, C.blocks[block_num].blocksize);
+ for (i = 1; i <= pow(2, K); i++) {
+ matno = get_y(K, i);
+ CDEBUG2(surf_sdp_out, "%d %d 1 1 1", matno, block_num);
+ addentry(constraints, &C, matno, block_num, 1, 1, 1.0,
+ C.blocks[block_num].blocksize);
block_num++;
}
/*
*/
xbt_swag_foreach(var, var_list) {
var->value = 0.0;
- if(var->weight && var->bound > 0) {
- matno = get_y(K,var->index);
- CDEBUG3(surf_sdp_out,"%d %d 1 1 %f", matno, block_num, var->bound);
- addentry(constraints, &C, matno, block_num, 1, 1, var->bound, C.blocks[block_num].blocksize);
+ if (var->weight && var->bound > 0) {
+ matno = get_y(K, var->index);
+ CDEBUG3(surf_sdp_out, "%d %d 1 1 %f", matno, block_num, var->bound);
+ addentry(constraints, &C, matno, block_num, 1, 1, var->bound,
+ C.blocks[block_num].blocksize);
}
}
* At this point, we'll stop to recognize whether any of the blocks
* are "hidden LP blocks" and correct the block type if needed.
*/
- for (i=1; i<=nb_cnsts; i++){
- if ((C.blocks[i].blockcategory != DIAG) &&
- (isdiag[i]==1) && (C.blocks[i].blocksize > 1)){
+ for (i = 1; i <= nb_cnsts; i++) {
+ if ((C.blocks[i].blockcategory != DIAG) &&
+ (isdiag[i] == 1) && (C.blocks[i].blocksize > 1)) {
/*
* We have a hidden diagonal block!
*/
-
- blocksz=C.blocks[i].blocksize;
- tempdiag=(double *)calloc((blocksz+1), sizeof(double));
- for (j=1; j<=blocksz; j++)
- tempdiag[j]=C.blocks[i].data.mat[ijtok(j,j,blocksz)];
+
+ blocksz = C.blocks[i].blocksize;
+ tempdiag = (double *) calloc((blocksz + 1), sizeof(double));
+ for (j = 1; j <= blocksz; j++)
+ tempdiag[j] = C.blocks[i].data.mat[ijtok(j, j, blocksz)];
free(C.blocks[i].data.mat);
- C.blocks[i].data.vec=tempdiag;
- C.blocks[i].blockcategory=DIAG;
+ C.blocks[i].data.vec = tempdiag;
+ C.blocks[i].blockcategory = DIAG;
};
};
-
-
+
+
/*
* Next, setup issparse and NULL out all nextbyblock pointers.
*/
- p=NULL;
- for (i=1; i<=k; i++) {
- p=constraints[i].blocks;
- while (p != NULL){
- /*
- * First, set issparse.
- */
- if (((p->numentries) > 0.25*(p->blocksize)) && ((p->numentries) > 15)){
- p->issparse=0;
- }else{
- p->issparse=1;
- };
-
- if (C.blocks[p->blocknum].blockcategory == DIAG)
- p->issparse=1;
-
- /*
- * Setup the cross links.
- */
-
- p->nextbyblock=NULL;
- p=p->next;
+ p = NULL;
+ for (i = 1; i <= k; i++) {
+ p = constraints[i].blocks;
+ while (p != NULL) {
+ /*
+ * First, set issparse.
+ */
+ if (((p->numentries) > 0.25 * (p->blocksize))
+ && ((p->numentries) > 15)) {
+ p->issparse = 0;
+ } else {
+ p->issparse = 1;
+ };
+
+ if (C.blocks[p->blocknum].blockcategory == DIAG)
+ p->issparse = 1;
+
+ /*
+ * Setup the cross links.
+ */
+
+ p->nextbyblock = NULL;
+ p = p->next;
};
};
* Create cross link reference.
*/
create_cross_link(constraints, nb_var);
-
-
+
+
/*
* Debuging print problem in SDPA format.
*/
- if(XBT_LOG_ISENABLED(surf_sdp, xbt_log_priority_debug)) {
+ if (XBT_LOG_ISENABLED(surf_sdp, xbt_log_priority_debug)) {
DEBUG0("Printing SDPA...");
- tmp=strdup("SURF-PROPORTIONNAL.sdpa");
- write_prob(tmp,total_block_size,nb_var,C,a,constraints);
+ tmp = strdup("SURF-PROPORTIONNAL.sdpa");
+ write_prob(tmp, total_block_size, nb_var, C, a, constraints);
}
/*
* Initialize parameters.
*/
DEBUG0("Initializing solution...");
- initsoln(total_block_size, nb_var, C, a, constraints, &X, &y, &Z);
-
+ initsoln(total_block_size, nb_var, C, a, constraints, &X, &y, &Z);
+
/*
* Call the solver.
*/
DEBUG0("Calling the solver...");
- stdout_sav=stdout;
- stdout=fopen("/dev/null","w");
- ret = easy_sdp(total_block_size, nb_var, C, a, constraints, 0.0, &X, &y, &Z, &pobj, &dobj);
+ stdout_sav = stdout;
+ stdout = fopen("/dev/null", "w");
+ ret =
+ easy_sdp(total_block_size, nb_var, C, a, constraints, 0.0, &X, &y,
+ &Z, &pobj, &dobj);
fclose(stdout);
- stdout=stdout_sav;
+ stdout = stdout_sav;
- switch(ret){
+ switch (ret) {
case 0:
- case 1: DEBUG0("SUCCESS The problem is primal infeasible");
- break;
+ case 1:
+ DEBUG0("SUCCESS The problem is primal infeasible");
+ break;
- case 2: DEBUG0("SUCCESS The problem is dual infeasible");
- break;
-
- case 3: DEBUG0("Partial SUCCESS A solution has been found, but full accuracy was not achieved. One or more of primal infeasibility, dual infeasibility, or relative duality gap are larger than their tolerances, but by a factor of less than 1000.");
- break;
+ case 2:
+ DEBUG0("SUCCESS The problem is dual infeasible");
+ break;
- case 4: DEBUG0("Failure. Maximum number of iterations reached.");
- break;
+ case 3:
+ DEBUG0
+ ("Partial SUCCESS A solution has been found, but full accuracy was not achieved. One or more of primal infeasibility, dual infeasibility, or relative duality gap are larger than their tolerances, but by a factor of less than 1000.");
+ break;
- case 5: DEBUG0("Failure. Stuck at edge of primal feasibility.");
- break;
+ case 4:
+ DEBUG0("Failure. Maximum number of iterations reached.");
+ break;
+
+ case 5:
+ DEBUG0("Failure. Stuck at edge of primal feasibility.");
+ break;
}
- if(XBT_LOG_ISENABLED(surf_sdp, xbt_log_priority_debug)) {
- tmp=strdup("SURF-PROPORTIONNAL.sol");
- write_sol(tmp,total_block_size, nb_var, X, y, Z);
+ if (XBT_LOG_ISENABLED(surf_sdp, xbt_log_priority_debug)) {
+ tmp = strdup("SURF-PROPORTIONNAL.sol");
+ write_sol(tmp, total_block_size, nb_var, X, y, Z);
}
/*
elem_list = &(cnst->element_set);
xbt_swag_foreach(elem, elem_list) {
- if(elem->variable->weight <=0) break;
-
- i = (int)get_y(K, elem->variable->index);
- elem->variable->value = y[i];
-
+ if (elem->variable->weight <= 0)
+ break;
+
+ i = (int) get_y(K, elem->variable->index);
+ elem->variable->value = y[i];
+
}
}
* Free up memory.
*/
free_prob(total_block_size, nb_var, C, a, constraints, X, y, Z);
-
+
free(isdiag);
free(tempdiag);
free(tmp);
-
+
sys->modified = 0;
-
- if(XBT_LOG_ISENABLED(surf_sdp, xbt_log_priority_debug)) {
+
+ if (XBT_LOG_ISENABLED(surf_sdp, xbt_log_priority_debug)) {
lmm_print(sys);
}
-
+
}
/*
* Create the cross_link reference in order to have a byblock list.
*/
-void create_cross_link(struct constraintmatrix *myconstraints, int k){
+void create_cross_link(struct constraintmatrix *myconstraints, int k)
+{
int i, j;
int blk;
/*
* Now, cross link.
*/
- prev=NULL;
- for (i=1; i<=k; i++){
- p=myconstraints[i].blocks;
- while (p != NULL){
- if (p->nextbyblock == NULL){
- blk=p->blocknum;
-
+ prev = NULL;
+ for (i = 1; i <= k; i++) {
+ p = myconstraints[i].blocks;
+ while (p != NULL) {
+ if (p->nextbyblock == NULL) {
+ blk = p->blocknum;
+
/*
* link in the remaining blocks.
*/
- for (j=i+1; j<=k; j++){
- q=myconstraints[j].blocks;
-
- while (q != NULL){
- if (q->blocknum == p->blocknum){
- if (p->nextbyblock == NULL){
- p->nextbyblock=q;
- q->nextbyblock=NULL;
- prev=q;
- }
- else{
- prev->nextbyblock=q;
- q->nextbyblock=NULL;
- prev=q;
+ for (j = i + 1; j <= k; j++) {
+ q = myconstraints[j].blocks;
+
+ while (q != NULL) {
+ if (q->blocknum == p->blocknum) {
+ if (p->nextbyblock == NULL) {
+ p->nextbyblock = q;
+ q->nextbyblock = NULL;
+ prev = q;
+ } else {
+ prev->nextbyblock = q;
+ q->nextbyblock = NULL;
+ prev = q;
}
break;
}
- q=q->next;
+ q = q->next;
}
}
}
- p=p->next;
+ p = p->next;
}
}
}
-
-void addentry(struct constraintmatrix *constraints,
- struct blockmatrix *C,
+
+void addentry(struct constraintmatrix *constraints,
+ struct blockmatrix *C,
int matno,
- int blkno,
- int indexi,
- int indexj,
- double ent,
- int blocksize)
+ int blkno, int indexi, int indexj, double ent, int blocksize)
{
struct sparseblock *p;
struct sparseblock *p_sav;
- p=constraints[matno].blocks;
-
+ p = constraints[matno].blocks;
+
if (matno != 0.0) {
- if (p == NULL){
+ if (p == NULL) {
/*
* We haven't yet allocated any blocks.
*/
- p=(struct sparseblock *)calloc(1, sizeof(struct sparseblock));
-
+ p = (struct sparseblock *) calloc(1, sizeof(struct sparseblock));
+
//two entries because this library ignores indices starting in zerox
- p->constraintnum=matno;
- p->blocknum=blkno;
- p->numentries=1;
- p->next=NULL;
-
- p->entries=calloc(p->numentries+1, sizeof(double));
- p->iindices=calloc(p->numentries+1, sizeof(int));
- p->jindices=calloc(p->numentries+1, sizeof(int));
-
- p->entries[p->numentries]=ent;
- p->iindices[p->numentries]=indexi;
- p->jindices[p->numentries]=indexj;
-
- p->blocksize=blocksize;
-
- constraints[matno].blocks=p;
+ p->constraintnum = matno;
+ p->blocknum = blkno;
+ p->numentries = 1;
+ p->next = NULL;
+
+ p->entries = calloc(p->numentries + 1, sizeof(double));
+ p->iindices = calloc(p->numentries + 1, sizeof(int));
+ p->jindices = calloc(p->numentries + 1, sizeof(int));
+
+ p->entries[p->numentries] = ent;
+ p->iindices[p->numentries] = indexi;
+ p->jindices[p->numentries] = indexj;
+
+ p->blocksize = blocksize;
+
+ constraints[matno].blocks = p;
} else {
/*
* We have some existing blocks. See whether this block is already
* in the chain.
*/
- while (p != NULL){
- if (p->blocknum == blkno){
+ while (p != NULL) {
+ if (p->blocknum == blkno) {
/*
* Found the right block.
*/
- p->constraintnum=matno;
- p->blocknum=blkno;
- p->numentries=p->numentries+1;
-
- p->entries = realloc(p->entries, (p->numentries+1) * sizeof(double) );
- p->iindices = realloc(p->iindices, (p->numentries+1) * sizeof(int) );
- p->jindices = realloc(p->jindices, (p->numentries+1) * sizeof(int) );
-
- p->entries[p->numentries]=ent;
- p->iindices[p->numentries]=indexi;
- p->jindices[p->numentries]=indexj;
-
+ p->constraintnum = matno;
+ p->blocknum = blkno;
+ p->numentries = p->numentries + 1;
+
+ p->entries =
+ realloc(p->entries, (p->numentries + 1) * sizeof(double));
+ p->iindices =
+ realloc(p->iindices, (p->numentries + 1) * sizeof(int));
+ p->jindices =
+ realloc(p->jindices, (p->numentries + 1) * sizeof(int));
+
+ p->entries[p->numentries] = ent;
+ p->iindices[p->numentries] = indexi;
+ p->jindices[p->numentries] = indexj;
+
return;
}
- p_sav=p;
- p=p->next;
+ p_sav = p;
+ p = p->next;
}
/*
* If we get here, we have a non-empty structure but not the right block
* inside hence create a new structure.
*/
-
- p=(struct sparseblock *)calloc(1, sizeof(struct sparseblock));
-
+
+ p = (struct sparseblock *) calloc(1, sizeof(struct sparseblock));
+
//two entries because this library ignores indices starting in zerox
- p->constraintnum=matno;
- p->blocknum=blkno;
- p->numentries=1;
- p->next=NULL;
-
- p->entries=calloc(p->numentries+1, sizeof(double));
- p->iindices=calloc(p->numentries+1, sizeof(int));
- p->jindices=calloc(p->numentries+1, sizeof(int));
-
- p->entries[p->numentries]=ent;
- p->iindices[p->numentries]=indexi;
- p->jindices[p->numentries]=indexj;
-
- p->blocksize=blocksize;
-
- p_sav->next=p;
+ p->constraintnum = matno;
+ p->blocknum = blkno;
+ p->numentries = 1;
+ p->next = NULL;
+
+ p->entries = calloc(p->numentries + 1, sizeof(double));
+ p->iindices = calloc(p->numentries + 1, sizeof(int));
+ p->jindices = calloc(p->numentries + 1, sizeof(int));
+
+ p->entries[p->numentries] = ent;
+ p->iindices[p->numentries] = indexi;
+ p->jindices[p->numentries] = indexj;
+
+ p->blocksize = blocksize;
+
+ p_sav->next = p;
}
} else {
- if (ent != 0.0){
- int blksz=C->blocks[blkno].blocksize;
- if (C->blocks[blkno].blockcategory == DIAG){
- C->blocks[blkno].data.vec[indexi]=ent;
- }else{
- C->blocks[blkno].data.mat[ijtok(indexi,indexj,blksz)]=ent;
- C->blocks[blkno].data.mat[ijtok(indexj,indexi,blksz)]=ent;
- };
+ if (ent != 0.0) {
+ int blksz = C->blocks[blkno].blocksize;
+ if (C->blocks[blkno].blockcategory == DIAG) {
+ C->blocks[blkno].data.vec[indexi] = ent;
+ } else {
+ C->blocks[blkno].data.mat[ijtok(indexi, indexj, blksz)] = ent;
+ C->blocks[blkno].data.mat[ijtok(indexj, indexi, blksz)] = ent;
+ };
};
-
+
}
}
-
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_kernel, surf,
"Logging specific to SURF (kernel)");
-int use_sdp_solver=0;
-int use_lagrange_solver=0;
+int use_sdp_solver = 0;
+int use_lagrange_solver = 0;
/* Additional declarations for Windows potability. */
#ifndef MAX_DRIVE
#define MAX_DRIVE 26
-#endif
+#endif
#ifdef _WIN32
#include <windows.h>
-static const char* disk_drives_letter_table[MAX_DRIVE] =
-{
- "A:\\",
- "B:\\",
- "C:\\",
- "D:\\",
- "E:\\",
- "F:\\",
- "G:\\",
- "H:\\",
- "I:\\",
- "J:\\",
- "K:\\",
- "L:\\",
- "M:\\",
- "N:\\",
- "O:\\",
- "P:\\",
- "Q:\\",
- "R:\\",
- "S:\\",
- "T:\\",
- "U:\\",
- "V:\\",
- "W:\\",
- "X:\\",
- "Y:\\",
- "Z:\\"
+static const char *disk_drives_letter_table[MAX_DRIVE] = {
+ "A:\\",
+ "B:\\",
+ "C:\\",
+ "D:\\",
+ "E:\\",
+ "F:\\",
+ "G:\\",
+ "H:\\",
+ "I:\\",
+ "J:\\",
+ "K:\\",
+ "L:\\",
+ "M:\\",
+ "N:\\",
+ "O:\\",
+ "P:\\",
+ "Q:\\",
+ "R:\\",
+ "S:\\",
+ "T:\\",
+ "U:\\",
+ "V:\\",
+ "W:\\",
+ "X:\\",
+ "Y:\\",
+ "Z:\\"
};
-#endif /* #ifdef _WIN32 */
+#endif /* #ifdef _WIN32 */
/*
* Returns the initial path. On Windows the initial path is
* case the function returns "./" that represents the current
* directory on Unix/Linux platforms.
*/
-
-const char* __surf_get_initial_path(void)
+
+const char *__surf_get_initial_path(void)
{
- #ifdef _WIN32
- unsigned i;
- char current_directory[MAX_PATH + 1] = {0};
- unsigned int len = GetCurrentDirectory(MAX_PATH + 1,current_directory);
- char root[4] = {0};
+#ifdef _WIN32
+ unsigned i;
+ char current_directory[MAX_PATH + 1] = { 0 };
+ unsigned int len = GetCurrentDirectory(MAX_PATH + 1, current_directory);
+ char root[4] = { 0 };
- if(!len)
- return NULL;
+ if (!len)
+ return NULL;
- strncpy(root,current_directory,3);
+ strncpy(root, current_directory, 3);
- for(i = 0; i<MAX_DRIVE;i++)
- {
- if(toupper(root[0]) == disk_drives_letter_table[i][0])
- return disk_drives_letter_table[i];
- }
+ for (i = 0; i < MAX_DRIVE; i++) {
+ if (toupper(root[0]) == disk_drives_letter_table[i][0])
+ return disk_drives_letter_table[i];
+ }
- return NULL;
- #else
- return "./";
- #endif
+ return NULL;
+#else
+ return "./";
+#endif
}
/* The __surf_is_absolute_file_path() returns 1 if
* file_path is a absolute file path, in the other
* case the function returns 0.
*/
-int __surf_is_absolute_file_path(const char* file_path)
+int __surf_is_absolute_file_path(const char *file_path)
{
- #ifdef _WIN32
- WIN32_FIND_DATA wfd ={0};
- HANDLE hFile = FindFirstFile(file_path,&wfd);
-
- if(INVALID_HANDLE_VALUE == hFile)
- return 0;
-
- FindClose(hFile);
- return 1;
- #else
- return (file_path[0] == '/');
- #endif
+#ifdef _WIN32
+ WIN32_FIND_DATA wfd = { 0 };
+ HANDLE hFile = FindFirstFile(file_path, &wfd);
+
+ if (INVALID_HANDLE_VALUE == hFile)
+ return 0;
+
+ FindClose(hFile);
+ return 1;
+#else
+ return (file_path[0] == '/');
+#endif
}
typedef struct surf_resource_object {
lmm_system_t maxmin_system = NULL;
xbt_dynar_t surf_path = NULL;
const char *surf_action_state_names[6] = {
- "SURF_ACTION_READY",
- "SURF_ACTION_RUNNING",
- "SURF_ACTION_FAILED",
- "SURF_ACTION_DONE",
- "SURF_ACTION_TO_FREE",
+ "SURF_ACTION_READY",
+ "SURF_ACTION_RUNNING",
+ "SURF_ACTION_FAILED",
+ "SURF_ACTION_DONE",
+ "SURF_ACTION_TO_FREE",
"SURF_ACTION_NOT_IN_THE_SYSTEM"
};
-int surf_network_resource_description_size=3
- #ifdef HAVE_GTNETS
- +1
- #endif
- #ifdef HAVE_SDP
- +1
- #endif
-;
-s_surf_resource_description_t surf_network_resource_description[]=
- {
- {"CM02",NULL,surf_network_resource_init_CM02},
+int surf_network_resource_description_size = 3
+#ifdef HAVE_GTNETS
+ + 1
+#endif
+#ifdef HAVE_SDP
+ + 1
+#endif
+ ;
+s_surf_resource_description_t surf_network_resource_description[] = {
+ {"CM02", NULL, surf_network_resource_init_CM02},
#ifdef HAVE_GTNETS
- {"GTNets",NULL,surf_network_resource_init_GTNETS},
+ {"GTNets", NULL, surf_network_resource_init_GTNETS},
#endif
#ifdef HAVE_SDP
- {"SDP",NULL,surf_network_resource_init_SDP},
+ {"SDP", NULL, surf_network_resource_init_SDP},
#endif
- {"Reno",NULL,surf_network_resource_init_Reno},
- {"Vegas",NULL,surf_network_resource_init_Vegas}
- };
-
-int surf_cpu_resource_description_size=1;
-s_surf_resource_description_t surf_cpu_resource_description[]=
- {
- {"Cas01",NULL,surf_cpu_resource_init_Cas01},
- };
-
-int surf_workstation_resource_description_size=4;
-s_surf_resource_description_t surf_workstation_resource_description[]=
- {
- {"CLM03",NULL,surf_workstation_resource_init_CLM03},
- {"KCCFLN05",NULL,surf_workstation_resource_init_KCCFLN05},
- {"compound",NULL,surf_workstation_resource_init_compound},
- {"ptask_L07",NULL,surf_workstation_resource_init_ptask_L07}
- };
-
-void update_resource_description(s_surf_resource_description_t *table,
+ {"Reno", NULL, surf_network_resource_init_Reno},
+ {"Vegas", NULL, surf_network_resource_init_Vegas}
+};
+
+int surf_cpu_resource_description_size = 1;
+s_surf_resource_description_t surf_cpu_resource_description[] = {
+ {"Cas01", NULL, surf_cpu_resource_init_Cas01},
+};
+
+int surf_workstation_resource_description_size = 4;
+s_surf_resource_description_t surf_workstation_resource_description[] = {
+ {"CLM03", NULL, surf_workstation_resource_init_CLM03},
+ {"KCCFLN05", NULL, surf_workstation_resource_init_KCCFLN05},
+ {"compound", NULL, surf_workstation_resource_init_compound},
+ {"ptask_L07", NULL, surf_workstation_resource_init_ptask_L07}
+};
+
+void update_resource_description(s_surf_resource_description_t * table,
int table_size,
- const char* name,
- surf_resource_t resource
- )
+ const char *name,
+ surf_resource_t resource)
{
int i = find_resource_description(table, table_size, name);
- table[i].resource=resource;
+ table[i].resource = resource;
}
-int find_resource_description(s_surf_resource_description_t *table,
- int table_size,
- const char* name)
+int find_resource_description(s_surf_resource_description_t * table,
+ int table_size, const char *name)
{
int i;
- char *name_list=NULL;
+ char *name_list = NULL;
- for(i=0;i<table_size;i++)
- if(!strcmp(name,table[i].name)) {
+ for (i = 0; i < table_size; i++)
+ if (!strcmp(name, table[i].name)) {
return i;
}
- name_list=strdup(table[0].name);
- for(i=1;i<table_size;i++) {
- name_list = xbt_realloc(name_list,strlen(name_list)+strlen(table[i].name)+2);
- strcat(name_list,", ");
- strcat(name_list,table[i].name);
+ name_list = strdup(table[0].name);
+ for (i = 1; i < table_size; i++) {
+ name_list =
+ xbt_realloc(name_list,
+ strlen(name_list) + strlen(table[i].name) + 2);
+ strcat(name_list, ", ");
+ strcat(name_list, table[i].name);
}
- xbt_assert2(0, "Model '%s' is invalid! Valid models are: %s.",name,name_list);
+ xbt_assert2(0, "Model '%s' is invalid! Valid models are: %s.", name,
+ name_list);
}
double generic_maxmin_share_resources(xbt_swag_t running_actions,
- size_t offset)
+ size_t offset)
{
- return generic_maxmin_share_resources2(running_actions, offset,
- maxmin_system, lmm_solve);
+ return generic_maxmin_share_resources2(running_actions, offset,
+ maxmin_system, lmm_solve);
}
double generic_maxmin_share_resources2(xbt_swag_t running_actions,
size_t offset,
lmm_system_t sys,
- void (*solve)(lmm_system_t))
+ void (*solve) (lmm_system_t))
{
surf_action_t action = NULL;
double min = -1;
double value = -1;
#define VARIABLE(action) (*((lmm_variable_t*)(((char *) (action)) + (offset))))
- xbt_assert0(solve,"Give me a real solver function!");
+ xbt_assert0(solve, "Give me a real solver function!");
solve(sys);
xbt_swag_foreach(action, running_actions) {
} else
min = action->max_duration;
- DEBUG5("Found action (%p: duration = %f, remains = %f, value = %f) ! %f",action, action->max_duration, action->remains, value, min);
+ DEBUG5("Found action (%p: duration = %f, remains = %f, value = %f) ! %f",
+ action, action->max_duration, action->remains, value, min);
for (action = xbt_swag_getNext(action, running_actions->offset);
action;
value = action->remains / value;
if (value < min) {
min = value;
- DEBUG2("Updating min (value) with %p: %f",action, min);
+ DEBUG2("Updating min (value) with %p: %f", action, min);
}
}
if ((action->max_duration >= 0) && (action->max_duration < min)) {
min = action->max_duration;
- DEBUG2("Updating min (duration) with %p: %f",action, min);
+ DEBUG2("Updating min (duration) with %p: %f", action, min);
}
}
- DEBUG1("min value : %f",min);
+ DEBUG1("min value : %f", min);
#undef VARIABLE
return min;
return SURF_ACTION_NOT_IN_THE_SYSTEM;
}
-double surf_action_get_start_time(surf_action_t action) {
+double surf_action_get_start_time(surf_action_t action)
+{
return action->start;
}
-double surf_action_get_finish_time(surf_action_t action) {
+double surf_action_get_finish_time(surf_action_t action)
+{
return action->finish;
}
XBT_OUT;
}
-void surf_action_set_data(surf_action_t action,
- void *data)
+void surf_action_set_data(surf_action_t action, void *data)
{
- action->data=data;
+ action->data = data;
}
void surf_init(int *argc, char **argv)
{
- int i,j;
+ int i, j;
char *opt;
-
- const char* initial_path;
+
+ const char *initial_path;
xbt_init(argc, argv);
if (!surf_path) {
-
- /* retrieves the current directory of the current process*/
+
+ /* retrieves the current directory of the current process */
initial_path = __surf_get_initial_path();
-
- xbt_assert0((initial_path), "__surf_get_initial_path() failed! Can't resolves current Windows directory");
-
- surf_path = xbt_dynar_new(sizeof(char*), NULL);
- xbt_dynar_push(surf_path,&initial_path);
-
- for (i=1; i<*argc; i++) {
- if (!strncmp(argv[i],"--surf-path=",strlen("--surf-path="))) {
- opt=strchr(argv[i],'=');
+
+ xbt_assert0((initial_path),
+ "__surf_get_initial_path() failed! Can't resolves current Windows directory");
+
+ surf_path = xbt_dynar_new(sizeof(char *), NULL);
+ xbt_dynar_push(surf_path, &initial_path);
+
+ for (i = 1; i < *argc; i++) {
+ if (!strncmp(argv[i], "--surf-path=", strlen("--surf-path="))) {
+ opt = strchr(argv[i], '=');
opt++;
- xbt_dynar_push(surf_path,&opt);
- /*remove this from argv*/
- for (j=i+1; j<*argc; j++) {
- argv[j-1] = argv[j];
- }
- argv[j-1] = NULL;
+ xbt_dynar_push(surf_path, &opt);
+ /*remove this from argv */
+ for (j = i + 1; j < *argc; j++) {
+ argv[j - 1] = argv[j];
+ }
+ argv[j - 1] = NULL;
(*argc)--;
- i--; /* compensate effect of next loop incrementation */
+ i--; /* compensate effect of next loop incrementation */
}
}
}
maxmin_system = lmm_system_new();
}
-static char* path_name = NULL;
+static char *path_name = NULL;
FILE *surf_fopen(const char *name, const char *mode)
{
- int i;
- char* path = NULL;
+ int i;
+ char *path = NULL;
FILE *file = NULL;
- int path_name_len = 0; /* don't count '\0' */
+ int path_name_len = 0; /* don't count '\0' */
xbt_assert0(name, "Need a non-NULL file name");
- xbt_assert0(surf_path,"surf_init has to be called before using surf_fopen");
-
- if (__surf_is_absolute_file_path(name)) { /* don't mess with absolute file names */
- return fopen(name,mode);
-
- } else { /* search relative files in the path */
-
- if(!path_name) {
- path_name_len = strlen(name);
- path_name=xbt_new0(char,path_name_len+1);
+ xbt_assert0(surf_path,
+ "surf_init has to be called before using surf_fopen");
+
+ if (__surf_is_absolute_file_path(name)) { /* don't mess with absolute file names */
+ return fopen(name, mode);
+
+ } else { /* search relative files in the path */
+
+ if (!path_name) {
+ path_name_len = strlen(name);
+ path_name = xbt_new0(char, path_name_len + 1);
}
- xbt_dynar_foreach(surf_path,i,path) {
- if(path_name_len < strlen(path)+strlen(name)+1) {
- path_name_len = strlen(path)+strlen(name)+1; /* plus '/' */
- path_name=xbt_realloc(path_name,path_name_len+1);
+ xbt_dynar_foreach(surf_path, i, path) {
+ if (path_name_len < strlen(path) + strlen(name) + 1) {
+ path_name_len = strlen(path) + strlen(name) + 1; /* plus '/' */
+ path_name = xbt_realloc(path_name, path_name_len + 1);
}
- sprintf(path_name,"%s/%s",path, name);
- file = fopen(path_name,mode);
- if (file) return file;
+ sprintf(path_name, "%s/%s", path, name);
+ file = fopen(path_name, mode);
+ if (file)
+ return file;
}
}
return file;
if (resource_list)
xbt_dynar_free(&resource_list);
- if(surf_path)
+ if (surf_path)
xbt_dynar_free(&surf_path);
tmgr_finalize();
surf_parse_lex_destroy();
- if(path_name) {
+ if (path_name) {
free(path_name);
path_name = NULL;
}
int i;
if (first_run) {
- DEBUG0("First Run! Let's \"purge\" events and put resources in the right state");
+ DEBUG0
+ ("First Run! Let's \"purge\" events and put resources in the right state");
while ((next_event_date = tmgr_history_next_date(history)) != -1.0) {
if (next_event_date > NOW)
break;
DEBUG0("Looking for next action end");
xbt_dynar_foreach(resource_list, i, resource) {
- DEBUG1("Running for Resource [%s]",resource->common_public->name);
+ DEBUG1("Running for Resource [%s]", resource->common_public->name);
resource_next_action_end =
resource->common_private->share_resources(NOW);
- DEBUG2("Resource [%s] : next action end = %f",resource->common_public->name,
- resource_next_action_end);
+ DEBUG2("Resource [%s] : next action end = %f",
+ resource->common_public->name, resource_next_action_end);
if (((min < 0.0) || (resource_next_action_end < min))
&& (resource_next_action_end >= 0.0))
min = resource_next_action_end;
DEBUG0("Looking for next event");
while ((next_event_date = tmgr_history_next_date(history)) != -1.0) {
- DEBUG1("Next event : %f",next_event_date);
+ DEBUG1("Next event : %f", next_event_date);
if (next_event_date > NOW + min)
break;
DEBUG0("Updating resources");
if (resource_obj->resource->common_private->
resource_used(resource_obj)) {
min = next_event_date - NOW;
- DEBUG1("This event will modify resource state. Next event set to %f", min);
+ DEBUG1
+ ("This event will modify resource state. Next event set to %f",
+ min);
}
/* update state of resource_obj according to new value. Does not touch lmm.
It will be modified if needed when updating actions */
free(timer);
}
-static command_t command_new(void *fun, void* args)
+static command_t command_new(void *fun, void *args)
{
command_t command = xbt_new0(s_command_t, 1);
command->resource = (surf_resource_t) surf_timer_resource;
command->function = fun;
command->args = args;
- xbt_swag_insert(command,command_pending);
+ xbt_swag_insert(command, command_pending);
return command;
}
{
free(command);
- if(xbt_swag_belongs(command,command_to_run)) {
- xbt_swag_remove(command,command_to_run);
- } else if (xbt_swag_belongs(command,command_pending)) {
- xbt_swag_remove(command,command_pending);
+ if (xbt_swag_belongs(command, command_to_run)) {
+ xbt_swag_remove(command, command_to_run);
+ } else if (xbt_swag_belongs(command, command_pending)) {
+ xbt_swag_remove(command, command_pending);
}
return;
}
static void update_actions_state(double now, double delta)
{
- if(xbt_heap_size(timer_heap)) {
- if(xbt_heap_maxkey(timer_heap)<=now+delta) {
+ if (xbt_heap_size(timer_heap)) {
+ if (xbt_heap_maxkey(timer_heap) <= now + delta) {
xbt_heap_pop(timer_heap);
}
}
command_t command = id;
/* Move this command to the list of commands to execute */
- xbt_swag_remove(command,command_pending);
- xbt_swag_insert(command,command_to_run);
+ xbt_swag_remove(command, command_pending);
+ xbt_swag_insert(command, command_to_run);
return;
}
command = command_new(function, arg);
- tmgr_history_add_trace(history, empty_trace, date, 0, command);
- xbt_heap_push(timer_heap, NULL , date);
+ tmgr_history_add_trace(history, empty_trace, date, 0, command);
+ xbt_heap_push(timer_heap, NULL, date);
}
command_t command = NULL;
command = xbt_swag_extract(command_to_run);
- if(command) {
+ if (command) {
*function = command->function;
*arg = command->args;
return 1;
xbt_swag_free(command_pending);
xbt_swag_free(command_to_run);
- xbt_swag_free(surf_timer_resource->common_public->states.ready_action_set);
+ xbt_swag_free(surf_timer_resource->common_public->states.
+ ready_action_set);
xbt_swag_free(surf_timer_resource->common_public->states.
running_action_set);
xbt_swag_free(surf_timer_resource->common_public->states.
failed_action_set);
- xbt_swag_free(surf_timer_resource->common_public->states.done_action_set);
+ xbt_swag_free(surf_timer_resource->common_public->states.
+ done_action_set);
free(surf_timer_resource->common_public);
free(surf_timer_resource->common_private);
free(surf_timer_resource->extension_public);
surf_timer_resource->common_private =
xbt_new0(s_surf_resource_private_t, 1);
- surf_timer_resource->common_public = xbt_new0(s_surf_resource_public_t, 1);
+ surf_timer_resource->common_public =
+ xbt_new0(s_surf_resource_public_t, 1);
surf_timer_resource->extension_public =
xbt_new0(s_surf_timer_resource_extension_public_t, 1);
xbt_swag_new(xbt_swag_offset(action, state_hookup));
surf_timer_resource->common_public->name_service = name_service;
- surf_timer_resource->common_public->get_resource_name = get_resource_name;
+ surf_timer_resource->common_public->get_resource_name =
+ get_resource_name;
surf_timer_resource->common_public->action_get_state =
surf_action_get_state;
surf_timer_resource->common_public->action_free = action_free;
surf_timer_resource->common_public->action_recycle = action_recycle;
surf_timer_resource->common_public->action_change_state =
action_change_state;
- surf_timer_resource->common_public->action_set_data = surf_action_set_data;
+ surf_timer_resource->common_public->action_set_data =
+ surf_action_set_data;
surf_timer_resource->common_public->name = "TIMER";
surf_timer_resource->common_private->resource_used = resource_used;
{
s_command_t var;
- command_pending = xbt_swag_new(xbt_swag_offset(var, command_set_hookup));
- command_to_run = xbt_swag_new(xbt_swag_offset(var, command_set_hookup));
+ command_pending =
+ xbt_swag_new(xbt_swag_offset(var, command_set_hookup));
+ command_to_run =
+ xbt_swag_new(xbt_swag_offset(var, command_set_hookup));
}
empty_trace = tmgr_empty_trace_new();
#include "xbt/log.h"
#include "surf/surfxml_parse_private.h"
#include "surf/surf_private.h"
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(parse, surf ,"Logging specific to the SURF module");
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(parse, surf,
+ "Logging specific to the SURF module");
#undef CLEANUP
#include "surfxml.c"
-static xbt_dynar_t surf_input_buffer_stack=NULL;
-static xbt_dynar_t surf_file_to_parse_stack=NULL;
+static xbt_dynar_t surf_input_buffer_stack = NULL;
+static xbt_dynar_t surf_file_to_parse_stack = NULL;
void nil_function(void);
void nil_function(void)
void STag_surfxml_include(void)
{
- xbt_dynar_push(surf_input_buffer_stack,&surf_input_buffer);
- xbt_dynar_push(surf_file_to_parse_stack,&surf_file_to_parse);
-
- surf_file_to_parse = surf_fopen(A_surfxml_include_file,"r");
+ xbt_dynar_push(surf_input_buffer_stack, &surf_input_buffer);
+ xbt_dynar_push(surf_file_to_parse_stack, &surf_file_to_parse);
+
+ surf_file_to_parse = surf_fopen(A_surfxml_include_file, "r");
xbt_assert1((surf_file_to_parse), "Unable to open \"%s\"\n",
A_surfxml_include_file);
- surf_input_buffer = surf_parse__create_buffer( surf_file_to_parse, 10);
+ surf_input_buffer = surf_parse__create_buffer(surf_file_to_parse, 10);
surf_parse__switch_to_buffer(surf_input_buffer);
- printf("STAG\n"); fflush(NULL);
+ printf("STAG\n");
+ fflush(NULL);
}
void ETag_surfxml_include(void)
{
- printf("ETAG\n"); fflush(NULL);
+ printf("ETAG\n");
+ fflush(NULL);
surf_parse__delete_buffer(surf_input_buffer);
fclose(surf_file_to_parse);
- xbt_dynar_pop(surf_file_to_parse_stack,&surf_file_to_parse);
- xbt_dynar_pop(surf_input_buffer_stack,&surf_input_buffer);
+ xbt_dynar_pop(surf_file_to_parse_stack, &surf_file_to_parse);
+ xbt_dynar_pop(surf_input_buffer_stack, &surf_input_buffer);
}
void STag_surfxml_platform_description(void)
{
- double version=0.0;
+ double version = 0.0;
- sscanf(A_surfxml_platform_description_version,"%lg",&version);
+ sscanf(A_surfxml_platform_description_version, "%lg", &version);
- xbt_assert0((version>=1.0),"******* BIG FAT WARNING *********\n "
+ xbt_assert0((version >= 1.0), "******* BIG FAT WARNING *********\n "
"You're using an old XML file. "
"Since SimGrid 3.1, units are Bytes, Flops, and seconds "
"instead of MBytes, MFlops and seconds. "
ETag_surfxml_argument_fun();
}
-void surf_parse_open(const char *file) {
- static int warned = 0; /* warn only once */
- if(!file) {
+void surf_parse_open(const char *file)
+{
+ static int warned = 0; /* warn only once */
+ if (!file) {
if (!warned) {
- WARN0("Bypassing the XML parser since surf_parse_open received a NULL pointer. If it is not what you want, go fix your code.");
+ WARN0
+ ("Bypassing the XML parser since surf_parse_open received a NULL pointer. If it is not what you want, go fix your code.");
warned = 1;
}
return;
}
- if(!surf_input_buffer_stack)
- surf_input_buffer_stack = xbt_dynar_new(sizeof(YY_BUFFER_STATE),NULL);
- if(!surf_file_to_parse_stack)
- surf_file_to_parse_stack = xbt_dynar_new(sizeof(FILE*),NULL);
-
- surf_file_to_parse = surf_fopen(file,"r");
- xbt_assert1((surf_file_to_parse), "Unable to open \"%s\"\n",file);
- surf_input_buffer = surf_parse__create_buffer( surf_file_to_parse, 10);
+ if (!surf_input_buffer_stack)
+ surf_input_buffer_stack = xbt_dynar_new(sizeof(YY_BUFFER_STATE), NULL);
+ if (!surf_file_to_parse_stack)
+ surf_file_to_parse_stack = xbt_dynar_new(sizeof(FILE *), NULL);
+
+ surf_file_to_parse = surf_fopen(file, "r");
+ xbt_assert1((surf_file_to_parse), "Unable to open \"%s\"\n", file);
+ surf_input_buffer = surf_parse__create_buffer(surf_file_to_parse, 10);
surf_parse__switch_to_buffer(surf_input_buffer);
surf_parse_lineno = 1;
}
-void surf_parse_close(void) {
- if(surf_input_buffer_stack)
+void surf_parse_close(void)
+{
+ if (surf_input_buffer_stack)
xbt_dynar_free(&surf_input_buffer_stack);
- if(surf_file_to_parse_stack)
+ if (surf_file_to_parse_stack)
xbt_dynar_free(&surf_file_to_parse_stack);
- if(surf_file_to_parse) {
+ if (surf_file_to_parse) {
surf_parse__delete_buffer(surf_input_buffer);
fclose(surf_file_to_parse);
}
int_f_void_t *surf_parse = _surf_parse;
-void surf_parse_get_double(double *value,const char *string)
-{
+void surf_parse_get_double(double *value, const char *string)
+{
int ret = 0;
ret = sscanf(string, "%lg", value);
- xbt_assert2((ret==1), "Parse error line %d : %s not a number", surf_parse_lineno,
- string);
+ xbt_assert2((ret == 1), "Parse error line %d : %s not a number",
+ surf_parse_lineno, string);
}
-void surf_parse_get_trace(tmgr_trace_t *trace, const char *string)
+void surf_parse_get_trace(tmgr_trace_t * trace, const char *string)
{
if ((!string) || (strcmp(string, "") == 0))
*trace = NULL;
else
*trace = tmgr_trace_new(string);
}
-
tmgr_trace_t tmgr_empty_trace_new(void)
{
tmgr_trace_t trace = NULL;
- /*double periodicity = -1.0; No periodicity by default; unused variables
- tmgr_event_t last_event = NULL;*/
+ /*double periodicity = -1.0; No periodicity by default; unused variables
+ tmgr_event_t last_event = NULL; */
s_tmgr_event_t event;
trace = xbt_new0(s_tmgr_trace_t, 1);
static xbt_dict_t parallel_task_network_link_set = NULL;
static workstation_CLM03_t workstation_new(const char *name,
- void *cpu, void *card)
+ void *cpu, void *card)
{
workstation_CLM03_t workstation = xbt_new0(s_workstation_CLM03_t, 1);
static void workstation_free(void *workstation)
{
- free(((workstation_CLM03_t)workstation)->name);
+ free(((workstation_CLM03_t) workstation)->name);
free(workstation);
}
xbt_dict_foreach(cpu_set, cursor, name, cpu) {
nw_card = xbt_dict_get_or_null(network_card_set, name);
- xbt_assert1(nw_card,
- "No corresponding card found for %s",name);
+ xbt_assert1(nw_card, "No corresponding card found for %s", name);
xbt_dict_set(workstation_set, name,
workstation_new(name, cpu, nw_card), workstation_free);
static int parallel_action_free(surf_action_t action)
{
action->using--;
- if(!action->using) {
+ if (!action->using) {
xbt_swag_remove(action, action->state_set);
- if(((surf_action_parallel_task_CSL05_t)action)->variable)
- lmm_variable_free(maxmin_system, ((surf_action_parallel_task_CSL05_t)action)->variable);
+ if (((surf_action_parallel_task_CSL05_t) action)->variable)
+ lmm_variable_free(maxmin_system,
+ ((surf_action_parallel_task_CSL05_t) action)->
+ variable);
free(action);
return 1;
}
static int action_free(surf_action_t action)
{
- if(action->resource_type==(surf_resource_t)surf_network_resource)
+ if (action->resource_type == (surf_resource_t) surf_network_resource)
return surf_network_resource->common_public->action_free(action);
- else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
+ else if (action->resource_type == (surf_resource_t) surf_cpu_resource)
return surf_cpu_resource->common_public->action_free(action);
- else if(action->resource_type==(surf_resource_t)surf_workstation_resource)
+ else if (action->resource_type ==
+ (surf_resource_t) surf_workstation_resource)
return parallel_action_free(action);
- else DIE_IMPOSSIBLE;
+ else
+ DIE_IMPOSSIBLE;
return 0;
}
static void action_use(surf_action_t action)
{
- if(action->resource_type==(surf_resource_t)surf_network_resource)
+ if (action->resource_type == (surf_resource_t) surf_network_resource)
surf_network_resource->common_public->action_use(action);
- else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
+ else if (action->resource_type == (surf_resource_t) surf_cpu_resource)
surf_cpu_resource->common_public->action_use(action);
- else if(action->resource_type==(surf_resource_t)surf_workstation_resource)
+ else if (action->resource_type ==
+ (surf_resource_t) surf_workstation_resource)
parallel_action_use(action);
- else DIE_IMPOSSIBLE;
+ else
+ DIE_IMPOSSIBLE;
return;
}
static void action_cancel(surf_action_t action)
{
- if(action->resource_type==(surf_resource_t)surf_network_resource)
+ if (action->resource_type == (surf_resource_t) surf_network_resource)
surf_network_resource->common_public->action_cancel(action);
- else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
+ else if (action->resource_type == (surf_resource_t) surf_cpu_resource)
surf_cpu_resource->common_public->action_cancel(action);
- else if(action->resource_type==(surf_resource_t)surf_workstation_resource)
+ else if (action->resource_type ==
+ (surf_resource_t) surf_workstation_resource)
parallel_action_use(action);
- else DIE_IMPOSSIBLE;
+ else
+ DIE_IMPOSSIBLE;
return;
}
static void action_change_state(surf_action_t action,
e_surf_action_state_t state)
{
- if(action->resource_type==(surf_resource_t)surf_network_resource)
- surf_network_resource->common_public->action_change_state(action,state);
- else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
- surf_cpu_resource->common_public->action_change_state(action,state);
- else if(action->resource_type==(surf_resource_t)surf_workstation_resource)
+ if (action->resource_type == (surf_resource_t) surf_network_resource)
+ surf_network_resource->common_public->action_change_state(action,
+ state);
+ else if (action->resource_type == (surf_resource_t) surf_cpu_resource)
+ surf_cpu_resource->common_public->action_change_state(action, state);
+ else if (action->resource_type ==
+ (surf_resource_t) surf_workstation_resource)
surf_action_change_state(action, state);
- else DIE_IMPOSSIBLE;
+ else
+ DIE_IMPOSSIBLE;
return;
}
static double share_resources(double now)
{
s_surf_action_parallel_task_CSL05_t action;
- return generic_maxmin_share_resources(surf_workstation_resource->common_public->
- states.running_action_set,
+ return generic_maxmin_share_resources(surf_workstation_resource->
+ common_public->states.
+ running_action_set,
xbt_swag_offset(action, variable));
}
xbt_swag_t running_actions =
surf_workstation_resource->common_public->states.running_action_set;
/* FIXME: unused
- xbt_swag_t failed_actions =
- surf_workstation_resource->common_public->states.failed_action_set;
- */
+ xbt_swag_t failed_actions =
+ surf_workstation_resource->common_public->states.failed_action_set;
+ */
xbt_swag_foreach_safe(action, next_action, running_actions) {
double_update(&(action->generic_action.remains),
- lmm_variable_getvalue(action->variable) * delta);
+ lmm_variable_getvalue(action->variable) * delta);
if (action->generic_action.max_duration != NO_MAX_DURATION)
double_update(&(action->generic_action.max_duration), delta);
- if ((action->generic_action.remains <= 0) &&
- (lmm_get_variable_weight(action->variable)>0)) {
+ if ((action->generic_action.remains <= 0) &&
+ (lmm_get_variable_weight(action->variable) > 0)) {
action->generic_action.finish = surf_get_clock();
action_change_state((surf_action_t) action, SURF_ACTION_DONE);
} else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
lmm_get_cnst_from_var(maxmin_system, action->variable,
i++))) {
resource = (surf_resource_t) lmm_constraint_id(cnst);
- if(resource== (surf_resource_t) surf_cpu_resource) {
+ if (resource == (surf_resource_t) surf_cpu_resource) {
cpu_Cas01_t cpu = lmm_constraint_id(cnst);
if (cpu->state_current == SURF_CPU_OFF) {
action->generic_action.finish = surf_get_clock();
- action_change_state((surf_action_t) action, SURF_ACTION_FAILED);
+ action_change_state((surf_action_t) action,
+ SURF_ACTION_FAILED);
break;
}
- } else if (resource== (surf_resource_t) surf_network_resource) {
+ } else if (resource == (surf_resource_t) surf_network_resource) {
network_link_CM02_t nw_link = lmm_constraint_id(cnst);
if (nw_link->state_current == SURF_NETWORK_LINK_OFF) {
action->generic_action.finish = surf_get_clock();
- action_change_state((surf_action_t) action, SURF_ACTION_FAILED);
+ action_change_state((surf_action_t) action,
+ SURF_ACTION_FAILED);
break;
}
- }
+ }
}
}
}
static void action_suspend(surf_action_t action)
{
- if(action->resource_type==(surf_resource_t)surf_network_resource)
+ if (action->resource_type == (surf_resource_t) surf_network_resource)
surf_network_resource->common_public->suspend(action);
- else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
+ else if (action->resource_type == (surf_resource_t) surf_cpu_resource)
surf_cpu_resource->common_public->suspend(action);
- else DIE_IMPOSSIBLE;
+ else
+ DIE_IMPOSSIBLE;
}
static void action_resume(surf_action_t action)
{
- if(action->resource_type==(surf_resource_t)surf_network_resource)
+ if (action->resource_type == (surf_resource_t) surf_network_resource)
surf_network_resource->common_public->resume(action);
- else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
+ else if (action->resource_type == (surf_resource_t) surf_cpu_resource)
surf_cpu_resource->common_public->resume(action);
- else DIE_IMPOSSIBLE;
+ else
+ DIE_IMPOSSIBLE;
}
static int action_is_suspended(surf_action_t action)
{
- if(action->resource_type==(surf_resource_t)surf_network_resource)
+ if (action->resource_type == (surf_resource_t) surf_network_resource)
return surf_network_resource->common_public->is_suspended(action);
- if(action->resource_type==(surf_resource_t)surf_cpu_resource)
+ if (action->resource_type == (surf_resource_t) surf_cpu_resource)
return surf_cpu_resource->common_public->is_suspended(action);
DIE_IMPOSSIBLE;
}
static void action_set_max_duration(surf_action_t action, double duration)
{
- if(action->resource_type==(surf_resource_t)surf_network_resource)
- surf_network_resource->common_public->set_max_duration(action,duration);
- else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
- surf_cpu_resource->common_public->set_max_duration(action,duration);
- else DIE_IMPOSSIBLE;
+ if (action->resource_type == (surf_resource_t) surf_network_resource)
+ surf_network_resource->common_public->set_max_duration(action,
+ duration);
+ else if (action->resource_type == (surf_resource_t) surf_cpu_resource)
+ surf_cpu_resource->common_public->set_max_duration(action, duration);
+ else
+ DIE_IMPOSSIBLE;
}
-
+
static void action_set_priority(surf_action_t action, double priority)
{
- if(action->resource_type==(surf_resource_t)surf_network_resource)
- surf_network_resource->common_public->set_priority(action,priority);
- else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
- surf_cpu_resource->common_public->set_priority(action,priority);
- else DIE_IMPOSSIBLE;
+ if (action->resource_type == (surf_resource_t) surf_network_resource)
+ surf_network_resource->common_public->set_priority(action, priority);
+ else if (action->resource_type == (surf_resource_t) surf_cpu_resource)
+ surf_cpu_resource->common_public->set_priority(action, priority);
+ else
+ DIE_IMPOSSIBLE;
}
static surf_action_t communicate(void *workstation_src,
{
return surf_network_resource->extension_public->
communicate(((workstation_CLM03_t) workstation_src)->network_card,
- ((workstation_CLM03_t) workstation_dst)->network_card, size, rate);
+ ((workstation_CLM03_t) workstation_dst)->network_card,
+ size, rate);
}
static e_surf_cpu_state_t get_state(void *workstation)
get_available_speed(((workstation_CLM03_t) workstation)->cpu);
}
-static surf_action_t execute_parallel_task_bogus (int workstation_nb,
- void **workstation_list,
- double *computation_amount,
- double *communication_amount,
- double amount,
- double rate)
+static surf_action_t execute_parallel_task_bogus(int workstation_nb,
+ void **workstation_list,
+ double
+ *computation_amount,
+ double
+ *communication_amount,
+ double amount,
+ double rate)
{
- xbt_assert0(0,"This model does not implement parallel tasks");
+ xbt_assert0(0, "This model does not implement parallel tasks");
}
-static surf_action_t execute_parallel_task (int workstation_nb,
- void **workstation_list,
- double *computation_amount,
- double *communication_amount,
- double amount,
- double rate)
+static surf_action_t execute_parallel_task(int workstation_nb,
+ void **workstation_list,
+ double *computation_amount,
+ double *communication_amount,
+ double amount, double rate)
{
surf_action_parallel_task_CSL05_t action = NULL;
int i, j, k;
int nb_host = 0;
if (parallel_task_network_link_set == NULL) {
- parallel_task_network_link_set = xbt_dict_new_ext(workstation_nb * workstation_nb * 10);
+ parallel_task_network_link_set =
+ xbt_dict_new_ext(workstation_nb * workstation_nb * 10);
}
/* Compute the number of affected resources... */
- for(i=0; i< workstation_nb; i++) {
- for(j=0; j< workstation_nb; j++) {
- network_card_CM02_t card_src = ((workstation_CLM03_t*)workstation_list)[i]->network_card;
- network_card_CM02_t card_dst = ((workstation_CLM03_t*)workstation_list)[j]->network_card;
+ for (i = 0; i < workstation_nb; i++) {
+ for (j = 0; j < workstation_nb; j++) {
+ network_card_CM02_t card_src =
+ ((workstation_CLM03_t *) workstation_list)[i]->network_card;
+ network_card_CM02_t card_dst =
+ ((workstation_CLM03_t *) workstation_list)[j]->network_card;
int route_size = ROUTE_SIZE(card_src->id, card_dst->id);
network_link_CM02_t *route = ROUTE(card_src->id, card_dst->id);
-
- if(communication_amount[i*workstation_nb+j]>0)
- for(k=0; k< route_size; k++) {
- xbt_dict_set(parallel_task_network_link_set, route[k]->name, route[k], NULL);
+
+ if (communication_amount[i * workstation_nb + j] > 0)
+ for (k = 0; k < route_size; k++) {
+ xbt_dict_set(parallel_task_network_link_set, route[k]->name,
+ route[k], NULL);
}
}
}
nb_link = xbt_dict_length(parallel_task_network_link_set);
xbt_dict_reset(parallel_task_network_link_set);
- for (i = 0; i<workstation_nb; i++)
- if(computation_amount[i]>0) nb_host++;
-
- if(nb_link + workstation_nb == 0)
+ for (i = 0; i < workstation_nb; i++)
+ if (computation_amount[i] > 0)
+ nb_host++;
+
+ if (nb_link + workstation_nb == 0)
return NULL;
action = xbt_new0(s_surf_action_parallel_task_CSL05_t, 1);
action->generic_action.finish = -1.0;
action->generic_action.resource_type =
(surf_resource_t) surf_workstation_resource;
- action->suspended = 0; /* Should be useless because of the
- calloc but it seems to help valgrind... */
+ action->suspended = 0; /* Should be useless because of the
+ calloc but it seems to help valgrind... */
action->generic_action.state_set =
surf_workstation_resource->common_public->states.running_action_set;
xbt_swag_insert(action, action->generic_action.state_set);
action->rate = rate;
- if(action->rate>0)
+ if (action->rate > 0)
action->variable = lmm_variable_new(maxmin_system, action, 1.0, -1.0,
nb_host + nb_link);
- else
- action->variable = lmm_variable_new(maxmin_system, action, 1.0, action->rate,
- nb_host + nb_link);
-
- for (i = 0; i<workstation_nb; i++)
- if(computation_amount[i]>0)
- lmm_expand(maxmin_system, ((cpu_Cas01_t) ((workstation_CLM03_t) workstation_list[i])->cpu)->constraint,
- action->variable, computation_amount[i]);
-
- for (i=0; i<workstation_nb; i++) {
- for(j=0; j< workstation_nb; j++) {
- network_card_CM02_t card_src = ((workstation_CLM03_t*)workstation_list)[i]->network_card;
- network_card_CM02_t card_dst = ((workstation_CLM03_t*)workstation_list)[j]->network_card;
+ else
+ action->variable =
+ lmm_variable_new(maxmin_system, action, 1.0, action->rate,
+ nb_host + nb_link);
+
+ for (i = 0; i < workstation_nb; i++)
+ if (computation_amount[i] > 0)
+ lmm_expand(maxmin_system,
+ ((cpu_Cas01_t)
+ ((workstation_CLM03_t) workstation_list[i])->cpu)->
+ constraint, action->variable, computation_amount[i]);
+
+ for (i = 0; i < workstation_nb; i++) {
+ for (j = 0; j < workstation_nb; j++) {
+ network_card_CM02_t card_src =
+ ((workstation_CLM03_t *) workstation_list)[i]->network_card;
+ network_card_CM02_t card_dst =
+ ((workstation_CLM03_t *) workstation_list)[j]->network_card;
int route_size = ROUTE_SIZE(card_src->id, card_dst->id);
network_link_CM02_t *route = ROUTE(card_src->id, card_dst->id);
-
- for(k=0; k< route_size; k++) {
- if(communication_amount[i*workstation_nb+j]>0) {
- lmm_expand_add(maxmin_system, route[k]->constraint,
- action->variable, communication_amount[i*workstation_nb+j]);
+
+ for (k = 0; k < route_size; k++) {
+ if (communication_amount[i * workstation_nb + j] > 0) {
+ lmm_expand_add(maxmin_system, route[k]->constraint,
+ action->variable,
+ communication_amount[i * workstation_nb + j]);
}
}
}
}
-
+
return (surf_action_t) action;
}
/* returns an array of network_link_CM02_t */
-static const void** get_route(void *src, void *dst) {
+static const void **get_route(void *src, void *dst)
+{
workstation_CLM03_t workstation_src = (workstation_CLM03_t) src;
workstation_CLM03_t workstation_dst = (workstation_CLM03_t) dst;
- return surf_network_resource->extension_public->get_route(workstation_src->network_card, workstation_dst->network_card);
+ return surf_network_resource->extension_public->
+ get_route(workstation_src->network_card,
+ workstation_dst->network_card);
}
-static int get_route_size(void *src, void *dst) {
+static int get_route_size(void *src, void *dst)
+{
workstation_CLM03_t workstation_src = (workstation_CLM03_t) src;
workstation_CLM03_t workstation_dst = (workstation_CLM03_t) dst;
- return surf_network_resource->extension_public->get_route_size(workstation_src->network_card, workstation_dst->network_card);
+ return surf_network_resource->extension_public->
+ get_route_size(workstation_src->network_card,
+ workstation_dst->network_card);
}
-static const char *get_link_name(const void *link) {
+static const char *get_link_name(const void *link)
+{
return surf_network_resource->extension_public->get_link_name(link);
}
-static double get_link_bandwidth(const void *link) {
+static double get_link_bandwidth(const void *link)
+{
return surf_network_resource->extension_public->get_link_bandwidth(link);
}
-static double get_link_latency(const void *link) {
- return surf_network_resource->extension_public->get_link_latency(link);
+static double get_link_latency(const void *link)
+{
+ return surf_network_resource->extension_public->get_link_latency(link);
}
static void finalize(void)
{
xbt_dict_free(&workstation_set);
- xbt_swag_free(surf_workstation_resource->common_public->states.ready_action_set);
+ xbt_swag_free(surf_workstation_resource->common_public->states.
+ ready_action_set);
xbt_swag_free(surf_workstation_resource->common_public->states.
running_action_set);
xbt_swag_free(surf_workstation_resource->common_public->states.
failed_action_set);
- xbt_swag_free(surf_workstation_resource->common_public->states.done_action_set);
+ xbt_swag_free(surf_workstation_resource->common_public->states.
+ done_action_set);
free(surf_workstation_resource->common_public);
free(surf_workstation_resource->common_private);
action_recycle;
surf_workstation_resource->common_public->action_change_state =
action_change_state;
- surf_workstation_resource->common_public->action_set_data = surf_action_set_data;
+ surf_workstation_resource->common_public->action_set_data =
+ surf_action_set_data;
surf_workstation_resource->common_public->name = "Workstation";
surf_workstation_resource->common_private->resource_used = resource_used;
surf_workstation_resource->common_public->suspend = action_suspend;
surf_workstation_resource->common_public->resume = action_resume;
- surf_workstation_resource->common_public->is_suspended = action_is_suspended;
- surf_workstation_resource->common_public->set_max_duration = action_set_max_duration;
- surf_workstation_resource->common_public->set_priority = action_set_priority;
+ surf_workstation_resource->common_public->is_suspended =
+ action_is_suspended;
+ surf_workstation_resource->common_public->set_max_duration =
+ action_set_max_duration;
+ surf_workstation_resource->common_public->set_priority =
+ action_set_priority;
surf_workstation_resource->extension_public->execute = execute;
surf_workstation_resource->extension_public->sleep = action_sleep;
surf_workstation_resource->extension_public->get_state = get_state;
surf_workstation_resource->extension_public->get_speed = get_speed;
- surf_workstation_resource->extension_public->get_available_speed = get_available_speed;
+ surf_workstation_resource->extension_public->get_available_speed =
+ get_available_speed;
surf_workstation_resource->extension_public->communicate = communicate;
- surf_workstation_resource->extension_public->execute_parallel_task =
- execute_parallel_task_bogus;
+ surf_workstation_resource->extension_public->execute_parallel_task =
+ execute_parallel_task_bogus;
surf_workstation_resource->extension_public->get_route = get_route;
- surf_workstation_resource->extension_public->get_route_size = get_route_size;
- surf_workstation_resource->extension_public->get_link_name = get_link_name;
- surf_workstation_resource->extension_public->get_link_bandwidth = get_link_bandwidth;
- surf_workstation_resource->extension_public->get_link_latency = get_link_latency;
+ surf_workstation_resource->extension_public->get_route_size =
+ get_route_size;
+ surf_workstation_resource->extension_public->get_link_name =
+ get_link_name;
+ surf_workstation_resource->extension_public->get_link_bandwidth =
+ get_link_bandwidth;
+ surf_workstation_resource->extension_public->get_link_latency =
+ get_link_latency;
workstation_set = xbt_dict_new();
xbt_assert0(maxmin_system, "surf_init has to be called first!");
void surf_workstation_resource_init_compound(const char *filename)
{
- xbt_assert0(surf_cpu_resource,"No CPU resource defined yet!");
- xbt_assert0(surf_network_resource,"No network resource defined yet!");
+ xbt_assert0(surf_cpu_resource, "No CPU resource defined yet!");
+ xbt_assert0(surf_network_resource, "No network resource defined yet!");
surf_workstation_resource_init_internal();
create_workstations();
cpu->power_current * cpu->power_scale *
cpu->interference_send);
xbt_dynar_foreach(cpu->outgoing_communications, cpt, action)
- lmm_elem_set_value(maxmin_system,cpu->constraint,action->variable,
- cpu->power_current * cpu->power_scale *
- ROUTE(action->src->id, action->dst->id).impact_on_src
- );
- } else if ((xbt_dynar_length(cpu->incomming_communications)) &&
- (!xbt_dynar_length(cpu->outgoing_communications))) {
+ lmm_elem_set_value(maxmin_system, cpu->constraint,
+ action->variable,
+ cpu->power_current * cpu->power_scale *
+ ROUTE(action->src->id,
+ action->dst->id).impact_on_src);
+ } else if ((xbt_dynar_length(cpu->incomming_communications))
+ && (!xbt_dynar_length(cpu->outgoing_communications))) {
/* Reception */
lmm_update_constraint_bound(maxmin_system, cpu->constraint,
cpu->power_current * cpu->power_scale *
cpu->interference_recv);
xbt_dynar_foreach(cpu->incomming_communications, cpt, action)
- lmm_elem_set_value(maxmin_system,cpu->constraint,action->variable,
- cpu->power_current * cpu->power_scale *
- ROUTE(action->src->id, action->dst->id).impact_on_dst
- );
+ lmm_elem_set_value(maxmin_system, cpu->constraint,
+ action->variable,
+ cpu->power_current * cpu->power_scale *
+ ROUTE(action->src->id,
+ action->dst->id).impact_on_dst);
} else {
/* Emission & Reception */
lmm_update_constraint_bound(maxmin_system, cpu->constraint,
cpu->power_current * cpu->power_scale *
cpu->interference_send_recv);
xbt_dynar_foreach(cpu->outgoing_communications, cpt, action)
- lmm_elem_set_value(maxmin_system,cpu->constraint,action->variable,
- cpu->power_current * cpu->power_scale *
- ROUTE(action->src->id, action->dst->id).impact_on_src_with_other_recv
- );
+ lmm_elem_set_value(maxmin_system, cpu->constraint,
+ action->variable,
+ cpu->power_current * cpu->power_scale *
+ ROUTE(action->src->id,
+ action->dst->id).
+ impact_on_src_with_other_recv);
xbt_dynar_foreach(cpu->incomming_communications, cpt, action)
- lmm_elem_set_value(maxmin_system,cpu->constraint,action->variable,
- cpu->power_current * cpu->power_scale *
- ROUTE(action->src->id, action->dst->id).impact_on_dst_with_other_send
- );
+ lmm_elem_set_value(maxmin_system, cpu->constraint,
+ action->variable,
+ cpu->power_current * cpu->power_scale *
+ ROUTE(action->src->id,
+ action->dst->id).
+ impact_on_dst_with_other_send);
}
}
static void *name_service(const char *name)
{
xbt_ex_t e;
- void *res=NULL;
+ void *res = NULL;
TRY {
res = xbt_dict_get(workstation_set, name);
} CATCH(e) {
- if (e.category != not_found_error)
+ if (e.category != not_found_error)
RETHROW;
WARN1("Host '%s' not found, verifing if it is a router", name);
res = NULL;
lmm_variable_free(maxmin_system,
((surf_action_workstation_KCCFLN05_t) action)->
variable);
- if(src)
+ if (src)
xbt_dynar_foreach(src->outgoing_communications, cpt, act)
- if (act == action) {
- xbt_dynar_remove_at(src->outgoing_communications, cpt, &act);
- break;
- }
+ if (act == action) {
+ xbt_dynar_remove_at(src->outgoing_communications, cpt, &act);
+ break;
+ }
- if(dst)
+ if (dst)
xbt_dynar_foreach(dst->incomming_communications, cpt, act)
- if (act == action) {
- xbt_dynar_remove_at(dst->incomming_communications, cpt, &act);
- break;
- }
+ if (act == action) {
+ xbt_dynar_remove_at(dst->incomming_communications, cpt, &act);
+ break;
+ }
- if(src && (!xbt_dynar_length(src->outgoing_communications)))
+ if (src && (!xbt_dynar_length(src->outgoing_communications)))
__update_cpu_usage(src);
- if(dst && (!xbt_dynar_length(dst->incomming_communications)))
+ if (dst && (!xbt_dynar_length(dst->incomming_communications)))
__update_cpu_usage(dst);
free(action);
static void action_suspend(surf_action_t action)
{
- XBT_IN1("(%p))",action);
- if(((surf_action_workstation_KCCFLN05_t) action)->suspended != 2) {
+ XBT_IN1("(%p))", action);
+ if (((surf_action_workstation_KCCFLN05_t) action)->suspended != 2) {
((surf_action_workstation_KCCFLN05_t) action)->suspended = 1;
lmm_update_variable_weight(maxmin_system,
((surf_action_workstation_KCCFLN05_t)
static void action_resume(surf_action_t action)
{
- XBT_IN1("(%p)",action);
- if(((surf_action_workstation_KCCFLN05_t) action)->suspended !=2) {
- if(((surf_action_workstation_KCCFLN05_t)action)->lat_current==0.0)
+ XBT_IN1("(%p)", action);
+ if (((surf_action_workstation_KCCFLN05_t) action)->suspended != 2) {
+ if (((surf_action_workstation_KCCFLN05_t) action)->lat_current == 0.0)
lmm_update_variable_weight(maxmin_system,
((surf_action_workstation_KCCFLN05_t)
action)->variable, 1.0);
else
lmm_update_variable_weight(maxmin_system,
- ((surf_action_workstation_KCCFLN05_t) action)->variable,
- ((surf_action_workstation_KCCFLN05_t) action)->lat_current);
-
+ ((surf_action_workstation_KCCFLN05_t)
+ action)->variable,
+ ((surf_action_workstation_KCCFLN05_t)
+ action)->lat_current);
+
((surf_action_workstation_KCCFLN05_t) action)->suspended = 0;
}
XBT_OUT;
static int action_is_suspended(surf_action_t action)
{
- return (((surf_action_workstation_KCCFLN05_t) action)->suspended==1);
+ return (((surf_action_workstation_KCCFLN05_t) action)->suspended == 1);
}
static void action_set_max_duration(surf_action_t action, double duration)
{ /* FIXME: should inherit */
- XBT_IN2("(%p,%g)",action,duration);
+ XBT_IN2("(%p,%g)", action, duration);
action->max_duration = duration;
XBT_OUT;
}
static void action_set_priority(surf_action_t action, double priority)
{ /* FIXME: should inherit */
- XBT_IN2("(%p,%g)",action,priority);
+ XBT_IN2("(%p,%g)", action, priority);
action->priority = priority;
XBT_OUT;
}
{
/* We can freely cast as a network_link_KCCFLN05_t because it has
the same prefix as cpu_KCCFLN05_t */
- if(((cpu_KCCFLN05_t) resource_id)->type == SURF_WORKSTATION_RESOURCE_CPU)
- return (lmm_constraint_used(maxmin_system,
- ((cpu_KCCFLN05_t) resource_id)->
- constraint) ||
- ((((cpu_KCCFLN05_t) resource_id)->bus)?
- lmm_constraint_used(maxmin_system,
- ((cpu_KCCFLN05_t) resource_id)->
- bus):0));
- else
+ if (((cpu_KCCFLN05_t) resource_id)->type ==
+ SURF_WORKSTATION_RESOURCE_CPU)
+ return (lmm_constraint_used
+ (maxmin_system, ((cpu_KCCFLN05_t) resource_id)->constraint)
+ || ((((cpu_KCCFLN05_t) resource_id)->bus) ?
+ lmm_constraint_used(maxmin_system,
+ ((cpu_KCCFLN05_t) resource_id)->
+ bus) : 0));
+ else
return lmm_constraint_used(maxmin_system,
((network_link_KCCFLN05_t) resource_id)->
constraint);
s_surf_action_workstation_KCCFLN05_t s_action;
surf_action_workstation_KCCFLN05_t action = NULL;
- xbt_swag_t running_actions = surf_workstation_resource->common_public->states.running_action_set;
+ xbt_swag_t running_actions =
+ surf_workstation_resource->common_public->states.running_action_set;
double min = generic_maxmin_share_resources(running_actions,
- xbt_swag_offset(s_action, variable));
+ xbt_swag_offset(s_action,
+ variable));
xbt_swag_foreach(action, running_actions) {
- if(action->latency>0) {
- if(min<0) {
+ if (action->latency > 0) {
+ if (min < 0) {
min = action->latency;
- DEBUG3("Updating min (value) with %p (start %f): %f",action,
+ DEBUG3("Updating min (value) with %p (start %f): %f", action,
action->generic_action.start, min);
- }
- else if (action->latency<min) {
+ } else if (action->latency < min) {
min = action->latency;
- DEBUG3("Updating min (latency) with %p (start %f): %f",action,
+ DEBUG3("Updating min (latency) with %p (start %f): %f", action,
action->generic_action.start, min);
}
}
}
- DEBUG1("min value : %f",min);
+ DEBUG1("min value : %f", min);
return min;
}
double_update(&(deltap), action->latency);
action->latency = 0.0;
}
- if ((action->latency == 0.0) && (action->suspended==0)) {
- if((action)->lat_current==0.0)
- lmm_update_variable_weight(maxmin_system,action->variable, 1.0);
+ if ((action->latency == 0.0) && (action->suspended == 0)) {
+ if ((action)->lat_current == 0.0)
+ lmm_update_variable_weight(maxmin_system, action->variable, 1.0);
else
- lmm_update_variable_weight(maxmin_system, action->variable,
+ lmm_update_variable_weight(maxmin_system, action->variable,
action->lat_current);
}
}
action, action->generic_action.remains,
lmm_variable_getvalue(action->variable) * deltap);
double_update(&(action->generic_action.remains),
- lmm_variable_getvalue(action->variable) * deltap);
+ lmm_variable_getvalue(action->variable) * deltap);
if (action->generic_action.max_duration != NO_MAX_DURATION)
double_update(&(action->generic_action.max_duration), delta);
- if ((action->generic_action.remains <= 0) &&
- (lmm_get_variable_weight(action->variable)>0)) {
+ if ((action->generic_action.remains <= 0) &&
+ (lmm_get_variable_weight(action->variable) > 0)) {
action->generic_action.finish = surf_get_clock();
surf_action_change_state((surf_action_t) action, SURF_ACTION_DONE);
} else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
/* ((cpu_KCCFLN05_t)constraint_id)->state_current==SURF_CPU_OFF?"Off":"On"); */
/* } */
- if(((((network_link_KCCFLN05_t)constraint_id)->type==
- SURF_WORKSTATION_RESOURCE_LINK) &&
- (((network_link_KCCFLN05_t)constraint_id)->state_current==
- SURF_NETWORK_LINK_OFF)) ||
- ((((cpu_KCCFLN05_t)constraint_id)->type==
- SURF_WORKSTATION_RESOURCE_CPU) &&
- (((cpu_KCCFLN05_t)constraint_id)->state_current==
- SURF_CPU_OFF))) {
- DEBUG1("Action (%p) Failed!!",action);
+ if (((((network_link_KCCFLN05_t) constraint_id)->type ==
+ SURF_WORKSTATION_RESOURCE_LINK) &&
+ (((network_link_KCCFLN05_t) constraint_id)->state_current ==
+ SURF_NETWORK_LINK_OFF)) ||
+ ((((cpu_KCCFLN05_t) constraint_id)->type ==
+ SURF_WORKSTATION_RESOURCE_CPU) &&
+ (((cpu_KCCFLN05_t) constraint_id)->state_current ==
+ SURF_CPU_OFF))) {
+ DEBUG1("Action (%p) Failed!!", action);
action->generic_action.finish = surf_get_clock();
- surf_action_change_state((surf_action_t) action, SURF_ACTION_FAILED);
+ surf_action_change_state((surf_action_t) action,
+ SURF_ACTION_FAILED);
break;
}
}
double value)
{
cpu_KCCFLN05_t cpu = id;
- network_link_KCCFLN05_t nw_link = id ;
+ network_link_KCCFLN05_t nw_link = id;
- if(nw_link->type == SURF_WORKSTATION_RESOURCE_LINK) {
- DEBUG2("Updating link %s (%p)",nw_link->name,nw_link);
+ if (nw_link->type == SURF_WORKSTATION_RESOURCE_LINK) {
+ DEBUG2("Updating link %s (%p)", nw_link->name, nw_link);
if (event_type == nw_link->bw_event) {
nw_link->bw_current = value;
lmm_update_constraint_bound(maxmin_system, nw_link->constraint,
double delta = value - nw_link->lat_current;
lmm_variable_t var = NULL;
surf_action_workstation_KCCFLN05_t action = NULL;
-
+
nw_link->lat_current = value;
- while (lmm_get_var_from_cnst(maxmin_system, nw_link->constraint, &var)) {
+ while (lmm_get_var_from_cnst
+ (maxmin_system, nw_link->constraint, &var)) {
action = lmm_variable_id(var);
action->lat_current += delta;
- if(action->rate<0)
+ if (action->rate < 0)
lmm_update_variable_bound(maxmin_system, action->variable,
- SG_TCP_CTE_GAMMA / (2.0 * action->lat_current));
- else
+ SG_TCP_CTE_GAMMA / (2.0 *
+ action->
+ lat_current));
+ else
lmm_update_variable_bound(maxmin_system, action->variable,
- min(action->rate,SG_TCP_CTE_GAMMA / (2.0 * action->lat_current)));
- if(action->suspended==0)
- lmm_update_variable_weight(maxmin_system, action->variable,
+ min(action->rate,
+ SG_TCP_CTE_GAMMA / (2.0 *
+ action->
+ lat_current)));
+ if (action->suspended == 0)
+ lmm_update_variable_weight(maxmin_system, action->variable,
action->lat_current);
- lmm_update_variable_latency(maxmin_system, action->variable, delta);
-
+ lmm_update_variable_latency(maxmin_system, action->variable,
+ delta);
+
}
} else if (event_type == nw_link->state_event) {
xbt_abort();
}
return;
- } else if(cpu->type == SURF_WORKSTATION_RESOURCE_CPU) {
- DEBUG3("Updating cpu %s (%p) with value %g",cpu->name,cpu,value);
+ } else if (cpu->type == SURF_WORKSTATION_RESOURCE_CPU) {
+ DEBUG3("Updating cpu %s (%p) with value %g", cpu->name, cpu, value);
if (event_type == cpu->power_event) {
cpu->power_current = value;
__update_cpu_usage(cpu);
static void finalize(void)
{
- int i,j;
+ int i, j;
xbt_dict_free(&network_link_set);
xbt_dict_free(&workstation_set);
surf_action_workstation_KCCFLN05_t action = NULL;
cpu_KCCFLN05_t CPU = cpu;
- XBT_IN2("(%s,%g)",CPU->name,size);
+ XBT_IN2("(%s,%g)", CPU->name, size);
action = xbt_new0(s_surf_action_workstation_KCCFLN05_t, 1);
action->generic_action.using = 1;
if (CPU->state_current == SURF_CPU_ON)
action->generic_action.state_set =
- surf_workstation_resource->common_public->states.running_action_set;
+ surf_workstation_resource->common_public->states.
+ running_action_set;
else
action->generic_action.state_set =
surf_workstation_resource->common_public->states.failed_action_set;
xbt_swag_insert(action, action->generic_action.state_set);
- action->variable = lmm_variable_new(maxmin_system, action,
- action->generic_action.priority, -1.0, 1);
- lmm_expand(maxmin_system, CPU->constraint, action->variable,
- 1.0);
+ action->variable = lmm_variable_new(maxmin_system, action,
+ action->generic_action.priority,
+ -1.0, 1);
+ lmm_expand(maxmin_system, CPU->constraint, action->variable, 1.0);
XBT_OUT;
return (surf_action_t) action;
}
{
surf_action_workstation_KCCFLN05_t action = NULL;
- XBT_IN2("(%s,%g)",((cpu_KCCFLN05_t)cpu)->name,duration);
+ XBT_IN2("(%s,%g)", ((cpu_KCCFLN05_t) cpu)->name, duration);
action = (surf_action_workstation_KCCFLN05_t) execute(cpu, 1.0);
action->generic_action.max_duration = duration;
static double get_speed(void *cpu, double load)
{
- return load*(((cpu_KCCFLN05_t) cpu)->power_scale);
+ return load * (((cpu_KCCFLN05_t) cpu)->power_scale);
}
static double get_available_speed(void *cpu)
}
-static surf_action_t communicate(void *src, void *dst, double size, double rate)
+static surf_action_t communicate(void *src, void *dst, double size,
+ double rate)
{
surf_action_workstation_KCCFLN05_t action = NULL;
cpu_KCCFLN05_t card_src = src;
int route_size = route->size;
int i;
- XBT_IN4("(%s,%s,%g,%g)",card_src->name,card_dst->name,size,rate);
- xbt_assert2(route_size,"You're trying to send data from %s to %s but there is no connexion between these two cards.", card_src->name, card_dst->name);
+ XBT_IN4("(%s,%s,%g,%g)", card_src->name, card_dst->name, size, rate);
+ xbt_assert2(route_size,
+ "You're trying to send data from %s to %s but there is no connexion between these two cards.",
+ card_src->name, card_dst->name);
action = xbt_new0(s_surf_action_workstation_KCCFLN05_t, 1);
action->src = src;
action->dst = dst;
action->generic_action.resource_type =
- (surf_resource_t) surf_workstation_resource;
- action->suspended = 0; /* Should be useless because of the
- calloc but it seems to help valgrind... */
+ (surf_resource_t) surf_workstation_resource;
+ action->suspended = 0; /* Should be useless because of the
+ calloc but it seems to help valgrind... */
action->generic_action.state_set =
surf_workstation_resource->common_public->states.running_action_set;
action->latency += route->links[i]->lat_current;
action->lat_current = action->latency;
- if(action->latency>0)
- action->variable = lmm_variable_new(maxmin_system, action, 0.0, -1.0,
- route_size+4); /* +1 for the src bus
- +1 for the dst bus
- +1 for the src cpu
- +1 for the dst cpu */
+ if (action->latency > 0)
+ action->variable = lmm_variable_new(maxmin_system, action, 0.0, -1.0, route_size + 4); /* +1 for the src bus
+ +1 for the dst bus
+ +1 for the src cpu
+ +1 for the dst cpu */
else
action->variable = lmm_variable_new(maxmin_system, action, 1.0, -1.0,
- route_size+4);
+ route_size + 4);
- if(action->rate<0) {
- if(action->lat_current>0)
+ if (action->rate < 0) {
+ if (action->lat_current > 0)
lmm_update_variable_bound(maxmin_system, action->variable,
- SG_TCP_CTE_GAMMA / (2.0 * action->lat_current));
+ SG_TCP_CTE_GAMMA / (2.0 *
+ action->lat_current));
else
lmm_update_variable_bound(maxmin_system, action->variable, -1.0);
} else {
- if(action->lat_current>0)
+ if (action->lat_current > 0)
lmm_update_variable_bound(maxmin_system, action->variable,
- min(action->rate,SG_TCP_CTE_GAMMA / (2.0 * action->lat_current)));
+ min(action->rate,
+ SG_TCP_CTE_GAMMA / (2.0 *
+ action->
+ lat_current)));
else
- lmm_update_variable_bound(maxmin_system, action->variable, action->rate);
+ lmm_update_variable_bound(maxmin_system, action->variable,
+ action->rate);
}
- lmm_update_variable_latency(maxmin_system, action->variable, action->latency);
-
+ lmm_update_variable_latency(maxmin_system, action->variable,
+ action->latency);
+
for (i = 0; i < route_size; i++)
- lmm_expand(maxmin_system, route->links[i]->constraint, action->variable, 1.0);
+ lmm_expand(maxmin_system, route->links[i]->constraint,
+ action->variable, 1.0);
if (card_src->bus)
lmm_expand(maxmin_system, card_src->bus, action->variable, 1.0);
if (card_dst->bus)
}
static surf_action_t execute_parallel_task(int workstation_nb,
- void **workstation_list,
- double *computation_amount,
+ void **workstation_list,
+ double *computation_amount,
double *communication_amount,
- double amount,
- double rate)
+ double amount, double rate)
{
surf_action_workstation_KCCFLN05_t action = NULL;
int i, j, k;
int nb_host = 0;
if (parallel_task_network_link_set == NULL) {
- parallel_task_network_link_set = xbt_dict_new_ext(workstation_nb * workstation_nb * 10);
+ parallel_task_network_link_set =
+ xbt_dict_new_ext(workstation_nb * workstation_nb * 10);
}
-
+
/* Compute the number of affected resources... */
- for(i=0; i< workstation_nb; i++) {
- for(j=0; j< workstation_nb; j++) {
+ for (i = 0; i < workstation_nb; i++) {
+ for (j = 0; j < workstation_nb; j++) {
cpu_KCCFLN05_t card_src = workstation_list[i];
cpu_KCCFLN05_t card_dst = workstation_list[j];
int route_size = ROUTE(card_src->id, card_dst->id).size;
- network_link_KCCFLN05_t *route = ROUTE(card_src->id, card_dst->id).links;
-
- if(communication_amount[i*workstation_nb+j]>0)
- for(k=0; k< route_size; k++) {
- xbt_dict_set(parallel_task_network_link_set, route[k]->name, route[k], NULL);
+ network_link_KCCFLN05_t *route =
+ ROUTE(card_src->id, card_dst->id).links;
+
+ if (communication_amount[i * workstation_nb + j] > 0)
+ for (k = 0; k < route_size; k++) {
+ xbt_dict_set(parallel_task_network_link_set, route[k]->name,
+ route[k], NULL);
}
}
}
xbt_dict_reset(parallel_task_network_link_set);
- for (i = 0; i<workstation_nb; i++)
- if(computation_amount[i]>0) nb_host++;
-
+ for (i = 0; i < workstation_nb; i++)
+ if (computation_amount[i] > 0)
+ nb_host++;
+
- if(nb_link + nb_host == 0) /* was workstation_nb... */
+ if (nb_link + nb_host == 0) /* was workstation_nb... */
return NULL;
action = xbt_new0(s_surf_action_workstation_KCCFLN05_t, 1);
DEBUG3("Creating a parallel task (%p) with %d cpus and %d links.",
- action, nb_host, nb_link);
+ action, nb_host, nb_link);
action->generic_action.using = 1;
action->generic_action.cost = amount;
action->generic_action.remains = amount;
action->generic_action.finish = -1.0;
action->generic_action.resource_type =
(surf_resource_t) surf_workstation_resource;
- action->suspended = 0; /* Should be useless because of the
- calloc but it seems to help valgrind... */
+ action->suspended = 0; /* Should be useless because of the
+ calloc but it seems to help valgrind... */
action->generic_action.state_set =
surf_workstation_resource->common_public->states.running_action_set;
xbt_swag_insert(action, action->generic_action.state_set);
action->rate = rate;
- if(action->rate>0)
+ if (action->rate > 0)
action->variable = lmm_variable_new(maxmin_system, action, 1.0, -1.0,
nb_host + nb_link);
- else
- action->variable = lmm_variable_new(maxmin_system, action, 1.0, action->rate,
- nb_host + nb_link);
-
- for (i = 0; i<workstation_nb; i++)
- if(computation_amount[i]>0)
- lmm_expand(maxmin_system, ((cpu_KCCFLN05_t) workstation_list[i])->constraint,
+ else
+ action->variable =
+ lmm_variable_new(maxmin_system, action, 1.0, action->rate,
+ nb_host + nb_link);
+
+ for (i = 0; i < workstation_nb; i++)
+ if (computation_amount[i] > 0)
+ lmm_expand(maxmin_system,
+ ((cpu_KCCFLN05_t) workstation_list[i])->constraint,
action->variable, computation_amount[i]);
- for (i=0; i<workstation_nb; i++) {
- for(j=0; j< workstation_nb; j++) {
+ for (i = 0; i < workstation_nb; i++) {
+ for (j = 0; j < workstation_nb; j++) {
cpu_KCCFLN05_t card_src = workstation_list[i];
cpu_KCCFLN05_t card_dst = workstation_list[j];
int route_size = ROUTE(card_src->id, card_dst->id).size;
- network_link_KCCFLN05_t *route = ROUTE(card_src->id, card_dst->id).links;
-
- for(k=0; k< route_size; k++) {
- if(communication_amount[i*workstation_nb+j]>0) {
- lmm_expand_add(maxmin_system, route[k]->constraint,
- action->variable, communication_amount[i*workstation_nb+j]);
+ network_link_KCCFLN05_t *route =
+ ROUTE(card_src->id, card_dst->id).links;
+
+ for (k = 0; k < route_size; k++) {
+ if (communication_amount[i * workstation_nb + j] > 0) {
+ lmm_expand_add(maxmin_system, route[k]->constraint,
+ action->variable,
+ communication_amount[i * workstation_nb + j]);
}
}
}
}
-
+
return (surf_action_t) action;
}
/* returns an array of network_link_KCCFLN05_t */
-static const void** get_route(void *src, void *dst) {
+static const void **get_route(void *src, void *dst)
+{
cpu_KCCFLN05_t card_src = src;
cpu_KCCFLN05_t card_dst = dst;
route_KCCFLN05_t route = &(ROUTE(card_src->id, card_dst->id));
- return (const void**) route->links;
+ return (const void **) route->links;
}
-static int get_route_size(void *src, void *dst) {
+static int get_route_size(void *src, void *dst)
+{
cpu_KCCFLN05_t card_src = src;
cpu_KCCFLN05_t card_dst = dst;
route_KCCFLN05_t route = &(ROUTE(card_src->id, card_dst->id));
return route->size;
}
-static const char *get_link_name(const void *link) {
+static const char *get_link_name(const void *link)
+{
return ((network_link_KCCFLN05_t) link)->name;
}
-static double get_link_bandwidth(const void *link) {
+static double get_link_bandwidth(const void *link)
+{
return ((network_link_KCCFLN05_t) link)->bw_current;
}
-static double get_link_latency(const void *link) {
+static double get_link_latency(const void *link)
+{
return ((network_link_KCCFLN05_t) link)->lat_current;
}
static void router_free(void *router)
{
- free( ((router_KCCFLN05_t) router)->name );
+ free(((router_KCCFLN05_t) router)->name);
}
static void router_new(const char *name)
{
- static unsigned int nb_routers = 0;
+ static unsigned int nb_routers = 0;
INFO1("Creating a router %s", name);
router = xbt_new0(s_router_KCCFLN05_t, 1);
router->name = xbt_strdup(name);
- router->id = nb_routers++;
+ router->id = nb_routers++;
xbt_dict_set(router_set, name, router, router_free);
}
if (A_surfxml_cpu_state == A_surfxml_cpu_state_OFF)
state_initial = SURF_CPU_OFF;
surf_parse_get_trace(&state_trace, A_surfxml_cpu_state_file);
-
+
surf_parse_get_double(&interference_send,
A_surfxml_cpu_interference_send);
surf_parse_get_double(&interference_recv,
e_surf_network_link_state_t
state_initial,
tmgr_trace_t state_trace,
- e_surf_network_link_sharing_policy_t policy)
+ e_surf_network_link_sharing_policy_t
+ policy)
{
network_link_KCCFLN05_t nw_link = xbt_new0(s_network_link_KCCFLN05_t, 1);
nw_link->constraint =
lmm_constraint_new(maxmin_system, nw_link, nw_link->bw_current);
- if(policy == SURF_NETWORK_LINK_FATPIPE)
+ if (policy == SURF_NETWORK_LINK_FATPIPE)
lmm_constraint_shared(nw_link->constraint);
xbt_dict_set(network_link_set, name, nw_link, network_link_free);
double lat_initial;
tmgr_trace_t lat_trace;
e_surf_network_link_state_t state_initial = SURF_NETWORK_LINK_ON;
- e_surf_network_link_sharing_policy_t policy_initial = SURF_NETWORK_LINK_SHARED;
+ e_surf_network_link_sharing_policy_t policy_initial =
+ SURF_NETWORK_LINK_SHARED;
tmgr_trace_t state_trace;
name = xbt_strdup(A_surfxml_network_link_name);
- surf_parse_get_double(&bw_initial,A_surfxml_network_link_bandwidth);
+ surf_parse_get_double(&bw_initial, A_surfxml_network_link_bandwidth);
surf_parse_get_trace(&bw_trace, A_surfxml_network_link_bandwidth_file);
- surf_parse_get_double(&lat_initial,A_surfxml_network_link_latency);
+ surf_parse_get_double(&lat_initial, A_surfxml_network_link_latency);
surf_parse_get_trace(&lat_trace, A_surfxml_network_link_latency_file);
- xbt_assert0((A_surfxml_network_link_state==A_surfxml_network_link_state_ON)||
- (A_surfxml_network_link_state==A_surfxml_network_link_state_OFF),
- "Invalid state");
- if (A_surfxml_network_link_state==A_surfxml_network_link_state_ON)
+ xbt_assert0((A_surfxml_network_link_state ==
+ A_surfxml_network_link_state_ON)
+ || (A_surfxml_network_link_state ==
+ A_surfxml_network_link_state_OFF), "Invalid state");
+ if (A_surfxml_network_link_state == A_surfxml_network_link_state_ON)
state_initial = SURF_NETWORK_LINK_ON;
- else if (A_surfxml_network_link_state==A_surfxml_network_link_state_OFF)
+ else if (A_surfxml_network_link_state ==
+ A_surfxml_network_link_state_OFF)
state_initial = SURF_NETWORK_LINK_OFF;
- if (A_surfxml_network_link_sharing_policy==A_surfxml_network_link_sharing_policy_SHARED)
+ if (A_surfxml_network_link_sharing_policy ==
+ A_surfxml_network_link_sharing_policy_SHARED)
policy_initial = SURF_NETWORK_LINK_SHARED;
- else if (A_surfxml_network_link_sharing_policy==A_surfxml_network_link_sharing_policy_FATPIPE)
+ else if (A_surfxml_network_link_sharing_policy ==
+ A_surfxml_network_link_sharing_policy_FATPIPE)
policy_initial = SURF_NETWORK_LINK_FATPIPE;
- surf_parse_get_trace(&state_trace,A_surfxml_network_link_state_file);
+ surf_parse_get_trace(&state_trace, A_surfxml_network_link_state_file);
network_link_new(name, bw_initial, bw_trace,
lat_initial, lat_trace, state_initial, state_trace,
policy_initial);
}
-static void route_new(int src_id, int dst_id, network_link_KCCFLN05_t *link_list, int nb_link,
+static void route_new(int src_id, int dst_id,
+ network_link_KCCFLN05_t * link_list, int nb_link,
double impact_on_src, double impact_on_dst,
double impact_on_src_with_other_recv,
double impact_on_dst_with_other_send)
route_KCCFLN05_t route = &(ROUTE(src_id, dst_id));
route->size = nb_link;
- route->links = link_list = xbt_realloc(link_list, sizeof(network_link_KCCFLN05_t) * nb_link);
+ route->links = link_list =
+ xbt_realloc(link_list, sizeof(network_link_KCCFLN05_t) * nb_link);
route->impact_on_src = impact_on_src;
route->impact_on_dst = impact_on_src;
route->impact_on_src_with_other_recv = impact_on_src_with_other_recv;
static void parse_route_set_endpoints(void)
{
cpu_KCCFLN05_t cpu_tmp = NULL;
-
+
cpu_tmp = (cpu_KCCFLN05_t) name_service(A_surfxml_route_src);
- if(cpu_tmp != NULL) {
+ if (cpu_tmp != NULL) {
src_id = cpu_tmp->id;
- }else {
+ } else {
xbt_assert1(xbt_dict_get_or_null(router_set, A_surfxml_route_src),
- "Invalid name '%s': neither a cpu nor a router!",
- A_surfxml_route_src);
- src_id=-1;
+ "Invalid name '%s': neither a cpu nor a router!",
+ A_surfxml_route_src);
+ src_id = -1;
return;
}
cpu_tmp = (cpu_KCCFLN05_t) name_service(A_surfxml_route_dst);
- if(cpu_tmp != NULL) {
+ if (cpu_tmp != NULL) {
dst_id = cpu_tmp->id;
- }else {
+ } else {
xbt_assert1(xbt_dict_get_or_null(router_set, A_surfxml_route_dst),
- "Invalid name '%s': neither a cpu nor a router!",
- A_surfxml_route_dst);
- dst_id=-1;
- return ;
+ "Invalid name '%s': neither a cpu nor a router!",
+ A_surfxml_route_dst);
+ dst_id = -1;
+ return;
}
-
+
surf_parse_get_double(&impact_on_src, A_surfxml_route_impact_on_src);
surf_parse_get_double(&impact_on_dst, A_surfxml_route_impact_on_dst);
surf_parse_get_double(&impact_on_src_with_other_recv,
A_surfxml_route_impact_on_src_with_other_recv);
surf_parse_get_double(&impact_on_dst_with_other_send,
A_surfxml_route_impact_on_dst_with_other_send);
-
+
nb_link = 0;
- link_list_capacity = 1;
+ link_list_capacity = 1;
link_list = xbt_new(network_link_KCCFLN05_t, link_list_capacity);
}
xbt_ex_t e;
if (nb_link == link_list_capacity) {
link_list_capacity *= 2;
- link_list = xbt_realloc(link_list, (link_list_capacity) * sizeof(network_link_KCCFLN05_t));
+ link_list =
+ xbt_realloc(link_list,
+ (link_list_capacity) *
+ sizeof(network_link_KCCFLN05_t));
}
TRY {
- link_list[nb_link++] = xbt_dict_get(network_link_set, A_surfxml_route_element_name);
- } CATCH(e) {
- RETHROW1("Link %s not found (dict raised this exception: %s)",A_surfxml_route_element_name);
+ link_list[nb_link++] =
+ xbt_dict_get(network_link_set, A_surfxml_route_element_name);
+ }
+ CATCH(e) {
+ RETHROW1("Link %s not found (dict raised this exception: %s)",
+ A_surfxml_route_element_name);
}
}
static void parse_route_set_route(void)
{
- if( src_id != -1 && dst_id != -1 )
- route_new(src_id, dst_id, link_list, nb_link, impact_on_src,
- impact_on_dst, impact_on_src_with_other_recv,
- impact_on_dst_with_other_send);
+ if (src_id != -1 && dst_id != -1)
+ route_new(src_id, dst_id, link_list, nb_link, impact_on_src,
+ impact_on_dst, impact_on_src_with_other_recv,
+ impact_on_dst_with_other_send);
}
static void parse_file(const char *file)
/* Figuring out the router (added after GTNETS) */
surf_parse_reset_parser();
- STag_surfxml_router_fun=parse_routers;
+ STag_surfxml_router_fun = parse_routers;
surf_parse_open(file);
- xbt_assert1((!surf_parse()),"Parse error in %s",file);
+ xbt_assert1((!surf_parse()), "Parse error in %s", file);
surf_parse_close();
/* Figuring out the network links */
xbt_assert1((!surf_parse()), "Parse error in %s", file);
surf_parse_close();
- /* Adding loopback if needed */
- for (i = 0; i < nb_workstation; i++)
- if(!ROUTE(i,i).size) {
- if(!loopback)
- loopback = network_link_new(xbt_strdup("__MSG_loopback__"),
- 498000000, NULL, 0.000015, NULL,
- SURF_NETWORK_LINK_ON, NULL,
- SURF_NETWORK_LINK_FATPIPE);
- ROUTE(i,i).size=1;
- ROUTE(i,i).links = xbt_new0(network_link_KCCFLN05_t, 1);
- ROUTE(i,i).links[0] = loopback;
+ /* Adding loopback if needed */
+ for (i = 0; i < nb_workstation; i++)
+ if (!ROUTE(i, i).size) {
+ if (!loopback)
+ loopback = network_link_new(xbt_strdup("__MSG_loopback__"),
+ 498000000, NULL, 0.000015, NULL,
+ SURF_NETWORK_LINK_ON, NULL,
+ SURF_NETWORK_LINK_FATPIPE);
+ ROUTE(i, i).size = 1;
+ ROUTE(i, i).links = xbt_new0(network_link_KCCFLN05_t, 1);
+ ROUTE(i, i).links[0] = loopback;
}
}
xbt_swag_new(xbt_swag_offset(action, state_hookup));
surf_workstation_resource->common_public->name_service = name_service;
- surf_workstation_resource->common_public->get_resource_name = get_resource_name;
- surf_workstation_resource->common_public->action_get_state = surf_action_get_state;
+ surf_workstation_resource->common_public->get_resource_name =
+ get_resource_name;
+ surf_workstation_resource->common_public->action_get_state =
+ surf_action_get_state;
surf_workstation_resource->common_public->action_get_start_time =
surf_action_get_start_time;
surf_workstation_resource->common_public->action_get_finish_time =
surf_workstation_resource->common_public->action_use = action_use;
surf_workstation_resource->common_public->action_free = action_free;
surf_workstation_resource->common_public->action_cancel = action_cancel;
- surf_workstation_resource->common_public->action_recycle = action_recycle;
- surf_workstation_resource->common_public->action_change_state = surf_action_change_state;
- surf_workstation_resource->common_public->action_set_data = surf_action_set_data;
+ surf_workstation_resource->common_public->action_recycle =
+ action_recycle;
+ surf_workstation_resource->common_public->action_change_state =
+ surf_action_change_state;
+ surf_workstation_resource->common_public->action_set_data =
+ surf_action_set_data;
surf_workstation_resource->common_public->suspend = action_suspend;
surf_workstation_resource->common_public->resume = action_resume;
- surf_workstation_resource->common_public->is_suspended = action_is_suspended;
- surf_workstation_resource->common_public->set_max_duration = action_set_max_duration;
- surf_workstation_resource->common_public->set_priority = action_set_priority;
+ surf_workstation_resource->common_public->is_suspended =
+ action_is_suspended;
+ surf_workstation_resource->common_public->set_max_duration =
+ action_set_max_duration;
+ surf_workstation_resource->common_public->set_priority =
+ action_set_priority;
surf_workstation_resource->common_public->name = "Workstation KCCFLN05";
surf_workstation_resource->common_private->resource_used = resource_used;
- surf_workstation_resource->common_private->share_resources = share_resources;
- surf_workstation_resource->common_private->update_actions_state = update_actions_state;
- surf_workstation_resource->common_private->update_resource_state = update_resource_state;
+ surf_workstation_resource->common_private->share_resources =
+ share_resources;
+ surf_workstation_resource->common_private->update_actions_state =
+ update_actions_state;
+ surf_workstation_resource->common_private->update_resource_state =
+ update_resource_state;
surf_workstation_resource->common_private->finalize = finalize;
surf_workstation_resource->extension_public->execute = execute;
surf_workstation_resource->extension_public->sleep = action_sleep;
- surf_workstation_resource->extension_public->get_state = resource_get_state;
+ surf_workstation_resource->extension_public->get_state =
+ resource_get_state;
surf_workstation_resource->extension_public->get_speed = get_speed;
- surf_workstation_resource->extension_public->get_available_speed = get_available_speed;
+ surf_workstation_resource->extension_public->get_available_speed =
+ get_available_speed;
surf_workstation_resource->extension_public->communicate = communicate;
- surf_workstation_resource->extension_public->execute_parallel_task = execute_parallel_task;
+ surf_workstation_resource->extension_public->execute_parallel_task =
+ execute_parallel_task;
surf_workstation_resource->extension_public->get_route = get_route;
- surf_workstation_resource->extension_public->get_route_size = get_route_size;
- surf_workstation_resource->extension_public->get_link_name = get_link_name;
- surf_workstation_resource->extension_public->get_link_bandwidth = get_link_bandwidth;
- surf_workstation_resource->extension_public->get_link_latency = get_link_latency;
-
- workstation_set = xbt_dict_new();
- router_set = xbt_dict_new();
+ surf_workstation_resource->extension_public->get_route_size =
+ get_route_size;
+ surf_workstation_resource->extension_public->get_link_name =
+ get_link_name;
+ surf_workstation_resource->extension_public->get_link_bandwidth =
+ get_link_bandwidth;
+ surf_workstation_resource->extension_public->get_link_latency =
+ get_link_latency;
+
+ workstation_set = xbt_dict_new();
+ router_set = xbt_dict_new();
network_link_set = xbt_dict_new();
xbt_assert0(maxmin_system, "surf_init has to be called first!");
void surf_workstation_resource_init_KCCFLN05(const char *filename)
{
xbt_assert0(!surf_cpu_resource, "CPU resource type already defined");
- xbt_assert0(!surf_network_resource, "network resource type already defined");
+ xbt_assert0(!surf_network_resource,
+ "network resource type already defined");
resource_init_internal();
parse_file(filename);
/********* cpu object *****************/
/**************************************/
typedef struct cpu_L07 {
- surf_resource_t resource; /* Do not move this field */
+ surf_resource_t resource; /* Do not move this field */
e_surf_workstation_resource_type_t type; /* Do not move this field */
- char *name; /* Do not move this field */
- lmm_constraint_t constraint; /* Do not move this field */
+ char *name; /* Do not move this field */
+ lmm_constraint_t constraint; /* Do not move this field */
double power_scale;
double power_current;
tmgr_trace_event_t power_event;
/**************************************/
typedef struct network_link_L07 {
- surf_resource_t resource; /* Do not move this field */
+ surf_resource_t resource; /* Do not move this field */
e_surf_workstation_resource_type_t type; /* Do not move this field */
- char *name; /* Do not move this field */
- lmm_constraint_t constraint; /* Do not move this field */
+ char *name; /* Do not move this field */
+ lmm_constraint_t constraint; /* Do not move this field */
double bw_current;
tmgr_trace_event_t bw_event;
e_surf_network_link_state_t state_current;
lmm_variable_t variable;
double rate;
int suspended;
-} s_surf_action_workstation_L07_t,
- *surf_action_workstation_L07_t;
+} s_surf_action_workstation_L07_t, *surf_action_workstation_L07_t;
XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_workstation);
static void action_suspend(surf_action_t action)
{
- XBT_IN1("(%p))",action);
- if(((surf_action_workstation_L07_t) action)->suspended != 2) {
+ XBT_IN1("(%p))", action);
+ if (((surf_action_workstation_L07_t) action)->suspended != 2) {
((surf_action_workstation_L07_t) action)->suspended = 1;
lmm_update_variable_weight(ptask_maxmin_system,
((surf_action_workstation_L07_t)
static void action_resume(surf_action_t action)
{
- XBT_IN1("(%p)",action);
- if(((surf_action_workstation_L07_t) action)->suspended !=2) {
+ XBT_IN1("(%p)", action);
+ if (((surf_action_workstation_L07_t) action)->suspended != 2) {
lmm_update_variable_weight(ptask_maxmin_system,
((surf_action_workstation_L07_t)
action)->variable, 1.0);
static int action_is_suspended(surf_action_t action)
{
- return (((surf_action_workstation_L07_t) action)->suspended==1);
+ return (((surf_action_workstation_L07_t) action)->suspended == 1);
}
static void action_set_max_duration(surf_action_t action, double duration)
{ /* FIXME: should inherit */
- XBT_IN2("(%p,%g)",action,duration);
+ XBT_IN2("(%p,%g)", action, duration);
action->max_duration = duration;
XBT_OUT;
}
static void action_set_priority(surf_action_t action, double priority)
{ /* FIXME: should inherit */
- XBT_IN2("(%p,%g)",action,priority);
+ XBT_IN2("(%p,%g)", action, priority);
action->priority = priority;
XBT_OUT;
}
{
s_surf_action_workstation_L07_t s_action;
- xbt_swag_t running_actions =
- surf_workstation_resource->common_public->states.running_action_set;
- double min =
- generic_maxmin_share_resources2(running_actions,
- xbt_swag_offset(s_action, variable),
- ptask_maxmin_system, bottleneck_solve);
-
- DEBUG1("min value : %f",min);
+ xbt_swag_t running_actions =
+ surf_workstation_resource->common_public->states.running_action_set;
+ double min = generic_maxmin_share_resources2(running_actions,
+ xbt_swag_offset(s_action,
+ variable),
+ ptask_maxmin_system,
+ bottleneck_solve);
+
+ DEBUG1("min value : %f", min);
return min;
}
if (action->generic_action.max_duration != NO_MAX_DURATION)
double_update(&(action->generic_action.max_duration), delta);
- if ((action->generic_action.remains <= 0) &&
- (lmm_get_variable_weight(action->variable)>0)) {
+ if ((action->generic_action.remains <= 0) &&
+ (lmm_get_variable_weight(action->variable) > 0)) {
action->generic_action.finish = surf_get_clock();
surf_action_change_state((surf_action_t) action, SURF_ACTION_DONE);
} else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
/* ((cpu_L07_t)constraint_id)->state_current==SURF_CPU_OFF?"Off":"On"); */
/* } */
- if(((((network_link_L07_t)constraint_id)->type==
- SURF_WORKSTATION_RESOURCE_LINK) &&
- (((network_link_L07_t)constraint_id)->state_current==
- SURF_NETWORK_LINK_OFF)) ||
- ((((cpu_L07_t)constraint_id)->type==
- SURF_WORKSTATION_RESOURCE_CPU) &&
- (((cpu_L07_t)constraint_id)->state_current==
- SURF_CPU_OFF))) {
- DEBUG1("Action (%p) Failed!!",action);
+ if (((((network_link_L07_t) constraint_id)->type ==
+ SURF_WORKSTATION_RESOURCE_LINK) &&
+ (((network_link_L07_t) constraint_id)->state_current ==
+ SURF_NETWORK_LINK_OFF)) ||
+ ((((cpu_L07_t) constraint_id)->type ==
+ SURF_WORKSTATION_RESOURCE_CPU) &&
+ (((cpu_L07_t) constraint_id)->state_current ==
+ SURF_CPU_OFF))) {
+ DEBUG1("Action (%p) Failed!!", action);
action->generic_action.finish = surf_get_clock();
- surf_action_change_state((surf_action_t) action, SURF_ACTION_FAILED);
+ surf_action_change_state((surf_action_t) action,
+ SURF_ACTION_FAILED);
break;
}
}
double value)
{
cpu_L07_t cpu = id;
- network_link_L07_t nw_link = id ;
+ network_link_L07_t nw_link = id;
- if(nw_link->type == SURF_WORKSTATION_RESOURCE_LINK) {
- DEBUG2("Updating link %s (%p)",nw_link->name,nw_link);
+ if (nw_link->type == SURF_WORKSTATION_RESOURCE_LINK) {
+ DEBUG2("Updating link %s (%p)", nw_link->name, nw_link);
if (event_type == nw_link->bw_event) {
nw_link->bw_current = value;
lmm_update_constraint_bound(ptask_maxmin_system, nw_link->constraint,
xbt_abort();
}
return;
- } else if(cpu->type == SURF_WORKSTATION_RESOURCE_CPU) {
- DEBUG3("Updating cpu %s (%p) with value %g",cpu->name,cpu,value);
+ } else if (cpu->type == SURF_WORKSTATION_RESOURCE_CPU) {
+ DEBUG3("Updating cpu %s (%p) with value %g", cpu->name, cpu, value);
if (event_type == cpu->power_event) {
cpu->power_current = value;
lmm_update_constraint_bound(ptask_maxmin_system, cpu->constraint,
static void finalize(void)
{
- int i,j;
+ int i, j;
xbt_dict_free(&network_link_set);
xbt_dict_free(&workstation_set);
static double get_speed(void *cpu, double load)
{
- return load*(((cpu_L07_t) cpu)->power_scale);
+ return load * (((cpu_L07_t) cpu)->power_scale);
}
static double get_available_speed(void *cpu)
}
static surf_action_t execute_parallel_task(int workstation_nb,
- void **workstation_list,
- double *computation_amount,
+ void **workstation_list,
+ double *computation_amount,
double *communication_amount,
- double amount,
- double rate)
+ double amount, double rate)
{
surf_action_workstation_L07_t action = NULL;
int i, j, k;
int nb_host = 0;
if (parallel_task_network_link_set == NULL) {
- parallel_task_network_link_set = xbt_dict_new_ext(workstation_nb * workstation_nb * 10);
+ parallel_task_network_link_set =
+ xbt_dict_new_ext(workstation_nb * workstation_nb * 10);
}
-
+
/* Compute the number of affected resources... */
- for(i=0; i< workstation_nb; i++) {
- for(j=0; j< workstation_nb; j++) {
+ for (i = 0; i < workstation_nb; i++) {
+ for (j = 0; j < workstation_nb; j++) {
cpu_L07_t card_src = workstation_list[i];
cpu_L07_t card_dst = workstation_list[j];
int route_size = ROUTE(card_src->id, card_dst->id).size;
network_link_L07_t *route = ROUTE(card_src->id, card_dst->id).links;
-
- if(communication_amount[i*workstation_nb+j]>0)
- for(k=0; k< route_size; k++) {
- xbt_dict_set(parallel_task_network_link_set, route[k]->name, route[k], NULL);
+
+ if (communication_amount[i * workstation_nb + j] > 0)
+ for (k = 0; k < route_size; k++) {
+ xbt_dict_set(parallel_task_network_link_set, route[k]->name,
+ route[k], NULL);
}
}
}
xbt_dict_reset(parallel_task_network_link_set);
- for (i = 0; i<workstation_nb; i++)
- if(computation_amount[i]>0) nb_host++;
-
+ for (i = 0; i < workstation_nb; i++)
+ if (computation_amount[i] > 0)
+ nb_host++;
+
- if(nb_link + nb_host == 0) /* was workstation_nb... */
+ if (nb_link + nb_host == 0) /* was workstation_nb... */
return NULL;
action = xbt_new0(s_surf_action_workstation_L07_t, 1);
DEBUG3("Creating a parallel task (%p) with %d cpus and %d links.",
- action, nb_host, nb_link);
+ action, nb_host, nb_link);
action->generic_action.using = 1;
action->generic_action.cost = amount;
action->generic_action.remains = amount;
action->generic_action.finish = -1.0;
action->generic_action.resource_type =
(surf_resource_t) surf_workstation_resource;
- action->suspended = 0; /* Should be useless because of the
- calloc but it seems to help valgrind... */
+ action->suspended = 0; /* Should be useless because of the
+ calloc but it seems to help valgrind... */
action->generic_action.state_set =
surf_workstation_resource->common_public->states.running_action_set;
xbt_swag_insert(action, action->generic_action.state_set);
action->rate = rate;
- if(action->rate>0)
- action->variable = lmm_variable_new(ptask_maxmin_system, action, 1.0, -1.0,
- nb_host + nb_link);
- else
- action->variable = lmm_variable_new(ptask_maxmin_system, action, 1.0, action->rate,
- nb_host + nb_link);
-
- for (i = 0; i<workstation_nb; i++)
- if(computation_amount[i]>0)
- lmm_expand(ptask_maxmin_system, ((cpu_L07_t) workstation_list[i])->constraint,
+ if (action->rate > 0)
+ action->variable =
+ lmm_variable_new(ptask_maxmin_system, action, 1.0, -1.0,
+ nb_host + nb_link);
+ else
+ action->variable =
+ lmm_variable_new(ptask_maxmin_system, action, 1.0, action->rate,
+ nb_host + nb_link);
+
+ for (i = 0; i < workstation_nb; i++)
+ if (computation_amount[i] > 0)
+ lmm_expand(ptask_maxmin_system,
+ ((cpu_L07_t) workstation_list[i])->constraint,
action->variable, computation_amount[i]);
- for (i=0; i<workstation_nb; i++) {
- for(j=0; j< workstation_nb; j++) {
+ for (i = 0; i < workstation_nb; i++) {
+ for (j = 0; j < workstation_nb; j++) {
cpu_L07_t card_src = workstation_list[i];
cpu_L07_t card_dst = workstation_list[j];
int route_size = ROUTE(card_src->id, card_dst->id).size;
network_link_L07_t *route = ROUTE(card_src->id, card_dst->id).links;
-
- for(k=0; k< route_size; k++) {
- if(communication_amount[i*workstation_nb+j]>0) {
- lmm_expand_add(ptask_maxmin_system, route[k]->constraint,
- action->variable, communication_amount[i*workstation_nb+j]);
+
+ for (k = 0; k < route_size; k++) {
+ if (communication_amount[i * workstation_nb + j] > 0) {
+ lmm_expand_add(ptask_maxmin_system, route[k]->constraint,
+ action->variable,
+ communication_amount[i * workstation_nb + j]);
}
}
}
}
-
+
return (surf_action_t) action;
}
return execute_parallel_task(1, &cpu, &size, &val, 1, -1);
}
-static surf_action_t communicate(void *src, void *dst, double size, double rate)
+static surf_action_t communicate(void *src, void *dst, double size,
+ double rate)
{
- void **workstation_list = xbt_new0(void*,2);
- double *computation_amount = xbt_new0(double,2);
- double *communication_amount = xbt_new0(double,4);
+ void **workstation_list = xbt_new0(void *, 2);
+ double *computation_amount = xbt_new0(double, 2);
+ double *communication_amount = xbt_new0(double, 4);
surf_action_t res = NULL;
- workstation_list[0]=src;
- workstation_list[1]=src;
+ workstation_list[0] = src;
+ workstation_list[1] = src;
communication_amount[1] = size;
- res = execute_parallel_task(2, workstation_list,
+ res = execute_parallel_task(2, workstation_list,
computation_amount, communication_amount,
1, rate);
-
+
free(computation_amount);
free(communication_amount);
free(workstation_list);
{
surf_action_workstation_L07_t action = NULL;
- XBT_IN2("(%s,%g)",((cpu_L07_t)cpu)->name,duration);
+ XBT_IN2("(%s,%g)", ((cpu_L07_t) cpu)->name, duration);
action = (surf_action_workstation_L07_t) execute(cpu, 1.0);
action->generic_action.max_duration = duration;
}
/* returns an array of network_link_L07_t */
-static const void** get_route(void *src, void *dst) {
+static const void **get_route(void *src, void *dst)
+{
cpu_L07_t card_src = src;
cpu_L07_t card_dst = dst;
route_L07_t route = &(ROUTE(card_src->id, card_dst->id));
- return (const void**) route->links;
+ return (const void **) route->links;
}
-static int get_route_size(void *src, void *dst) {
+static int get_route_size(void *src, void *dst)
+{
cpu_L07_t card_src = src;
cpu_L07_t card_dst = dst;
route_L07_t route = &(ROUTE(card_src->id, card_dst->id));
return route->size;
}
-static const char *get_link_name(const void *link) {
+static const char *get_link_name(const void *link)
+{
return ((network_link_L07_t) link)->name;
}
-static double get_link_bandwidth(const void *link) {
+static double get_link_bandwidth(const void *link)
+{
return ((network_link_L07_t) link)->bw_current;
}
-static double get_link_latency(const void *link) {
- xbt_assert0(0,"This model does not implement latencies");
+static double get_link_latency(const void *link)
+{
+ xbt_assert0(0, "This model does not implement latencies");
}
/**************************************/
}
static cpu_L07_t cpu_new(const char *name, double power_scale,
- double power_initial,
- tmgr_trace_t power_trace,
- e_surf_cpu_state_t state_initial,
- tmgr_trace_t state_trace)
+ double power_initial,
+ tmgr_trace_t power_trace,
+ e_surf_cpu_state_t state_initial,
+ tmgr_trace_t state_trace)
{
cpu_L07_t cpu = xbt_new0(s_cpu_L07_t, 1);
if (A_surfxml_cpu_state == A_surfxml_cpu_state_OFF)
state_initial = SURF_CPU_OFF;
surf_parse_get_trace(&state_trace, A_surfxml_cpu_state_file);
-
+
cpu_new(A_surfxml_cpu_name, power_scale, power_initial, power_trace,
state_initial, state_trace);
}
static void create_routing_table(void)
{
- routing_table =
- xbt_new0(s_route_L07_t, nb_workstation * nb_workstation);
+ routing_table = xbt_new0(s_route_L07_t, nb_workstation * nb_workstation);
}
static void network_link_free(void *nw_link)
}
static network_link_L07_t network_link_new(char *name,
- double bw_initial,
- tmgr_trace_t bw_trace,
- e_surf_network_link_state_t
- state_initial,
- tmgr_trace_t state_trace,
- e_surf_network_link_sharing_policy_t policy)
+ double bw_initial,
+ tmgr_trace_t bw_trace,
+ e_surf_network_link_state_t
+ state_initial,
+ tmgr_trace_t state_trace,
+ e_surf_network_link_sharing_policy_t
+ policy)
{
network_link_L07_t nw_link = xbt_new0(s_network_link_L07_t, 1);
tmgr_history_add_trace(history, state_trace, 0.0, 0, nw_link);
nw_link->constraint =
- lmm_constraint_new(ptask_maxmin_system, nw_link, nw_link->bw_current);
+ lmm_constraint_new(ptask_maxmin_system, nw_link,
+ nw_link->bw_current);
- if(policy == SURF_NETWORK_LINK_FATPIPE)
+ if (policy == SURF_NETWORK_LINK_FATPIPE)
lmm_constraint_shared(nw_link->constraint);
xbt_dict_set(network_link_set, name, nw_link, network_link_free);
double bw_initial;
tmgr_trace_t bw_trace;
e_surf_network_link_state_t state_initial = SURF_NETWORK_LINK_ON;
- e_surf_network_link_sharing_policy_t policy_initial = SURF_NETWORK_LINK_SHARED;
+ e_surf_network_link_sharing_policy_t policy_initial =
+ SURF_NETWORK_LINK_SHARED;
tmgr_trace_t state_trace;
name = xbt_strdup(A_surfxml_network_link_name);
- surf_parse_get_double(&bw_initial,A_surfxml_network_link_bandwidth);
+ surf_parse_get_double(&bw_initial, A_surfxml_network_link_bandwidth);
surf_parse_get_trace(&bw_trace, A_surfxml_network_link_bandwidth_file);
- xbt_assert0((A_surfxml_network_link_state==A_surfxml_network_link_state_ON)||
- (A_surfxml_network_link_state==A_surfxml_network_link_state_OFF),
- "Invalid state");
- if (A_surfxml_network_link_state==A_surfxml_network_link_state_ON)
+ xbt_assert0((A_surfxml_network_link_state ==
+ A_surfxml_network_link_state_ON)
+ || (A_surfxml_network_link_state ==
+ A_surfxml_network_link_state_OFF), "Invalid state");
+ if (A_surfxml_network_link_state == A_surfxml_network_link_state_ON)
state_initial = SURF_NETWORK_LINK_ON;
- else if (A_surfxml_network_link_state==A_surfxml_network_link_state_OFF)
+ else if (A_surfxml_network_link_state ==
+ A_surfxml_network_link_state_OFF)
state_initial = SURF_NETWORK_LINK_OFF;
- if (A_surfxml_network_link_sharing_policy==A_surfxml_network_link_sharing_policy_SHARED)
+ if (A_surfxml_network_link_sharing_policy ==
+ A_surfxml_network_link_sharing_policy_SHARED)
policy_initial = SURF_NETWORK_LINK_SHARED;
- else if (A_surfxml_network_link_sharing_policy==A_surfxml_network_link_sharing_policy_FATPIPE)
+ else if (A_surfxml_network_link_sharing_policy ==
+ A_surfxml_network_link_sharing_policy_FATPIPE)
policy_initial = SURF_NETWORK_LINK_FATPIPE;
- surf_parse_get_trace(&state_trace,A_surfxml_network_link_state_file);
+ surf_parse_get_trace(&state_trace, A_surfxml_network_link_state_file);
network_link_new(name, bw_initial, bw_trace, state_initial, state_trace,
policy_initial);
}
-static void route_new(int src_id, int dst_id, network_link_L07_t *link_list, int nb_link)
+static void route_new(int src_id, int dst_id,
+ network_link_L07_t * link_list, int nb_link)
{
route_L07_t route = &(ROUTE(src_id, dst_id));
route->size = nb_link;
- route->links = link_list = xbt_realloc(link_list, sizeof(network_link_L07_t) * nb_link);
+ route->links = link_list =
+ xbt_realloc(link_list, sizeof(network_link_L07_t) * nb_link);
}
static int nb_link;
static void parse_route_set_endpoints(void)
{
cpu_L07_t cpu_tmp = NULL;
-
+
cpu_tmp = (cpu_L07_t) name_service(A_surfxml_route_src);
- xbt_assert1(cpu_tmp,"Invalid cpu %s",A_surfxml_route_src);
- if(cpu_tmp != NULL) src_id = cpu_tmp->id;
-
+ xbt_assert1(cpu_tmp, "Invalid cpu %s", A_surfxml_route_src);
+ if (cpu_tmp != NULL)
+ src_id = cpu_tmp->id;
+
cpu_tmp = (cpu_L07_t) name_service(A_surfxml_route_dst);
- xbt_assert1(cpu_tmp,"Invalid cpu %s",A_surfxml_route_dst);
- if(cpu_tmp != NULL) dst_id = cpu_tmp->id;
+ xbt_assert1(cpu_tmp, "Invalid cpu %s", A_surfxml_route_dst);
+ if (cpu_tmp != NULL)
+ dst_id = cpu_tmp->id;
nb_link = 0;
- link_list_capacity = 1;
+ link_list_capacity = 1;
link_list = xbt_new(network_link_L07_t, link_list_capacity);
}
xbt_ex_t e;
if (nb_link == link_list_capacity) {
link_list_capacity *= 2;
- link_list = xbt_realloc(link_list, (link_list_capacity) * sizeof(network_link_L07_t));
+ link_list =
+ xbt_realloc(link_list,
+ (link_list_capacity) * sizeof(network_link_L07_t));
}
TRY {
- link_list[nb_link++] = xbt_dict_get(network_link_set, A_surfxml_route_element_name);
- } CATCH(e) {
- RETHROW1("Link %s not found (dict raised this exception: %s)",A_surfxml_route_element_name);
+ link_list[nb_link++] =
+ xbt_dict_get(network_link_set, A_surfxml_route_element_name);
+ }
+ CATCH(e) {
+ RETHROW1("Link %s not found (dict raised this exception: %s)",
+ A_surfxml_route_element_name);
}
}
static void parse_route_set_route(void)
{
- if( src_id != -1 && dst_id != -1 )
- route_new(src_id, dst_id, link_list, nb_link);
+ if (src_id != -1 && dst_id != -1)
+ route_new(src_id, dst_id, link_list, nb_link);
}
static void parse_file(const char *file)
xbt_assert1((!surf_parse()), "Parse error in %s", file);
surf_parse_close();
- /* Adding loopback if needed */
- for (i = 0; i < nb_workstation; i++)
- if(!ROUTE(i,i).size) {
- if(!loopback)
- loopback = network_link_new(xbt_strdup("__MSG_loopback__"),
- 498000000, NULL,
- SURF_NETWORK_LINK_ON, NULL,
- SURF_NETWORK_LINK_FATPIPE);
-
- ROUTE(i,i).size=1;
- ROUTE(i,i).links = xbt_new0(network_link_L07_t, 1);
- ROUTE(i,i).links[0] = loopback;
+ /* Adding loopback if needed */
+ for (i = 0; i < nb_workstation; i++)
+ if (!ROUTE(i, i).size) {
+ if (!loopback)
+ loopback = network_link_new(xbt_strdup("__MSG_loopback__"),
+ 498000000, NULL,
+ SURF_NETWORK_LINK_ON, NULL,
+ SURF_NETWORK_LINK_FATPIPE);
+
+ ROUTE(i, i).size = 1;
+ ROUTE(i, i).links = xbt_new0(network_link_L07_t, 1);
+ ROUTE(i, i).links[0] = loopback;
}
}
xbt_swag_new(xbt_swag_offset(action, state_hookup));
surf_workstation_resource->common_public->name_service = name_service;
- surf_workstation_resource->common_public->get_resource_name = get_resource_name;
- surf_workstation_resource->common_public->action_get_state = surf_action_get_state;
+ surf_workstation_resource->common_public->get_resource_name =
+ get_resource_name;
+ surf_workstation_resource->common_public->action_get_state =
+ surf_action_get_state;
surf_workstation_resource->common_public->action_get_start_time =
surf_action_get_start_time;
surf_workstation_resource->common_public->action_get_finish_time =
surf_workstation_resource->common_public->action_use = action_use;
surf_workstation_resource->common_public->action_free = action_free;
surf_workstation_resource->common_public->action_cancel = action_cancel;
- surf_workstation_resource->common_public->action_recycle = action_recycle;
- surf_workstation_resource->common_public->action_change_state = surf_action_change_state;
- surf_workstation_resource->common_public->action_set_data = surf_action_set_data;
+ surf_workstation_resource->common_public->action_recycle =
+ action_recycle;
+ surf_workstation_resource->common_public->action_change_state =
+ surf_action_change_state;
+ surf_workstation_resource->common_public->action_set_data =
+ surf_action_set_data;
surf_workstation_resource->common_public->suspend = action_suspend;
surf_workstation_resource->common_public->resume = action_resume;
- surf_workstation_resource->common_public->is_suspended = action_is_suspended;
- surf_workstation_resource->common_public->set_max_duration = action_set_max_duration;
- surf_workstation_resource->common_public->set_priority = action_set_priority;
+ surf_workstation_resource->common_public->is_suspended =
+ action_is_suspended;
+ surf_workstation_resource->common_public->set_max_duration =
+ action_set_max_duration;
+ surf_workstation_resource->common_public->set_priority =
+ action_set_priority;
surf_workstation_resource->common_public->name = "Workstation ptask_L07";
surf_workstation_resource->common_private->resource_used = resource_used;
- surf_workstation_resource->common_private->share_resources = share_resources;
- surf_workstation_resource->common_private->update_actions_state = update_actions_state;
- surf_workstation_resource->common_private->update_resource_state = update_resource_state;
+ surf_workstation_resource->common_private->share_resources =
+ share_resources;
+ surf_workstation_resource->common_private->update_actions_state =
+ update_actions_state;
+ surf_workstation_resource->common_private->update_resource_state =
+ update_resource_state;
surf_workstation_resource->common_private->finalize = finalize;
surf_workstation_resource->extension_public->execute = execute;
surf_workstation_resource->extension_public->sleep = action_sleep;
- surf_workstation_resource->extension_public->get_state = resource_get_state;
+ surf_workstation_resource->extension_public->get_state =
+ resource_get_state;
surf_workstation_resource->extension_public->get_speed = get_speed;
- surf_workstation_resource->extension_public->get_available_speed = get_available_speed;
+ surf_workstation_resource->extension_public->get_available_speed =
+ get_available_speed;
surf_workstation_resource->extension_public->communicate = communicate;
- surf_workstation_resource->extension_public->execute_parallel_task = execute_parallel_task;
+ surf_workstation_resource->extension_public->execute_parallel_task =
+ execute_parallel_task;
surf_workstation_resource->extension_public->get_route = get_route;
- surf_workstation_resource->extension_public->get_route_size = get_route_size;
- surf_workstation_resource->extension_public->get_link_name = get_link_name;
- surf_workstation_resource->extension_public->get_link_bandwidth = get_link_bandwidth;
- surf_workstation_resource->extension_public->get_link_latency = get_link_latency;
-
- workstation_set = xbt_dict_new();
+ surf_workstation_resource->extension_public->get_route_size =
+ get_route_size;
+ surf_workstation_resource->extension_public->get_link_name =
+ get_link_name;
+ surf_workstation_resource->extension_public->get_link_bandwidth =
+ get_link_bandwidth;
+ surf_workstation_resource->extension_public->get_link_latency =
+ get_link_latency;
+
+ workstation_set = xbt_dict_new();
network_link_set = xbt_dict_new();
- if(!ptask_maxmin_system)
+ if (!ptask_maxmin_system)
ptask_maxmin_system = lmm_system_new();
}
void surf_workstation_resource_init_ptask_L07(const char *filename)
{
xbt_assert0(!surf_cpu_resource, "CPU resource type already defined");
- xbt_assert0(!surf_network_resource, "network resource type already defined");
+ xbt_assert0(!surf_network_resource,
+ "network resource type already defined");
resource_init_internal();
parse_file(filename);