X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/7a8cd62135619ad52e05ae1c929ef07e166e4260..2489210b4ea8d03fbece8db288ef9e3ff6725723:/src/surf/cpu_ti.c diff --git a/src/surf/cpu_ti.c b/src/surf/cpu_ti.c index b44fd4d035..91d66eab9f 100644 --- a/src/surf/cpu_ti.c +++ b/src/surf/cpu_ti.c @@ -148,7 +148,8 @@ static void* cpu_ti_create_resource(const char *name, double power_peak, int core, e_surf_resource_state_t state_initial, tmgr_trace_t state_trace, - xbt_dict_t cpu_properties) + xbt_dict_t cpu_properties, + surf_model_t cpu_model) { tmgr_trace_t empty_trace; s_tmgr_event_t val; @@ -160,7 +161,7 @@ static void* cpu_ti_create_resource(const char *name, double power_peak, name); xbt_assert(core==1,"Multi-core not handled with this model yet"); cpu = (cpu_ti_t) surf_resource_new(sizeof(s_cpu_ti_t), - surf_cpu_model, name,cpu_properties); + cpu_model, name,cpu_properties); cpu->action_set = xbt_swag_new(xbt_swag_offset(ti_action, cpu_list_hookup)); cpu->power_peak = power_peak; @@ -198,7 +199,8 @@ static void parse_cpu_ti_init(sg_platf_host_cbarg_t host) host->core_amount, host->initial_state, host->state_trace, - host->properties); + host->properties, + surf_cpu_model_pm); } @@ -311,7 +313,7 @@ static void cpu_ti_action_state_set(surf_action_t action, * \param cpu Cpu on which the actions are running * \param now Current time */ -static void cpu_ti_update_remaining_amount(cpu_ti_t cpu, double now) +static void cpu_ti_update_remaining_amount(surf_model_t cpu_model, cpu_ti_t cpu, double now) { double area_total; surf_action_cpu_ti_t action; @@ -331,7 +333,7 @@ static void cpu_ti_update_remaining_amount(cpu_ti_t cpu, double now) surf_action_t generic = (surf_action_t)action; /* action not running, skip it */ if (generic->state_set != - surf_cpu_model->states.running_action_set) + cpu_model->states.running_action_set) continue; /* bogus priority, skip it */ @@ -368,19 +370,19 @@ static void cpu_ti_update_remaining_amount(cpu_ti_t cpu, double now) * \param cpu Cpu on which the actions are running * \param now Current time */ -static void cpu_ti_update_action_finish_date(cpu_ti_t cpu, double now) +static void cpu_ti_update_action_finish_date(surf_model_t cpu_model, cpu_ti_t cpu, double now) { #define GENERIC_ACTION(action) action->generic_action surf_action_cpu_ti_t action; double sum_priority = 0.0, total_area, min_finish = -1; /* update remaning amount of actions */ - cpu_ti_update_remaining_amount(cpu, now); + cpu_ti_update_remaining_amount(cpu_model, cpu, now); xbt_swag_foreach(action, cpu->action_set) { /* action not running, skip it */ if (GENERIC_ACTION(action).state_set != - surf_cpu_model->states.running_action_set) + cpu_model->states.running_action_set) continue; /* bogus priority, skip it */ @@ -399,7 +401,7 @@ static void cpu_ti_update_action_finish_date(cpu_ti_t cpu, double now) min_finish = -1; /* action not running, skip it */ if (GENERIC_ACTION(action).state_set != - surf_cpu_model->states.running_action_set) + cpu_model->states.running_action_set) continue; /* verify if the action is really running on cpu */ @@ -451,14 +453,20 @@ static void cpu_ti_update_action_finish_date(cpu_ti_t cpu, double now) #undef GENERIC_ACTION } -static double cpu_ti_share_resources(double now) +static double cpu_ti_share_resources(surf_model_t cpu_model, double now) { cpu_ti_t cpu, cpu_next; double min_action_duration = -1; /* iterates over modified cpus to update share resources */ xbt_swag_foreach_safe(cpu, cpu_next, cpu_ti_modified_cpu) { - cpu_ti_update_action_finish_date(cpu, now); + /* FIXME: cpu_ti_modified_cpu is a global object. But, now we have multiple + * cpu_model objects in the system. Do we have to create this + * swag for each cpu model object? + * + * We should revisit here after we know what cpu_ti is. + **/ + cpu_ti_update_action_finish_date(cpu_model, cpu, now); } /* get the min next event if heap not empty */ if (xbt_heap_size(cpu_ti_action_heap) > 0) @@ -469,8 +477,10 @@ static double cpu_ti_share_resources(double now) return min_action_duration; } -static void cpu_ti_update_actions_state(double now, double delta) +static void cpu_ti_update_actions_state(surf_model_t cpu_model, double now, double delta) { + /* FIXME: cpu_ti_action_heap is global. Is this okay for VM support? */ + #define GENERIC_ACTION(action) action->generic_action surf_action_cpu_ti_t action; while ((xbt_heap_size(cpu_ti_action_heap) > 0) @@ -482,7 +492,7 @@ static void cpu_ti_update_actions_state(double now, double delta) GENERIC_ACTION(action).remains = 0; cpu_ti_action_state_set((surf_action_t) action, SURF_ACTION_DONE); /* update remaining amout of all actions */ - cpu_ti_update_remaining_amount(surf_cpu_resource_priv(action->cpu), surf_get_clock()); + cpu_ti_update_remaining_amount(cpu_model, surf_cpu_resource_priv(action->cpu), surf_get_clock()); } #undef GENERIC_ACTION } @@ -492,6 +502,7 @@ static void cpu_ti_update_resource_state(void *id, double value, double date) { cpu_ti_t cpu = id; + surf_model_t cpu_model = ((surf_resource_t) cpu)->model; surf_action_cpu_ti_t action; surf_watched_hosts(); @@ -504,7 +515,7 @@ static void cpu_ti_update_resource_state(void *id, XBT_DEBUG("Finish trace date: %lf value %lf date %lf", surf_get_clock(), value, date); /* update remaining of actions and put in modified cpu swag */ - cpu_ti_update_remaining_amount(cpu, date); + cpu_ti_update_remaining_amount(cpu_model, cpu, date); xbt_swag_insert(cpu, cpu_ti_modified_cpu); power_trace = cpu->avail_trace->power_trace; @@ -564,10 +575,11 @@ static surf_action_t cpu_ti_execute(void *cpu, double size) { surf_action_cpu_ti_t action = NULL; cpu_ti_t CPU = surf_cpu_resource_priv(cpu); + surf_model_t cpu_model = ((surf_resource_t) CPU)->model; XBT_IN("(%s,%g)", surf_resource_name(CPU), size); action = - surf_action_new(sizeof(s_surf_action_cpu_ti_t), size, surf_cpu_model, + surf_action_new(sizeof(s_surf_action_cpu_ti_t), size, cpu_model, CPU->state_current != SURF_RESOURCE_ON); action->cpu = cpu; action->index_heap = -1; @@ -679,9 +691,10 @@ static void cpu_ti_action_set_priority(surf_action_t action, static double cpu_ti_action_get_remains(surf_action_t action) { + surf_model_t cpu_model = action->model_obj; XBT_IN("(%p)", action); - cpu_ti_update_remaining_amount((cpu_ti_t) - ((surf_action_cpu_ti_t) action)->cpu, + + cpu_ti_update_remaining_amount(cpu_model, (cpu_ti_t) ((surf_action_cpu_ti_t) action)->cpu, surf_get_clock()); XBT_OUT(); return action->remains; @@ -729,12 +742,15 @@ static double cpu_ti_get_available_speed(void *cpu) return CPU->power_scale; } -static void cpu_ti_finalize(void) +static void cpu_ti_finalize(surf_model_t cpu_model) { void **cpu; xbt_lib_cursor_t cursor; char *key; + /* FIXME: we should update this code for VM support */ + xbt_abort(); + xbt_lib_foreach(host_lib, cursor, key, cpu){ if(cpu[SURF_CPU_LEVEL]) { @@ -744,8 +760,8 @@ static void cpu_ti_finalize(void) } } - surf_model_exit(surf_cpu_model); - surf_cpu_model = NULL; + surf_model_exit(cpu_model); + cpu_model = NULL; xbt_swag_free (cpu_ti_running_action_set_that_does_not_need_being_checked); @@ -754,12 +770,12 @@ static void cpu_ti_finalize(void) xbt_heap_free(cpu_ti_action_heap); } -static void surf_cpu_ti_model_init_internal(void) +surf_model_t surf_cpu_ti_model_init_internal(void) { s_surf_action_t action; s_cpu_ti_t cpu; - surf_cpu_model = surf_model_init(); + surf_model_t cpu_model = surf_model_init(); cpu_ti_running_action_set_that_does_not_need_being_checked = xbt_swag_new(xbt_swag_offset(action, state_hookup)); @@ -767,48 +783,51 @@ static void surf_cpu_ti_model_init_internal(void) cpu_ti_modified_cpu = xbt_swag_new(xbt_swag_offset(cpu, modified_cpu_hookup)); - surf_cpu_model->name = "cpu_ti"; + cpu_model->name = "cpu_ti"; + cpu_model->type = SURF_MODEL_TYPE_CPU; - surf_cpu_model->action_unref = cpu_ti_action_unref; - surf_cpu_model->action_cancel = cpu_ti_action_cancel; - surf_cpu_model->action_state_set = cpu_ti_action_state_set; + cpu_model->action_unref = cpu_ti_action_unref; + cpu_model->action_cancel = cpu_ti_action_cancel; + cpu_model->action_state_set = cpu_ti_action_state_set; - surf_cpu_model->model_private->resource_used = cpu_ti_resource_used; - surf_cpu_model->model_private->share_resources = cpu_ti_share_resources; - surf_cpu_model->model_private->update_actions_state = + cpu_model->model_private->resource_used = cpu_ti_resource_used; + cpu_model->model_private->share_resources = cpu_ti_share_resources; + cpu_model->model_private->update_actions_state = cpu_ti_update_actions_state; - surf_cpu_model->model_private->update_resource_state = + cpu_model->model_private->update_resource_state = cpu_ti_update_resource_state; - surf_cpu_model->model_private->finalize = cpu_ti_finalize; + cpu_model->model_private->finalize = cpu_ti_finalize; - surf_cpu_model->suspend = cpu_ti_action_suspend; - surf_cpu_model->resume = cpu_ti_action_resume; - surf_cpu_model->is_suspended = cpu_ti_action_is_suspended; - surf_cpu_model->set_max_duration = cpu_ti_action_set_max_duration; - surf_cpu_model->set_priority = cpu_ti_action_set_priority; - surf_cpu_model->get_remains = cpu_ti_action_get_remains; + cpu_model->suspend = cpu_ti_action_suspend; + cpu_model->resume = cpu_ti_action_resume; + cpu_model->is_suspended = cpu_ti_action_is_suspended; + cpu_model->set_max_duration = cpu_ti_action_set_max_duration; + cpu_model->set_priority = cpu_ti_action_set_priority; + cpu_model->get_remains = cpu_ti_action_get_remains; - surf_cpu_model->extension.cpu.execute = cpu_ti_execute; - surf_cpu_model->extension.cpu.sleep = cpu_ti_action_sleep; + cpu_model->extension.cpu.execute = cpu_ti_execute; + cpu_model->extension.cpu.sleep = cpu_ti_action_sleep; - surf_cpu_model->extension.cpu.get_state = cpu_ti_get_state; - surf_cpu_model->extension.cpu.get_speed = cpu_ti_get_speed; - surf_cpu_model->extension.cpu.get_available_speed = + cpu_model->extension.cpu.get_state = cpu_ti_get_state; + cpu_model->extension.cpu.get_speed = cpu_ti_get_speed; + cpu_model->extension.cpu.get_available_speed = cpu_ti_get_available_speed; - surf_cpu_model->extension.cpu.add_traces = add_traces_cpu_ti; + cpu_model->extension.cpu.add_traces = add_traces_cpu_ti; cpu_ti_action_heap = xbt_heap_new(8, NULL); xbt_heap_set_update_callback(cpu_ti_action_heap, cpu_ti_action_update_index_heap); + return cpu_model; } -void surf_cpu_model_init_ti() +surf_model_t surf_cpu_model_init_ti(void) { - xbt_assert(!surf_cpu_model,"CPU model already initialized. This should not happen."); - surf_cpu_ti_model_init_internal(); + surf_model_t cpu_model = surf_cpu_ti_model_init_internal(); cpu_ti_define_callbacks(); - xbt_dynar_push(model_list, &surf_cpu_model); + xbt_dynar_push(model_list, &cpu_model); + + return cpu_model; }