/** * Update the CPU total energy for a finished action * */ void update_resource_energy(surf_model_t model, surf_action_lmm_t action) { if(model == surf_cpu_model){ cpu_Cas01_t cpu_model = (cpu_Cas01_t)lmm_constraint_id(lmm_get_cnst_from_var (model->model_private->maxmin_system, action->variable, 0)); if( cpu_model->energy->last_updated < surf_get_clock()) { double load = lmm_constraint_get_usage(cpu_model->constraint) / cpu_model->power_peak; cpu_update_energy(cpu_model, load); } } }
static int xbt_log_layout_simple_doit(xbt_log_layout_t l, xbt_log_event_t ev, const char *fmt) { char *p = ev->buffer; int rem_size = ev->buffer_size; const char *procname; int len; *p = '['; check_overflow(1); /* Display the proc info if available */ procname = xbt_procname(); if (procname && strcmp(procname,"maestro")) { len = snprintf(p, rem_size, "%s:%s:(%d) ", SIMIX_host_self_get_name(), procname, xbt_getpid()); check_overflow(len); } else if (!procname) { len = snprintf(p, rem_size, "%s::(%d) ", SIMIX_host_self_get_name(), xbt_getpid()); check_overflow(len); } /* Display the date */ len = snprintf(p, rem_size, "%f] ", surf_get_clock() - simple_begin_of_time); check_overflow(len); /* Display file position if not INFO */ if (ev->priority != xbt_log_priority_info && !xbt_log_no_loc) { len = snprintf(p, rem_size, "%s:%d: ", ev->fileName, ev->lineNum); check_overflow(len); } /* Display category name */ len = snprintf(p, rem_size, "[%s/%s] ", ev->cat->name, xbt_log_priority_names[ev->priority]); check_overflow(len); /* Display user-provided message */ len = vsnprintf(p, rem_size, fmt, ev->ap); check_overflow(len); /* End it */ *p = '\n'; check_overflow(1); *p = '\0'; return 1; }
void CpuCas01::apply_event(tmgr_trace_iterator_t event, double value) { if (event == speed_.event) { /* TODO (Hypervisor): do the same thing for constraint_core[i] */ xbt_assert(coresAmount_ == 1, "FIXME: add speed scaling code also for constraint_core[i]"); speed_.scale = value; onSpeedChange(); tmgr_trace_event_unref(&speed_.event); } else if (event == stateEvent_) { /* TODO (Hypervisor): do the same thing for constraint_core[i] */ xbt_assert(coresAmount_ == 1, "FIXME: add state change code also for constraint_core[i]"); if (value > 0) { if(isOff()) host_that_restart.push_back(getHost()); turnOn(); } else { lmm_constraint_t cnst = getConstraint(); lmm_variable_t var = nullptr; lmm_element_t elem = nullptr; double date = surf_get_clock(); turnOff(); while ((var = lmm_get_var_from_cnst(getModel()->getMaxminSystem(), cnst, &elem))) { Action *action = static_cast<Action*>(lmm_variable_id(var)); if (action->getState() == Action::State::running || action->getState() == Action::State::ready || action->getState() == Action::State::not_in_the_system) { action->setFinishTime(date); action->setState(Action::State::failed); } } } tmgr_trace_event_unref(&stateEvent_); } else { xbt_die("Unknown event!\n"); } }
static int xbt_log_layout_format_doit(xbt_log_layout_t l, xbt_log_event_t ev, const char *msg_fmt) { char *p = ev->buffer; int rem_size = ev->buffer_size; int precision = -1; int length = -1; char *q; for (q = l->data ; *q != '\0' ; q++) { if (*q == '%') { q++; handle_modifier: switch (*q) { case '\0': fprintf(stderr, "Layout format (%s) ending with %%\n", (char *)l->data); xbt_abort(); case '%': *p = '%'; check_overflow(1); break; case 'n': /* platform-dependant line separator; LOG4J compliant */ *p = '\n'; check_overflow(1); break; case 'e': /* plain space; SimGrid extension */ *p = ' '; check_overflow(1); break; case '.': /* precision specifier */ precision = strtol(q + 1, &q, 10); goto handle_modifier; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': /* length modifier */ length = strtol(q, &q, 10); goto handle_modifier; case 'c': /* category name; LOG4J compliant should accept a precision postfix to show the hierarchy */ show_string(ev->cat->name); break; case 'p': /* priority name; LOG4J compliant */ show_string(xbt_log_priority_names[ev->priority]); break; case 'h': /* host name; SimGrid extension */ show_string(SIMIX_host_self_get_name()); break; case 't': /* thread name; LOG4J compliant */ show_string(SIMIX_process_self_get_name()); break; case 'P': /* process name; SimGrid extension */ show_string(xbt_procname()); break; case 'i': /* process PID name; SimGrid extension */ show_int(xbt_getpid()); break; case 'F': /* file name; LOG4J compliant */ show_string(ev->fileName); break; case 'l': { /* location; LOG4J compliant */ int len, sz; set_sz_from_precision(); len = snprintf(p, sz, "%s:%d", ev->fileName, ev->lineNum); check_overflow(MIN(sz, len)); break; } case 'L': /* line number; LOG4J compliant */ show_int(ev->lineNum); break; case 'M': /* method (ie, function) name; LOG4J compliant */ show_string(ev->functionName); break; case 'b': /* backtrace; called %throwable in LOG4J */ case 'B': /* short backtrace; called %throwable{short} in LOG4J */ // TODO, backtrace #if 0 && HAVE_BACKTRACE && HAVE_EXECINFO_H && HAVE_POPEN && defined(ADDR2LINE) { xbt_ex_t e(""); e.used = backtrace((void **) e.bt, XBT_BACKTRACE_SIZE); e.bt_strings = NULL; xbt_ex_setup_backtrace(&e); if (*q == 'B') { show_string(e.bt_strings[1] + 8); } else { xbt_strbuff_t buff = xbt_strbuff_new(); int i; xbt_strbuff_append(buff, e.bt_strings[1] + 8); for (i = 2; i < e.used; i++) { xbt_strbuff_append(buff, "\n"); xbt_strbuff_append(buff, e.bt_strings[i] + 8); } show_string(buff->data); xbt_strbuff_free(buff); } } #else show_string("(no backtrace on this arch)"); #endif break; case 'd': /* date; LOG4J compliant */ show_double(surf_get_clock()); break; case 'r': /* application age; LOG4J compliant */ show_double(surf_get_clock() - format_begin_of_time); break; case 'm': { /* user-provided message; LOG4J compliant */ int len, sz; set_sz_from_precision(); len = vsnprintf(p, sz, msg_fmt, ev->ap); check_overflow(MIN(sz, len)); break; } default: fprintf(stderr, ERRMSG, *q, (char *)l->data); xbt_abort(); } } else { *p = *q; check_overflow(1); } } *p = '\0'; return 1; }
int main(int argc, char **argv) { sg_host_t hostA = NULL; sg_host_t hostB = NULL; double now = -1.0; int running; surf_init(&argc, argv); /* Initialize some common structures */ xbt_cfg_set_parse("network/model:CM02"); xbt_cfg_set_parse("cpu/model:Cas01"); xbt_assert(argc >1, "Usage : %s platform.txt\n", argv[0]); parse_platform_file(argv[1]); /*********************** HOST ***********************************/ hostA = sg_host_by_name("Cpu A"); hostB = sg_host_by_name("Cpu B"); /* Let's check that those two processors exist */ XBT_DEBUG("%s : %p", sg_host_get_name(hostA), hostA); XBT_DEBUG("%s : %p", sg_host_get_name(hostB), hostB); /* Let's do something on it */ hostA->pimpl_cpu->execution_start(1000.0); hostB->pimpl_cpu->execution_start(1000.0); surf_host_sleep(hostB, 7.32); surf_network_model_communicate(surf_network_model, hostA, hostB, 150.0, -1.0); surf_solve(-1.0); /* Takes traces into account. Returns 0.0 */ do { surf_action_t action = NULL; unsigned int iter; surf_model_t model = NULL; running = 0; now = surf_get_clock(); XBT_INFO("Next Event : %g", now); xbt_dynar_foreach(all_existing_models, iter, model) { if (surf_model_running_action_set_size((surf_model_t)model)) { XBT_DEBUG("\t Running that model"); running = 1; } while ((action = surf_model_extract_failed_action_set((surf_model_t)model))) { XBT_INFO(" * Done Action"); XBT_DEBUG("\t * Failed Action: %p", action); action->unref(); } while ((action = surf_model_extract_done_action_set((surf_model_t)model))) { XBT_INFO(" * Done Action"); XBT_DEBUG("\t * Done Action: %p", action); action->unref(); } } } while (running && surf_solve(-1.0) >= 0.0); XBT_INFO("Simulation Terminated"); surf_exit(); return 0; }
void test(char *platform) { void *cpuA = NULL; void *cpuB = NULL; void *cardA = NULL; void *cardB = NULL; surf_action_t actionA = NULL; surf_action_t actionB = NULL; surf_action_t actionC = NULL; e_surf_action_state_t stateActionA; e_surf_action_state_t stateActionB; e_surf_action_state_t stateActionC; double now = -1.0; xbt_cfg_set_parse(_sg_cfg_set, "cpu/model:Cas01"); xbt_cfg_set_parse(_sg_cfg_set, "network/model:CM02"); parse_platform_file(platform); /*********************** CPU ***********************************/ XBT_DEBUG("%p", surf_cpu_model_pm); cpuA = surf_cpu_resource_by_name("Cpu A"); cpuB = surf_cpu_resource_by_name("Cpu B"); /* Let's check that those two processors exist */ XBT_DEBUG("%s : %p", surf_resource_name(surf_cpu_resource_priv(cpuA)), cpuA); XBT_DEBUG("%s : %p", surf_resource_name(surf_cpu_resource_priv(cpuB)), cpuB); /* Let's do something on it */ actionA = surf_cpu_execute(cpuA, 1000.0); actionB = surf_cpu_execute(cpuB, 1000.0); actionC = surf_cpu_sleep(cpuB, 7.32); /* Use whatever calling style you want... */ stateActionA = surf_action_get_state(actionA); /* When you know actionA model type */ stateActionB = surf_action_get_state(actionB); /* If you're unsure about it's model type */ stateActionC = surf_action_get_state(actionC); /* When you know actionA model type */ /* And just look at the state of these tasks */ XBT_DEBUG("actionA : %p (%s)", actionA, string_action(stateActionA)); XBT_DEBUG("actionB : %p (%s)", actionB, string_action(stateActionB)); XBT_DEBUG("actionC : %p (%s)", actionB, string_action(stateActionC)); /*********************** Network *******************************/ XBT_DEBUG("%p", surf_network_model); cardA = sg_routing_edge_by_name_or_null("Cpu A"); cardB = sg_routing_edge_by_name_or_null("Cpu B"); /* Let's check that those two processors exist */ XBT_DEBUG("%s : %p", surf_routing_edge_name(cardA), cardA); XBT_DEBUG("%s : %p", surf_routing_edge_name(cardB), cardB); /* Let's do something on it */ surf_network_model_communicate(surf_network_model, cardA, cardB, 150.0, -1.0); surf_solve(-1.0); /* Takes traces into account. Returns 0.0 */ do { surf_action_t action = NULL; now = surf_get_clock(); XBT_DEBUG("Next Event : %g", now); XBT_DEBUG("\t CPU actions"); while ((action = surf_model_extract_failed_action_set((surf_model_t)surf_cpu_model_pm))) { XBT_DEBUG("\t * Failed : %p", action); surf_action_unref(action); } while ((action = surf_model_extract_done_action_set((surf_model_t)surf_cpu_model_pm))) { XBT_DEBUG("\t * Done : %p", action); surf_action_unref(action); } XBT_DEBUG("\t Network actions"); while ((action = surf_model_extract_failed_action_set((surf_model_t)surf_network_model))) { XBT_DEBUG("\t * Failed : %p", action); surf_action_unref(action); } while ((action = surf_model_extract_done_action_set((surf_model_t)surf_network_model))) { XBT_DEBUG("\t * Done : %p", action); surf_action_unref(action); } } while ((surf_model_running_action_set_size((surf_model_t)surf_network_model) || surf_model_running_action_set_size((surf_model_t)surf_cpu_model_pm)) && surf_solve(-1.0) >= 0.0); XBT_DEBUG("Simulation Terminated"); }
void generic_update_actions_state_lazy(double now, double delta, surf_model_t model) { surf_action_lmm_t action; while ((xbt_heap_size(model->model_private->action_heap) > 0) && (double_equals(xbt_heap_maxkey(model->model_private->action_heap), now))) { action = xbt_heap_pop(model->model_private->action_heap); XBT_DEBUG("Something happened to action %p", action); #ifdef HAVE_TRACING if (TRACE_is_enabled()) { if(model == surf_cpu_model){ surf_resource_t cpu = lmm_constraint_id(lmm_get_cnst_from_var (model->model_private->maxmin_system, action->variable, 0)); TRACE_surf_host_set_utilization(cpu->name, ((surf_action_t)action)->category, lmm_variable_getvalue(action->variable), action->last_update, now - action->last_update); } else{ int n = lmm_get_number_of_cnst_from_var(model->model_private->maxmin_system, action->variable); unsigned int i; for (i = 0; i < n; i++){ lmm_constraint_t constraint = lmm_get_cnst_from_var(model->model_private->maxmin_system, action->variable, i); link_CM02_t link = lmm_constraint_id(constraint); TRACE_surf_link_set_utilization(link->lmm_resource.generic_resource.name, ((surf_action_t)action)->category, (lmm_variable_getvalue(action->variable)* lmm_get_cnst_weight_from_var(model->model_private->maxmin_system, action->variable, i)), action->last_update, now - action->last_update); } } } #endif if(model == surf_cpu_model){ action->generic_action.finish = surf_get_clock(); update_resource_energy(model, action); /* set the remains to 0 due to precision problems when updating the remaining amount */ action->generic_action.remains = 0; surf_action_state_set((surf_action_t) action, SURF_ACTION_DONE); surf_action_lmm_heap_remove(model->model_private->action_heap,action); //FIXME: strange call since action was already popped } else{ // if I am wearing a latency hat if (action->hat == LATENCY) { XBT_DEBUG("Latency paid for action %p. Activating", action); lmm_update_variable_weight(model->model_private->maxmin_system, action->variable, ((surf_action_network_CM02_t)(action))->weight); surf_action_lmm_heap_remove(model->model_private->action_heap,action); action->last_update = surf_get_clock(); // if I am wearing a max_duration or normal hat } else if (action->hat == MAX_DURATION || action->hat == NORMAL) { // no need to communicate anymore // assume that flows that reached max_duration have remaining of 0 action->generic_action.finish = surf_get_clock(); XBT_DEBUG("Action %p finished", action); action->generic_action.remains = 0; ((surf_action_t)action)->finish = surf_get_clock(); model->action_state_set((surf_action_t) action, SURF_ACTION_DONE); surf_action_lmm_heap_remove(model->model_private->action_heap,action); if (model->gap_remove && model == surf_network_model) model->gap_remove(action); } } } #ifdef HAVE_TRACING if (TRACE_is_enabled() && model == surf_cpu_model) { //defining the last timestamp that we can safely dump to trace file //without losing the event ascending order (considering all CPU's) double smaller = -1; xbt_swag_t running_actions = model->states.running_action_set; xbt_swag_foreach(action, running_actions) { if (smaller < 0) { smaller = action->last_update; continue; } if (action->last_update < smaller) { smaller = action->last_update; } } if (smaller > 0) { TRACE_last_timestamp_to_dump = smaller; } }
void generic_update_action_remaining_lazy( surf_action_lmm_t action, double now) { double delta = 0.0; surf_model_t model = action->generic_action.model_type; if(model == surf_network_model) { if (action->suspended != 0) return; } else { xbt_assert(action->generic_action.state_set == model->states.running_action_set, "You're updating an action that is not running."); /* bogus priority, skip it */ xbt_assert(action->generic_action.priority > 0, "You're updating an action that seems suspended."); } delta = now - action->last_update; if (action->generic_action.remains > 0) { XBT_DEBUG("Updating action(%p): remains was %lf, last_update was: %lf", action, action->generic_action.remains, action->last_update); double_update(&(action->generic_action.remains), action->last_value * delta); #ifdef HAVE_TRACING if (model == surf_cpu_model && TRACE_is_enabled()) { surf_resource_t cpu = lmm_constraint_id(lmm_get_cnst_from_var (model->model_private->maxmin_system, action->variable, 0)); TRACE_surf_host_set_utilization(cpu->name, action->generic_action.category, action->last_value, action->last_update, now - action->last_update); } #endif XBT_DEBUG("Updating action(%p): remains is now %lf", action, action->generic_action.remains); } if(model == surf_network_model) { if (((surf_action_t)action)->max_duration != NO_MAX_DURATION) double_update(&(((surf_action_t)action)->max_duration), delta); if ((((surf_action_t)action)->remains <= 0) && (lmm_get_variable_weight(action->variable) > 0)) { ((surf_action_t)action)->finish = surf_get_clock(); model->action_state_set((surf_action_t) action, SURF_ACTION_DONE); surf_action_lmm_heap_remove(model->model_private->action_heap,(surf_action_lmm_t)action); } else if (((((surf_action_t)action)->max_duration != NO_MAX_DURATION) && (((surf_action_t)action)->max_duration <= 0))) { ((surf_action_t)action)->finish = surf_get_clock(); model->action_state_set((surf_action_t) action, SURF_ACTION_DONE); surf_action_lmm_heap_remove(model->model_private->action_heap,(surf_action_lmm_t)action); } } action->last_update = now; action->last_value = lmm_variable_getvalue(action->variable); }
int main(int argc, char **argv) { double now = -1.0; surf_init(&argc, argv); /* Initialize some common structures */ xbt_cfg_set_parse("cpu/model:Cas01"); xbt_cfg_set_parse("network/model:CM02"); xbt_assert(argc > 1, "Usage: %s platform.xml\n", argv[0]); parse_platform_file(argv[1]); XBT_DEBUG("CPU model: %p", surf_cpu_model_pm); XBT_DEBUG("Network model: %p", surf_network_model); simgrid::s4u::Host* hostA = sg_host_by_name("Cpu A"); simgrid::s4u::Host* hostB = sg_host_by_name("Cpu B"); /* Let's do something on it */ simgrid::surf::Action* actionA = hostA->pimpl_cpu->execution_start(1000.0); simgrid::surf::Action* actionB = hostB->pimpl_cpu->execution_start(1000.0); simgrid::surf::Action* actionC = hostB->pimpl_cpu->sleep(7.32); simgrid::surf::Action::State stateActionA = actionA->getState(); simgrid::surf::Action::State stateActionB = actionB->getState(); simgrid::surf::Action::State stateActionC = actionC->getState(); /* And just look at the state of these tasks */ XBT_INFO("actionA state: %s", string_action(stateActionA)); XBT_INFO("actionB state: %s", string_action(stateActionB)); XBT_INFO("actionC state: %s", string_action(stateActionC)); /* Let's do something on it */ surf_network_model->communicate(hostA, hostB, 150.0, -1.0); surf_solve(-1.0); do { simgrid::surf::ActionList *action_list = nullptr; now = surf_get_clock(); XBT_INFO("Next Event : %g", now); XBT_DEBUG("\t CPU actions"); action_list = surf_cpu_model_pm->getFailedActionSet(); for(simgrid::surf::ActionList::iterator it(action_list->begin()), itNext = it, itend(action_list->end()) ; it != itend ; it=itNext) { ++itNext; simgrid::surf::Action *action = static_cast<simgrid::surf::CpuAction*>(&*it); XBT_INFO(" CPU Failed action"); XBT_DEBUG("\t * Failed : %p", action); action->unref(); } action_list = surf_cpu_model_pm->getDoneActionSet(); for(simgrid::surf::ActionList::iterator it(action_list->begin()), itNext = it, itend(action_list->end()) ; it != itend ; it=itNext) { ++itNext; simgrid::surf::Action *action = static_cast<simgrid::surf::CpuAction*>(&*it); XBT_INFO(" CPU Done action"); XBT_DEBUG("\t * Done : %p", action); action->unref(); } action_list = surf_network_model->getFailedActionSet(); for(simgrid::surf::ActionList::iterator it(action_list->begin()), itNext = it, itend(action_list->end()) ; it != itend ; it=itNext) { ++itNext; simgrid::surf::Action *action = static_cast<simgrid::surf::NetworkAction*>(&*it); XBT_INFO(" Network Failed action"); XBT_DEBUG("\t * Failed : %p", action); action->unref(); } action_list = surf_network_model->getDoneActionSet(); for(simgrid::surf::ActionList::iterator it(action_list->begin()), itNext = it, itend(action_list->end()) ; it != itend ; it=itNext) { ++itNext; simgrid::surf::Action *action = static_cast<simgrid::surf::NetworkAction*>(&*it); XBT_INFO(" Network Done action"); XBT_DEBUG("\t * Done : %p", action); action->unref(); } } while ((surf_network_model->getRunningActionSet()->size() || surf_cpu_model_pm->getRunningActionSet()->size()) && surf_solve(-1.0) >= 0.0); XBT_DEBUG("Simulation Terminated"); return 0; }
double getClock() { return surf_get_clock(); }
explicit LinkEnergy(simgrid::s4u::Link* ptr) : link_(ptr), last_updated_(surf_get_clock()) {}
double LinkEnergy::get_consumed_energy() { if (last_updated_ < surf_get_clock()) // We need to simcall this as it modifies the environment simgrid::simix::simcall(std::bind(&LinkEnergy::update, this)); return this->total_energy_; }