X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/d8d97d835782d0906f8c5a8d0d335fefae36873a..9b9103db7f7aac95d28b162b7f78c6a946bba864:/src/surf/cpu.c diff --git a/src/surf/cpu.c b/src/surf/cpu.c index 879f2ac5ad..df379ddcae 100644 --- a/src/surf/cpu.c +++ b/src/surf/cpu.c @@ -1,39 +1,35 @@ -/* Authors: Arnaud Legrand */ +/* $Id$ */ + +/* Copyright (c) 2004 Arnaud Legrand. All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it - under the terms of the license (GNU LGPL) which comes with this package. */ + * under the terms of the license (GNU LGPL) which comes with this package. */ #include "cpu_private.h" -#include "xbt/dict.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(cpu, surf, "Logging specific to the SURF CPU module"); surf_cpu_resource_t surf_cpu_resource = NULL; -static xbt_dict_t cpu_set = NULL; +xbt_dict_t cpu_set = NULL; + +static void cpu_free(void *cpu) +{ + xbt_free(((cpu_t)cpu)->name); + xbt_free(cpu); +} /* power_scale is the basic power of the cpu when the cpu is - completely available. initial_power is therefore expected to be + completely available. power_initial is therefore expected to be comprised between 0.0 and 1.0, just as the values of power_trace. state_trace values mean SURF_CPU_ON if >0 and SURF_CPU_OFF otherwise. */ - -static void cpu_free(void *CPU) -{ - cpu_t cpu = CPU; - -/* lmm_constraint_free(maxmin_system,cpu->constraint); */ -/* Clean somewhere else ! */ - - xbt_free(cpu); -} - -static cpu_t cpu_new(const char *name, xbt_maxmin_float_t power_scale, - xbt_maxmin_float_t initial_power, +static cpu_t cpu_new(char *name, double power_scale, + double power_initial, tmgr_trace_t power_trace, - e_surf_cpu_state_t initial_state, + e_surf_cpu_state_t state_initial, tmgr_trace_t state_trace) { cpu_t cpu = xbt_new0(s_cpu_t, 1); @@ -41,13 +37,13 @@ static cpu_t cpu_new(const char *name, xbt_maxmin_float_t power_scale, cpu->resource = (surf_resource_t) surf_cpu_resource; cpu->name = name; cpu->power_scale = power_scale; - cpu->power_current = initial_power; + cpu->power_current = power_initial; /* cpu->power_trace = power_trace; */ if (power_trace) cpu->power_event = tmgr_history_add_trace(history, power_trace, 0.0, 0, cpu); - cpu->state_current = initial_state; + cpu->state_current = state_initial; /* cpu->state_trace = state_trace; */ if (state_trace) cpu->state_event = @@ -67,86 +63,40 @@ static cpu_t cpu_new(const char *name, xbt_maxmin_float_t power_scale, power trace state trace Token: TOKEN_WORD TOKEN_WORD TOKEN_WORD TOKEN_WORD TOKEN_WORD TOKEN_WORD - Type: string float float string ON/OFF string + Type: string double double string ON/OFF string */ -static void parse_host(void) +static void parse_cpu(void) { - e_surf_token_t token; char *name = NULL; - xbt_maxmin_float_t power_scale = 0.0; - xbt_maxmin_float_t initial_power = 0.0; - tmgr_trace_t power_trace = NULL;; - e_surf_cpu_state_t initial_state = SURF_CPU_OFF; + double power_scale = 0.0; + double power_initial = 0.0; + tmgr_trace_t power_trace = NULL; + e_surf_cpu_state_t state_initial = SURF_CPU_OFF; tmgr_trace_t state_trace = NULL; - name = xbt_strdup(surf_parse_text); - - token = surf_parse(); /* power_scale */ - xbt_assert1((token == TOKEN_WORD), "Parse error line %d", line_pos); - xbt_assert2((sscanf(surf_parse_text, XBT_MAXMIN_FLOAT_T, &power_scale) == - 1), "Parse error line %d : %s not a number", line_pos, - surf_parse_text); + name = xbt_strdup(A_cpu_name); + surf_parse_get_double(&power_scale,A_cpu_power); + surf_parse_get_double(&power_initial,A_cpu_availability); + surf_parse_get_trace(&power_trace,A_cpu_availability_file); - token = surf_parse(); /* initial_power */ - xbt_assert1((token == TOKEN_WORD), "Parse error line %d", line_pos); - xbt_assert2((sscanf(surf_parse_text, XBT_MAXMIN_FLOAT_T, &initial_power) - == 1), "Parse error line %d : %s not a number", line_pos, - surf_parse_text); + xbt_assert0((A_cpu_state==A_cpu_state_ON)||(A_cpu_state==A_cpu_state_OFF), + "Invalid state") + if (A_cpu_state==A_cpu_state_ON) state_initial = SURF_CPU_ON; + if (A_cpu_state==A_cpu_state_OFF) state_initial = SURF_CPU_OFF; + surf_parse_get_trace(&state_trace,A_cpu_state_file); - token = surf_parse(); /* power_trace */ - xbt_assert1((token == TOKEN_WORD), "Parse error line %d", line_pos); - if (strcmp(surf_parse_text, "") == 0) - power_trace = NULL; - else - power_trace = tmgr_trace_new(surf_parse_text); - - token = surf_parse(); /* initial_state */ - xbt_assert1((token == TOKEN_WORD), "Parse error line %d", line_pos); - if (strcmp(surf_parse_text, "ON") == 0) - initial_state = SURF_CPU_ON; - else if (strcmp(surf_parse_text, "OFF") == 0) - initial_state = SURF_CPU_OFF; - else { - CRITICAL2("Invalid cpu state (line %d): %s neq ON or OFF\n", line_pos, - surf_parse_text); - xbt_abort(); - } - - token = surf_parse(); /* state_trace */ - xbt_assert1((token == TOKEN_WORD), "Parse error line %d", line_pos); - if (strcmp(surf_parse_text, "") == 0) - state_trace = NULL; - else - state_trace = tmgr_trace_new(surf_parse_text); - - cpu_new(name, power_scale, initial_power, power_trace, initial_state, + cpu_new(name, power_scale, power_initial, power_trace, state_initial, state_trace); } static void parse_file(const char *file) { - e_surf_token_t token; - - find_section(file, "CPU"); - - while (1) { - token = surf_parse(); - - if (token == TOKEN_END_SECTION) - break; - if (token == TOKEN_NEWLINE) - continue; - - if (token == TOKEN_WORD) - parse_host(); - else { - CRITICAL1("Parse error line %d\n", line_pos); - xbt_abort(); - } - } - - close_section("CPU"); + surf_parse_reset_parser(); + ETag_cpu_fun=parse_cpu; + surf_parse_open(file); + xbt_assert1((!surf_parse()),"Parse error in %s",file); + surf_parse_close(); } static void *name_service(const char *name) @@ -197,33 +147,15 @@ static void action_change_state(surf_action_t action, return; } -static xbt_heap_float_t share_resources(xbt_heap_float_t now) +static double share_resources(double now) { - surf_action_cpu_t action = NULL; - xbt_swag_t running_actions = - surf_cpu_resource->common_public->states.running_action_set; - xbt_maxmin_float_t min = -1; - xbt_maxmin_float_t value = -1; - lmm_solve(maxmin_system); - - action = xbt_swag_getFirst(running_actions); - if (!action) - return 0.0; - value = lmm_variable_getvalue(action->variable); - min = action->generic_action.remains / value; - - xbt_swag_foreach(action, running_actions) { - value = action->generic_action.remains / - lmm_variable_getvalue(action->variable); - if (value < min) - min = value; - } - - return min; + s_surf_action_cpu_t action; + return generic_maxmin_share_resources(surf_cpu_resource->common_public-> + states.running_action_set, + xbt_swag_offset(action, variable)); } -static void update_actions_state(xbt_heap_float_t now, - xbt_heap_float_t delta) +static void update_actions_state(double now, double delta) { surf_action_cpu_t action = NULL; surf_action_cpu_t next_action = NULL; @@ -235,8 +167,16 @@ static void update_actions_state(xbt_heap_float_t now, xbt_swag_foreach_safe(action, next_action, running_actions) { action->generic_action.remains -= lmm_variable_getvalue(action->variable) * delta; + if (action->generic_action.max_duration != NO_MAX_DURATION) + action->generic_action.max_duration -= delta; /* if(action->generic_action.remains<.00001) action->generic_action.remains=0; */ - if (action->generic_action.remains <= 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) && + (action->generic_action.max_duration <= 0)) { + action->generic_action.finish = surf_get_clock(); action_change_state((surf_action_t) action, SURF_ACTION_DONE); } else { /* Need to check that none of the resource has failed */ lmm_constraint_t cnst = NULL; @@ -248,6 +188,7 @@ static void update_actions_state(xbt_heap_float_t now, i++))) { 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); break; } @@ -264,17 +205,17 @@ static void update_actions_state(xbt_heap_float_t now, static void update_resource_state(void *id, tmgr_trace_event_t event_type, - xbt_maxmin_float_t value) + double value) { cpu_t cpu = id; - printf("[" XBT_HEAP_FLOAT_T "] Asking to update \"%s\" with value " - XBT_MAXMIN_FLOAT_T " for event %p\n", surf_get_clock(), cpu->name, - value, event_type); +/* printf("[" "%lg" "] Asking to update CPU \"%s\" with value " */ +/* "%lg" " for event %p\n", surf_get_clock(), cpu->name, */ +/* value, event_type); */ if (event_type == cpu->power_event) { cpu->power_current = value; - lmm_update_constraint_bound(cpu->constraint, + lmm_update_constraint_bound(maxmin_system, cpu->constraint, cpu->power_current * cpu->power_scale); } else if (event_type == cpu->state_event) { if (value > 0) @@ -289,7 +230,7 @@ static void update_resource_state(void *id, return; } -static surf_action_t execute(void *cpu, xbt_maxmin_float_t size) +static surf_action_t execute(void *cpu, double size) { surf_action_cpu_t action = NULL; cpu_t CPU = cpu; @@ -298,9 +239,9 @@ static surf_action_t execute(void *cpu, xbt_maxmin_float_t size) action->generic_action.cost = size; action->generic_action.remains = size; - action->generic_action.start = -1.0; + action->generic_action.max_duration = NO_MAX_DURATION; + action->generic_action.start = surf_get_clock(); action->generic_action.finish = -1.0; - action->generic_action.callback = cpu; action->generic_action.resource_type = (surf_resource_t) surf_cpu_resource; @@ -319,9 +260,37 @@ static surf_action_t execute(void *cpu, xbt_maxmin_float_t size) return (surf_action_t) action; } +static surf_action_t action_sleep(void *cpu, double duration) +{ + surf_action_cpu_t action = NULL; + + action = (surf_action_cpu_t) execute(cpu, 1.0); + action->generic_action.max_duration = duration; + lmm_update_variable_weight(maxmin_system, action->variable, 0.0); + + return (surf_action_t) action; +} + +static void action_suspend(surf_action_t action) +{ + lmm_update_variable_weight(maxmin_system, + ((surf_action_cpu_t) action)->variable, 0.0); +} + +static void action_resume(surf_action_t action) +{ + lmm_update_variable_weight(maxmin_system, + ((surf_action_cpu_t) action)->variable, 1.0); +} + +static int action_is_suspended(surf_action_t action) +{ + return (lmm_get_variable_weight(((surf_action_cpu_t) action)->variable) == 0.0); +} + static e_surf_cpu_state_t get_state(void *cpu) { - return SURF_CPU_OFF; + return ((cpu_t) cpu)->state_current; } static void finalize(void) @@ -350,7 +319,7 @@ static void surf_cpu_resource_init_internal(void) surf_cpu_resource->common_private = xbt_new0(s_surf_resource_private_t, 1); surf_cpu_resource->common_public = xbt_new0(s_surf_resource_public_t, 1); -/* surf_cpu_resource->extension_private = xbt_new0(s_surf_cpu_resource_extension_private_t,1); */ + surf_cpu_resource->extension_public = xbt_new0(s_surf_cpu_resource_extension_public_t, 1); @@ -365,7 +334,6 @@ static void surf_cpu_resource_init_internal(void) surf_cpu_resource->common_public->name_service = name_service; surf_cpu_resource->common_public->get_resource_name = get_resource_name; - surf_cpu_resource->common_public->resource_used = resource_used; surf_cpu_resource->common_public->action_get_state = surf_action_get_state; surf_cpu_resource->common_public->action_free = action_free; @@ -373,7 +341,10 @@ static void surf_cpu_resource_init_internal(void) surf_cpu_resource->common_public->action_recycle = action_recycle; surf_cpu_resource->common_public->action_change_state = action_change_state; + surf_cpu_resource->common_public->action_set_data = surf_action_set_data; + surf_cpu_resource->common_public->name = "CPU"; + surf_cpu_resource->common_private->resource_used = resource_used; surf_cpu_resource->common_private->share_resources = share_resources; surf_cpu_resource->common_private->update_actions_state = update_actions_state; @@ -382,6 +353,11 @@ static void surf_cpu_resource_init_internal(void) surf_cpu_resource->common_private->finalize = finalize; surf_cpu_resource->extension_public->execute = execute; + surf_cpu_resource->extension_public->sleep = action_sleep; + surf_cpu_resource->extension_public->suspend = action_suspend; + surf_cpu_resource->extension_public->resume = action_resume; + surf_cpu_resource->extension_public->is_suspended = action_is_suspended; + surf_cpu_resource->extension_public->get_state = get_state; cpu_set = xbt_dict_new(); @@ -389,8 +365,25 @@ static void surf_cpu_resource_init_internal(void) xbt_assert0(maxmin_system, "surf_init has to be called first!"); } -void surf_cpu_resource_init(const char *filename) +/*********************************************************************/ +/* Basic sharing model for CPU: that is all this started... ;) */ +/*********************************************************************/ +/* @InProceedings{casanova01simgrid, */ +/* author = "H. Casanova", */ +/* booktitle = "Proceedings of the IEEE Symposium on Cluster Computing */ +/* and the Grid (CCGrid'01)", */ +/* publisher = "IEEE Computer Society", */ +/* title = "Simgrid: {A} Toolkit for the Simulation of Application */ +/* Scheduling", */ +/* year = "2001", */ +/* month = may, */ +/* note = "Available at */ +/* \url{http://grail.sdsc.edu/papers/simgrid_ccgrid01.ps.gz}." */ +/* } */ +void surf_cpu_resource_init_Cas01(const char *filename) { + if (surf_cpu_resource) + return; surf_cpu_resource_init_internal(); parse_file(filename); xbt_dynar_push(resource_list, &surf_cpu_resource);