static xbt_swag_t
cpu_running_action_set_that_does_not_need_being_checked = NULL;
-/* added to manage the communication action's heap */
-static void net_action_update_index_heap(void *action, int i)
-{
- surf_action_cpu_Cas01_t a = action;
- GENERIC_LMM_ACTION(a).index_heap = i;
-}
-
-/* insert action on heap using a given key and a hat (heap_action_type)
- * a hat can be of three types for communications:
- *
- * NORMAL = this is a normal heap entry stating the date to finish transmitting
- * LATENCY = this is a heap entry to warn us when the latency is payed
- * MAX_DURATION =this is a heap entry to warn us when the max_duration limit is reached
- */
-static void heap_insert(surf_action_cpu_Cas01_t action, double key,
- enum heap_action_type hat)
-{
- GENERIC_LMM_ACTION(action).hat = hat;
- xbt_heap_push(cpu_action_heap, action, key);
-}
-
-static void heap_remove(surf_action_cpu_Cas01_t action)
-{
- GENERIC_LMM_ACTION(action).hat = NOTSET;
- if (GENERIC_LMM_ACTION(action).index_heap >= 0) {
- xbt_heap_remove(cpu_action_heap, GENERIC_LMM_ACTION(action).index_heap);
- }
-}
static void *cpu_create_resource(const char *name, double power_peak,
double power_scale,
((surf_action_lmm_t) action)->variable);
if (cpu_update_mechanism == UM_LAZY) {
/* remove from heap */
- heap_remove((surf_action_cpu_Cas01_t) action);
+ surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);
xbt_swag_remove(action, cpu_modified_set);
}
#ifdef HAVE_TRACING
surf_action_state_set(action, SURF_ACTION_FAILED);
if (cpu_update_mechanism == UM_LAZY) {
xbt_swag_remove(action, cpu_modified_set);
- heap_remove((surf_action_cpu_Cas01_t) action);
+ surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);
}
return;
}
return;
}
-static void 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
+ (cpu_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));
- update_action_remaining_lazy(now);
lmm_solve(cpu_maxmin_system);
("After share resources, The size of modified actions set is %d",
xbt_swag_size(cpu_modified_set));
- xbt_swag_foreach(action, cpu_modified_set) {
+ while((action = xbt_swag_extract(cpu_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) {
- heap_remove(action);
- heap_insert(action, min, max_dur_flag ? MAX_DURATION : NORMAL);
+ 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);
XBT_DEBUG("Insert at heap action(%p) min %lf now %lf", action, min,
now);
} else DIE_IMPOSSIBLE;
/* 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);
- heap_remove(action);
+ surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action); //FIXME: strange call since action was already popped
}
#ifdef HAVE_TRACING
if (TRACE_is_enabled()) {
if (cpu_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,
GENERIC_LMM_ACTION(action).variable, 1.0);
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) {
lmm_update_variable_weight(cpu_maxmin_system,
GENERIC_LMM_ACTION(action).variable, 0.0);
if (cpu_update_mechanism == UM_LAZY) { // remove action from the heap
- heap_remove((surf_action_cpu_Cas01_t) action);
+ surf_action_lmm_heap_remove(cpu_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
0.0);
((surf_action_lmm_t) action)->suspended = 1;
if (cpu_update_mechanism == UM_LAZY)
- heap_remove((surf_action_cpu_Cas01_t) action);
+ surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);
}
XBT_OUT();
}
action->priority);
((surf_action_lmm_t) action)->suspended = 0;
if (cpu_update_mechanism == UM_LAZY)
- heap_remove((surf_action_cpu_Cas01_t) action);
+ surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);
}
XBT_OUT();
}
action->max_duration = duration;
if (cpu_update_mechanism == UM_LAZY)
- heap_remove((surf_action_cpu_Cas01_t) action);
+ surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);
XBT_OUT();
}
priority);
if (cpu_update_mechanism == UM_LAZY)
- heap_remove((surf_action_cpu_Cas01_t) action);
+ surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);
XBT_OUT();
}
XBT_IN("(%p)", action);
/* update remains before return it */
if (cpu_update_mechanism == UM_LAZY)
- update_action_remaining_lazy(surf_get_clock());
+ cpu_update_action_remaining_lazy((surf_action_cpu_Cas01_t)action,
+ surf_get_clock());
XBT_OUT();
return action->remains;
}
cpu_running_action_set_that_does_not_need_being_checked = NULL;
if (cpu_action_heap)
xbt_heap_free(cpu_action_heap);
+ xbt_swag_free(cpu_modified_set);
}
static void surf_cpu_model_init_internal()
if (cpu_update_mechanism == UM_LAZY) {
cpu_action_heap = xbt_heap_new(8, NULL);
xbt_heap_set_update_callback(cpu_action_heap,
- net_action_update_index_heap);
+ surf_action_lmm_update_index_heap);
cpu_modified_set =
xbt_swag_new(xbt_swag_offset(comp, generic_lmm_action.action_list_hookup));
cpu_maxmin_system->keep_track = cpu_modified_set;
