#include "maxmin_private.h"
surf_model_t surf_cpu_model = NULL;
-lmm_system_t cpu_maxmin_system = NULL;
-e_UM_t cpu_update_mechanism = UM_UNDEFINED;
-static int cpu_selective_update = 0;
-
-static xbt_swag_t cpu_modified_set= NULL;
-static xbt_heap_t cpu_action_heap = NULL;
#undef GENERIC_LMM_ACTION
#undef GENERIC_ACTION
tmgr_history_add_trace(history, state_trace, 0.0, 0, cpu);
cpu->constraint =
- lmm_constraint_new(cpu_maxmin_system, cpu,
+ lmm_constraint_new(surf_cpu_model->maxmin_system, cpu,
cpu->core * cpu->power_scale * cpu->power_peak);
xbt_lib_set(host_lib, name, SURF_CPU_LEVEL, cpu);
static int cpu_resource_used(void *resource)
{
- return lmm_constraint_used(cpu_maxmin_system,
+ return lmm_constraint_used(surf_cpu_model->maxmin_system,
((cpu_Cas01_t) resource)->constraint);
}
if (!action->refcount) {
xbt_swag_remove(action, action->state_set);
if (((surf_action_lmm_t) action)->variable)
- lmm_variable_free(cpu_maxmin_system,
+ lmm_variable_free(surf_cpu_model->maxmin_system,
((surf_action_lmm_t) action)->variable);
- if (cpu_update_mechanism == UM_LAZY) {
+ if (surf_cpu_model->update_mechanism == UM_LAZY) {
/* remove from heap */
- surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);
- xbt_swag_remove(action, cpu_modified_set);
+ surf_action_lmm_heap_remove(surf_cpu_model->action_heap,(surf_action_lmm_t)action);
+ xbt_swag_remove(action, surf_cpu_model->modified_set);
}
#ifdef HAVE_TRACING
xbt_free(action->category);
static void cpu_action_cancel(surf_action_t action)
{
surf_action_state_set(action, SURF_ACTION_FAILED);
- if (cpu_update_mechanism == UM_LAZY) {
- xbt_swag_remove(action, cpu_modified_set);
- surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);
+ if (surf_cpu_model->update_mechanism == UM_LAZY) {
+ xbt_swag_remove(action, surf_cpu_model->modified_set);
+ surf_action_lmm_heap_remove(surf_cpu_model->action_heap,(surf_action_lmm_t)action);
}
return;
}
{
/* if((state==SURF_ACTION_DONE) || (state==SURF_ACTION_FAILED)) */
/* if(((surf_action_lmm_t)action)->variable) { */
-/* lmm_variable_disable(cpu_maxmin_system, ((surf_action_lmm_t)action)->variable); */
+/* lmm_variable_disable(surf_cpu_model->maxmin_system, ((surf_action_lmm_t)action)->variable); */
/* ((surf_action_lmm_t)action)->variable = NULL; */
/* } */
return;
}
-static void cpu_update_action_remaining_lazy(double now)
+static void cpu_update_action_remaining_lazy(surf_action_cpu_Cas01_t action, double now)
{
- surf_action_cpu_Cas01_t action;
double delta = 0.0;
- xbt_swag_foreach(action, cpu_modified_set) {
- if (GENERIC_ACTION(action).state_set !=
- surf_cpu_model->states.running_action_set)
- continue; // FIXME useless ????
+ xbt_assert(GENERIC_ACTION(action).state_set == surf_cpu_model->states.running_action_set,
+ "You're updating an action that is not running.");
/* bogus priority, skip it */
- if (GENERIC_ACTION(action).priority <= 0)
- continue;
-
- delta = now - GENERIC_LMM_ACTION(action).last_update;
- if (GENERIC_ACTION(action).remains > 0) {
-
- double_update(&(GENERIC_ACTION(action).remains),
- lmm_variable_getvalue(GENERIC_LMM_ACTION(action).variable) * delta);
+ xbt_assert(GENERIC_ACTION(action).priority > 0,
+ "You're updating an action that seems suspended.");
+
+ delta = now - GENERIC_LMM_ACTION(action).last_update;
+ if (GENERIC_ACTION(action).remains > 0) {
+ XBT_DEBUG("Updating action(%p): remains was %lf, last_update was: %lf", action,
+ GENERIC_ACTION(action).remains,
+ GENERIC_LMM_ACTION(action).last_update);
+ double_update(&(GENERIC_ACTION(action).remains),
+ GENERIC_LMM_ACTION(action).last_value * delta);
#ifdef HAVE_TRACING
- if (TRACE_is_enabled()) {
- cpu_Cas01_t cpu =
- lmm_constraint_id(lmm_get_cnst_from_var
- (cpu_maxmin_system,
- GENERIC_LMM_ACTION(action).variable, 0));
- TRACE_surf_host_set_utilization(cpu->generic_resource.name,
- ((surf_action_t)action)->category,
- lmm_variable_getvalue(GENERIC_LMM_ACTION(action).variable),
- GENERIC_LMM_ACTION(action).last_update,
- now - GENERIC_LMM_ACTION(action).last_update);
- }
-#endif
- XBT_DEBUG("Update action(%p) remains %lf", action,
- GENERIC_ACTION(action).remains);
+ if (TRACE_is_enabled()) {
+ cpu_Cas01_t cpu =
+ lmm_constraint_id(lmm_get_cnst_from_var
+ (surf_cpu_model->maxmin_system,
+ GENERIC_LMM_ACTION(action).variable, 0));
+ TRACE_surf_host_set_utilization(cpu->generic_resource.name,
+ ((surf_action_t)action)->category,
+ GENERIC_LMM_ACTION(action).last_value,
+ GENERIC_LMM_ACTION(action).last_update,
+ now - GENERIC_LMM_ACTION(action).last_update);
}
- GENERIC_LMM_ACTION(action).last_update = now;
+#endif
+ XBT_DEBUG("Updating action(%p): remains is now %lf", action,
+ GENERIC_ACTION(action).remains);
}
-
+ GENERIC_LMM_ACTION(action).last_update = now;
+ GENERIC_LMM_ACTION(action).last_value = lmm_variable_getvalue(GENERIC_LMM_ACTION(action).variable);
}
static double cpu_share_resources_lazy(double now)
XBT_DEBUG
("Before share resources, the size of modified actions set is %d",
- xbt_swag_size(cpu_modified_set));
- cpu_update_action_remaining_lazy(now);
+ xbt_swag_size(surf_cpu_model->modified_set));
- lmm_solve(cpu_maxmin_system);
+ lmm_solve(surf_cpu_model->maxmin_system);
XBT_DEBUG
("After share resources, The size of modified actions set is %d",
- xbt_swag_size(cpu_modified_set));
+ xbt_swag_size(surf_cpu_model->modified_set));
- xbt_swag_foreach(action, cpu_modified_set) {
+ while((action = xbt_swag_extract(surf_cpu_model->modified_set))) {
int max_dur_flag = 0;
if (GENERIC_ACTION(action).state_set !=
if (GENERIC_ACTION(action).priority <= 0)
continue;
+ cpu_update_action_remaining_lazy(action,now);
+
min = -1;
value = lmm_variable_getvalue(GENERIC_LMM_ACTION(action).variable);
if (value > 0) {
GENERIC_ACTION(action).max_duration);
if (min != -1) {
- surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);
- surf_action_lmm_heap_insert(cpu_action_heap,(surf_action_lmm_t)action, min, max_dur_flag ? MAX_DURATION : NORMAL);
+ surf_action_lmm_heap_remove(surf_cpu_model->action_heap,(surf_action_lmm_t)action);
+ surf_action_lmm_heap_insert(surf_cpu_model->action_heap,(surf_action_lmm_t)action, min, max_dur_flag ? MAX_DURATION : NORMAL);
XBT_DEBUG("Insert at heap action(%p) min %lf now %lf", action, min,
now);
} else DIE_IMPOSSIBLE;
}
//hereafter must have already the min value for this resource model
- if (xbt_heap_size(cpu_action_heap) > 0)
- min = xbt_heap_maxkey(cpu_action_heap) - now;
+ if (xbt_heap_size(surf_cpu_model->action_heap) > 0)
+ min = xbt_heap_maxkey(surf_cpu_model->action_heap) - now;
else
min = -1;
xbt_swag_offset(action,
generic_lmm_action.
variable),
- cpu_maxmin_system, lmm_solve);
+ surf_cpu_model->maxmin_system, lmm_solve);
}
static void cpu_update_actions_state_lazy(double now, double delta)
{
surf_action_cpu_Cas01_t action;
- while ((xbt_heap_size(cpu_action_heap) > 0)
- && (double_equals(xbt_heap_maxkey(cpu_action_heap), now))) {
- action = xbt_heap_pop(cpu_action_heap);
+ while ((xbt_heap_size(surf_cpu_model->action_heap) > 0)
+ && (double_equals(xbt_heap_maxkey(surf_cpu_model->action_heap), now))) {
+ action = xbt_heap_pop(surf_cpu_model->action_heap);
XBT_DEBUG("Action %p: finish", action);
GENERIC_ACTION(action).finish = surf_get_clock();
#ifdef HAVE_TRACING
if (TRACE_is_enabled()) {
cpu_Cas01_t cpu =
lmm_constraint_id(lmm_get_cnst_from_var
- (cpu_maxmin_system,
+ (surf_cpu_model->maxmin_system,
GENERIC_LMM_ACTION(action).variable, 0));
TRACE_surf_host_set_utilization(cpu->generic_resource.name,
((surf_action_t)action)->category,
/* set the remains to 0 due to precision problems when updating the remaining amount */
GENERIC_ACTION(action).remains = 0;
cpu_action_state_set((surf_action_t) action, SURF_ACTION_DONE);
- surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);
+ surf_action_lmm_heap_remove(surf_cpu_model->action_heap,(surf_action_lmm_t)action); //FIXME: strange call since action was already popped
}
#ifdef HAVE_TRACING
if (TRACE_is_enabled()) {
if (TRACE_is_enabled()) {
cpu_Cas01_t x =
lmm_constraint_id(lmm_get_cnst_from_var
- (cpu_maxmin_system,
+ (surf_cpu_model->maxmin_system,
GENERIC_LMM_ACTION(action).variable, 0));
TRACE_surf_host_set_utilization(x->generic_resource.name,
if (event_type == cpu->power_event) {
cpu->power_scale = value;
- lmm_update_constraint_bound(cpu_maxmin_system, cpu->constraint,
+ lmm_update_constraint_bound(surf_cpu_model->maxmin_system, cpu->constraint,
cpu->core * cpu->power_scale *
cpu->power_peak);
#ifdef HAVE_TRACING
cpu->power_peak);
#endif
while ((var = lmm_get_var_from_cnst
- (cpu_maxmin_system, cpu->constraint, &elem))) {
+ (surf_cpu_model->maxmin_system, cpu->constraint, &elem))) {
surf_action_cpu_Cas01_t action = lmm_variable_id(var);
- lmm_update_variable_bound(cpu_maxmin_system,
+ lmm_update_variable_bound(surf_cpu_model->maxmin_system,
GENERIC_LMM_ACTION(action).variable,
cpu->power_scale * cpu->power_peak);
}
cpu->state_current = SURF_RESOURCE_OFF;
- while ((var = lmm_get_var_from_cnst(cpu_maxmin_system, cnst, &elem))) {
+ while ((var = lmm_get_var_from_cnst(surf_cpu_model->maxmin_system, cnst, &elem))) {
surf_action_t action = lmm_variable_id(var);
if (surf_action_state_get(action) == SURF_ACTION_RUNNING ||
calloc but it seems to help valgrind... */
GENERIC_LMM_ACTION(action).variable =
- lmm_variable_new(cpu_maxmin_system, action,
+ lmm_variable_new(surf_cpu_model->maxmin_system, action,
GENERIC_ACTION(action).priority,
CPU->power_scale * CPU->power_peak, 1);
- if (cpu_update_mechanism == UM_LAZY) {
+ if (surf_cpu_model->update_mechanism == UM_LAZY) {
GENERIC_LMM_ACTION(action).index_heap = -1;
GENERIC_LMM_ACTION(action).last_update = surf_get_clock();
+ GENERIC_LMM_ACTION(action).last_value = 0.0;
}
- lmm_expand(cpu_maxmin_system, CPU->constraint,
+ lmm_expand(surf_cpu_model->maxmin_system, CPU->constraint,
GENERIC_LMM_ACTION(action).variable, 1.0);
XBT_OUT();
return (surf_action_t) action;
XBT_IN("(%s,%g)", surf_resource_name(cpu), duration);
action = (surf_action_cpu_Cas01_t) cpu_execute(cpu, 1.0);
+ // FIXME: sleep variables should not consume 1.0 in lmm_expand
GENERIC_ACTION(action).max_duration = duration;
GENERIC_LMM_ACTION(action).suspended = 2;
if (duration == NO_MAX_DURATION) {
xbt_swag_insert(action, ((surf_action_t) action)->state_set);
}
- lmm_update_variable_weight(cpu_maxmin_system,
+ lmm_update_variable_weight(surf_cpu_model->maxmin_system,
GENERIC_LMM_ACTION(action).variable, 0.0);
- if (cpu_update_mechanism == UM_LAZY) { // remove action from the heap
- surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);
+ if (surf_cpu_model->update_mechanism == UM_LAZY) { // remove action from the heap
+ surf_action_lmm_heap_remove(surf_cpu_model->action_heap,(surf_action_lmm_t)action);
// this is necessary for a variable with weight 0 since such
// variables are ignored in lmm and we need to set its max_duration
// correctly at the next call to share_resources
- xbt_swag_insert_at_head(action,cpu_modified_set);
+ xbt_swag_insert_at_head(action,surf_cpu_model->modified_set);
}
XBT_OUT();
{
XBT_IN("(%p)", action);
if (((surf_action_lmm_t) action)->suspended != 2) {
- lmm_update_variable_weight(cpu_maxmin_system,
+ lmm_update_variable_weight(surf_cpu_model->maxmin_system,
((surf_action_lmm_t) action)->variable,
0.0);
((surf_action_lmm_t) action)->suspended = 1;
- if (cpu_update_mechanism == UM_LAZY)
- surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);
+ if (surf_cpu_model->update_mechanism == UM_LAZY)
+ surf_action_lmm_heap_remove(surf_cpu_model->action_heap,(surf_action_lmm_t)action);
}
XBT_OUT();
}
XBT_IN("(%p)", action);
if (((surf_action_lmm_t) action)->suspended != 2) {
- lmm_update_variable_weight(cpu_maxmin_system,
+ lmm_update_variable_weight(surf_cpu_model->maxmin_system,
((surf_action_lmm_t) action)->variable,
action->priority);
((surf_action_lmm_t) action)->suspended = 0;
- if (cpu_update_mechanism == UM_LAZY)
- surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);
+ if (surf_cpu_model->update_mechanism == UM_LAZY)
+ surf_action_lmm_heap_remove(surf_cpu_model->action_heap,(surf_action_lmm_t)action);
}
XBT_OUT();
}
XBT_IN("(%p,%g)", action, duration);
action->max_duration = duration;
- if (cpu_update_mechanism == UM_LAZY)
- surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);
+ if (surf_cpu_model->update_mechanism == UM_LAZY)
+ surf_action_lmm_heap_remove(surf_cpu_model->action_heap,(surf_action_lmm_t)action);
XBT_OUT();
}
{
XBT_IN("(%p,%g)", action, priority);
action->priority = priority;
- lmm_update_variable_weight(cpu_maxmin_system,
+ lmm_update_variable_weight(surf_cpu_model->maxmin_system,
((surf_action_lmm_t) action)->variable,
priority);
- if (cpu_update_mechanism == UM_LAZY)
- surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);
+ if (surf_cpu_model->update_mechanism == UM_LAZY)
+ surf_action_lmm_heap_remove(surf_cpu_model->action_heap,(surf_action_lmm_t)action);
XBT_OUT();
}
{
XBT_IN("(%p)", action);
/* update remains before return it */
- if (cpu_update_mechanism == UM_LAZY)
- cpu_update_action_remaining_lazy(surf_get_clock());
+ if (surf_cpu_model->update_mechanism == UM_LAZY)
+ cpu_update_action_remaining_lazy((surf_action_cpu_Cas01_t)action,
+ surf_get_clock());
XBT_OUT();
return action->remains;
}
static void cpu_finalize(void)
{
- lmm_system_free(cpu_maxmin_system);
- cpu_maxmin_system = NULL;
+ lmm_system_free(surf_cpu_model->maxmin_system);
+ surf_cpu_model->maxmin_system = NULL;
+
+ if (surf_cpu_model->action_heap)
+ xbt_heap_free(surf_cpu_model->action_heap);
+ xbt_swag_free(surf_cpu_model->modified_set);
surf_model_exit(surf_cpu_model);
surf_cpu_model = NULL;
xbt_swag_free(cpu_running_action_set_that_does_not_need_being_checked);
cpu_running_action_set_that_does_not_need_being_checked = NULL;
- if (cpu_action_heap)
- xbt_heap_free(cpu_action_heap);
}
static void surf_cpu_model_init_internal()
s_surf_action_t action;
s_surf_action_cpu_Cas01_t comp;
+ char *optim = xbt_cfg_get_string(_surf_cfg_set, "cpu/optim");
+ int select =
+ xbt_cfg_get_int(_surf_cfg_set, "cpu/maxmin_selective_update");
+
surf_cpu_model = surf_model_init();
+ if (!strcmp(optim, "Full")) {
+ surf_cpu_model->update_mechanism = UM_FULL;
+ surf_cpu_model->selective_update = select;
+ } else if (!strcmp(optim, "Lazy")) {
+ surf_cpu_model->update_mechanism = UM_LAZY;
+ surf_cpu_model->selective_update = 1;
+ xbt_assert((select == 1)
+ ||
+ (xbt_cfg_is_default_value
+ (_surf_cfg_set, "cpu/maxmin_selective_update")),
+ "Disabling selective update while using the lazy update mechanism is dumb!");
+ } else {
+ xbt_die("Unsupported optimization (%s) for this model", optim);
+ }
+
cpu_running_action_set_that_does_not_need_being_checked =
xbt_swag_new(xbt_swag_offset(action, state_hookup));
surf_cpu_model->model_private->resource_used = cpu_resource_used;
- if (cpu_update_mechanism == UM_LAZY) {
+ if (surf_cpu_model->update_mechanism == UM_LAZY) {
surf_cpu_model->model_private->share_resources =
cpu_share_resources_lazy;
surf_cpu_model->model_private->update_actions_state =
cpu_update_actions_state_lazy;
- } else if (cpu_update_mechanism == UM_FULL) {
+ } else if (surf_cpu_model->update_mechanism == UM_FULL) {
surf_cpu_model->model_private->share_resources =
cpu_share_resources_full;
surf_cpu_model->model_private->update_actions_state =
cpu_update_actions_state_full;
} else
- xbt_die("Invalid update mechanism!");
+ xbt_die("Invalid cpu update mechanism!");
surf_cpu_model->model_private->update_resource_state =
cpu_update_resource_state;
surf_cpu_model->extension.cpu.create_resource = cpu_create_resource;
surf_cpu_model->extension.cpu.add_traces = cpu_add_traces_cpu;
- if (!cpu_maxmin_system) {
- cpu_maxmin_system = lmm_system_new(cpu_selective_update);
+ if (!surf_cpu_model->maxmin_system) {
+ surf_cpu_model->maxmin_system = lmm_system_new(surf_cpu_model->selective_update);
}
- if (cpu_update_mechanism == UM_LAZY) {
- cpu_action_heap = xbt_heap_new(8, NULL);
- xbt_heap_set_update_callback(cpu_action_heap,
+ if (surf_cpu_model->update_mechanism == UM_LAZY) {
+ surf_cpu_model->action_heap = xbt_heap_new(8, NULL);
+ xbt_heap_set_update_callback(surf_cpu_model->action_heap,
surf_action_lmm_update_index_heap);
- cpu_modified_set =
+ surf_cpu_model->modified_set =
xbt_swag_new(xbt_swag_offset(comp, generic_lmm_action.action_list_hookup));
- cpu_maxmin_system->keep_track = cpu_modified_set;
+ surf_cpu_model->maxmin_system->keep_track = surf_cpu_model->modified_set;
}
}
void surf_cpu_model_init_Cas01()
{
char *optim = xbt_cfg_get_string(_surf_cfg_set, "cpu/optim");
- int select =
- xbt_cfg_get_int(_surf_cfg_set, "cpu/maxmin_selective_update");
- if (!strcmp(optim, "Full")) {
- cpu_update_mechanism = UM_FULL;
- cpu_selective_update = select;
- } else if (!strcmp(optim, "Lazy")) {
- cpu_update_mechanism = UM_LAZY;
- cpu_selective_update = 1;
- xbt_assert((select == 1)
- ||
- (xbt_cfg_is_default_value
- (_surf_cfg_set, "cpu/maxmin_selective_update")),
- "Disabling selective update while using the lazy update mechanism is dumb!");
- } else if (!strcmp(optim, "TI")) {
+ if (surf_cpu_model)
+ return;
+
+ if (!strcmp(optim, "TI")) {
surf_cpu_model_init_ti();
return;
- } else {
- xbt_die("Unsupported optimization (%s) for this model", optim);
}
- if (surf_cpu_model)
- return;
surf_cpu_model_init_internal();
cpu_define_callbacks();
xbt_dynar_push(model_list, &surf_cpu_model);
