#include "src/surf/trace_mgr.hpp"
#include "surf/surf.hpp"
-#ifndef SURF_MODEL_CPUTI_H_
-#define SURF_MODEL_CPUTI_H_
+#define EPSILON 0.000000001
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_cpu_ti, surf_cpu, "Logging specific to the SURF CPU TRACE INTEGRATION module");
*/
double CpuTiTmgr::integrate(double a, double b)
{
- int a_index;
-
if ((a < 0.0) || (a > b)) {
xbt_die("Error, invalid integration interval [%.2f,%.2f]. "
"You probably have a task executing with negative computation amount. Check your code.", a, b);
}
- if (fabs(a -b) < EPSILON)
+ if (fabs(a - b) < EPSILON)
return 0.0;
- if (type_ == TRACE_FIXED) {
- return ((b - a) * value_);
+ if (type_ == Type::FIXED) {
+ return (b - a) * value_;
}
+ int a_index;
if (fabs(ceil(a / last_time_) - a / last_time_) < EPSILON)
a_index = 1 + static_cast<int>(ceil(a / last_time_));
else
return a;
/* Is the trace fixed ? */
- if (type_ == TRACE_FIXED) {
+ if (type_ == Type::FIXED) {
return (a + (amount / value_));
}
/* no availability file, fixed trace */
if (not speed_trace) {
- type_ = TRACE_FIXED;
+ type_ = Type::FIXED;
value_ = value;
XBT_DEBUG("No availability trace. Constant value = %f", value);
return;
/* only one point available, fixed trace */
if (speed_trace->event_list.size() == 1) {
- type_ = TRACE_FIXED;
+ type_ = Type::FIXED;
value_ = speed_trace->event_list.front().value_;
return;
}
- type_ = TRACE_DYNAMIC;
+ type_ = Type::DYNAMIC;
/* count the total time of trace file */
for (auto const& val : speed_trace->event_list)
/*********
* Model *
*********/
+namespace simgrid {
+namespace surf {
-void surf_cpu_model_init_ti()
+void CpuTiModel::create_pm_vm_models()
{
- xbt_assert(not surf_cpu_model_pm, "CPU model already initialized. This should not happen.");
- xbt_assert(not surf_cpu_model_vm, "CPU model already initialized. This should not happen.");
+ xbt_assert(surf_cpu_model_pm == nullptr, "CPU model already initialized. This should not happen.");
+ xbt_assert(surf_cpu_model_vm == nullptr, "CPU model already initialized. This should not happen.");
surf_cpu_model_pm = new simgrid::surf::CpuTiModel();
- all_existing_models->push_back(surf_cpu_model_pm);
-
surf_cpu_model_vm = new simgrid::surf::CpuTiModel();
- all_existing_models->push_back(surf_cpu_model_vm);
}
-namespace simgrid {
-namespace surf {
+CpuTiModel::CpuTiModel() : CpuModel(Model::UpdateAlgo::FULL)
+{
+ all_existing_models.push_back(this);
+}
CpuTiModel::~CpuTiModel()
{
surf_cpu_model_pm = nullptr;
}
-Cpu *CpuTiModel::createCpu(simgrid::s4u::Host *host, std::vector<double>* speedPerPstate, int core)
+Cpu* CpuTiModel::create_cpu(simgrid::s4u::Host* host, std::vector<double>* speed_per_pstate, int core)
{
- return new CpuTi(this, host, speedPerPstate, core);
+ return new CpuTi(this, host, speed_per_pstate, core);
}
double CpuTiModel::next_occuring_event(double now)
if (trace && trace->event_list.size() > 1) {
trace_mgr::DatedValue val = trace->event_list.back();
if (val.date_ < 1e-12)
- speed_.event = future_evt_set->add_trace(new simgrid::trace_mgr::trace(), this);
+ speed_.event = future_evt_set.add_trace(new simgrid::trace_mgr::trace(), this);
}
}
void CpuTi::apply_event(tmgr_trace_event_t event, double value)
{
if (event == speed_.event) {
- XBT_DEBUG("Finish trace date: value %f", value);
+ XBT_DEBUG("Speed changed in trace! New fixed value: %f", value);
+
/* update remaining of actions and put in modified cpu list */
update_remaining_amount(surf_get_clock());
set_modified(true);
- tmgr_trace_t speedTrace = speed_integrated_trace_->speed_trace_;
- trace_mgr::DatedValue val = speedTrace->event_list.back();
delete speed_integrated_trace_;
- speed_.scale = val.value_;
-
- CpuTiTmgr* trace = new CpuTiTmgr(TRACE_FIXED, val.value_);
- XBT_DEBUG("value %f", val.value_);
-
- speed_integrated_trace_ = trace;
+ speed_integrated_trace_ = new CpuTiTmgr(value);
+ speed_.scale = value;
tmgr_trace_event_unref(&speed_.event);
- } else if (event == stateEvent_) {
+ } else if (event == state_event_) {
if (value > 0) {
if (is_off())
- host_that_restart.push_back(getHost());
+ host_that_restart.push_back(get_host());
turn_on();
} else {
turn_off();
}
}
}
- tmgr_trace_event_unref(&stateEvent_);
+ tmgr_trace_event_unref(&state_event_);
} else {
xbt_die("Unknown event!\n");
return not action_set_.empty();
}
-double CpuTi::get_available_speed()
+double CpuTi::get_speed_ratio()
{
speed_.scale = speed_integrated_trace_->get_power_scale(surf_get_clock());
- return Cpu::get_available_speed();
+ return Cpu::get_speed_ratio();
}
/** @brief Update the remaining amount of actions */
void CpuTi::update_remaining_amount(double now)
{
-
- /* already updated */
+ /* already up to date */
if (last_update_ >= now)
return;
action->set_max_duration(duration);
action->suspended_ = kernel::resource::Action::SuspendStates::sleeping;
- if (duration == NO_MAX_DURATION) {
- /* Move to the *end* of the corresponding action set. This convention is used to speed up update_resource_state */
- simgrid::xbt::intrusive_erase(*action->get_state_set(), *action);
- action->state_set_ = &static_cast<CpuTiModel*>(get_model())->runningActionSetThatDoesNotNeedBeingChecked_;
- action->get_state_set()->push_back(*action);
- }
+ if (duration < 0) // NO_MAX_DURATION
+ action->set_state(simgrid::kernel::resource::Action::State::IGNORED);
action_set_.push_back(*action);
}
}
-
-#endif /* SURF_MODEL_CPUTI_H_ */