* under the terms of the license (GNU LGPL) which comes with this package. */
#include "cpu_ti.hpp"
-#include "trace_mgr_private.h"
#include "xbt/heap.h"
+#include "src/surf/trace_mgr.hpp"
+#include "src/surf/platform.hpp"
#ifndef SURF_MODEL_CPUTI_H_
#define SURF_MODEL_CPUTI_H_
}
/**
- * \brief Auxiliary function to calculate the integral between a and b.
- * It simply calculates the integral at point a and b and returns the difference
- * between them.
+ * \brief Auxiliary function to compute the integral between a and b.
+ * It simply computes the integrals at point a and b and returns the difference between them.
* \param trace Trace structure
* \param a Initial point
* \param b Final point
}
/**
- * \brief Auxiliary function to calculate the integral at point a.
+ * \brief Auxiliary function to compute the integral at point a.
* \param trace Trace structure
* \param a point
* \return Integral
}
/**
-* \brief Calculate the time needed to execute "amount" on cpu.
+* \brief Computes the time needed to execute "amount" on cpu.
*
* Here, amount can span multiple trace periods
*
static void cpu_ti_define_callbacks()
{
- sg_platf_postparse_add_cb(simgrid::surf::cpu_add_traces);
+ simgrid::surf::on_postparse.connect([]() {
+ surf_cpu_model_pm->addTraces();
+ });
}
/*********
xbt_heap_free(p_tiActionHeap);
}
-Cpu *CpuTiModel::createCpu(simgrid::Host *host,
+Cpu *CpuTiModel::createCpu(simgrid::s4u::Host *host,
xbt_dynar_t speedPeak,
int pstate,
double speedScale,
tmgr_trace_t speedTrace,
int core,
- e_surf_resource_state_t stateInitial,
+ int initiallyOn,
tmgr_trace_t stateTrace)
{
xbt_assert(core==1,"Multi-core not handled with this model yet");
xbt_assert(xbt_dynar_getfirst_as(speedPeak, double) > 0.0,
"Speed has to be >0.0. Did you forget to specify the mandatory speed attribute?");
CpuTi *cpu = new CpuTi(this, host, speedPeak, pstate, speedScale, speedTrace,
- core, stateInitial, stateTrace);
+ core, initiallyOn, stateTrace);
return cpu;
}
/* connect all traces relative to hosts */
xbt_dict_foreach(trace_connect_list_host_avail, cursor, trace_name, elm) {
tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name);
- CpuTi *cpu = static_cast<CpuTi*>(sg_host_by_name(elm)->p_cpu);
+ CpuTi *cpu = static_cast<CpuTi*>(sg_host_by_name(elm)->pimpl_cpu);
xbt_assert(cpu, "Host %s undefined", elm);
xbt_assert(trace, "Trace %s undefined", trace_name);
xbt_dict_foreach(trace_connect_list_power, cursor, trace_name, elm) {
tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name);
- CpuTi *cpu = static_cast<CpuTi*>(sg_host_by_name(elm)->p_cpu);
+ CpuTi *cpu = static_cast<CpuTi*>(sg_host_by_name(elm)->pimpl_cpu);
xbt_assert(cpu, "Host %s undefined", elm);
xbt_assert(trace, "Trace %s undefined", trace_name);
/************
* Resource *
************/
-CpuTi::CpuTi(CpuTiModel *model, simgrid::Host *host, xbt_dynar_t speedPeak,
+CpuTi::CpuTi(CpuTiModel *model, simgrid::s4u::Host *host, xbt_dynar_t speedPeak,
int pstate, double speedScale, tmgr_trace_t speedTrace, int core,
- e_surf_resource_state_t stateInitial, tmgr_trace_t stateTrace)
- : Cpu(model, host, NULL, pstate, core, 0, speedScale, stateInitial)
+ int initiallyOn, tmgr_trace_t stateTrace)
+ : Cpu(model, host, NULL, pstate, core, 0, speedScale, initiallyOn)
{
- p_speedEvent = NULL;
- m_speedScale = speedScale;
+ xbt_assert(core==1,"Multi-core not handled by this model yet");
m_core = core;
- tmgr_trace_t empty_trace;
- s_tmgr_event_t val;
- xbt_assert(core==1,"Multi-core not handled with this model yet");
- XBT_DEBUG("speed scale %f", speedScale);
+
+ m_speedScale = speedScale;
p_availTrace = new CpuTiTgmr(speedTrace, speedScale);
p_actionSet = new ActionTiList();
- m_lastUpdate = 0;
-
xbt_dynar_get_cpy(speedPeak, 0, &m_speedPeak);
XBT_DEBUG("CPU create: peak=%f", m_speedPeak);
if (stateTrace)
p_stateEvent = tmgr_history_add_trace(history, stateTrace, 0.0, 0, this);
+
if (speedTrace && xbt_dynar_length(speedTrace->s_list.event_list) > 1) {
+ s_tmgr_event_t val;
// add a fake trace event if periodicity == 0
xbt_dynar_get_cpy(speedTrace->s_list.event_list,
xbt_dynar_length(speedTrace->s_list.event_list) - 1, &val);
if (val.delta == 0) {
- empty_trace = tmgr_empty_trace_new();
- p_speedEvent =
- tmgr_history_add_trace(history, empty_trace,
- p_availTrace->m_lastTime, 0, this);
+ tmgr_trace_t empty_trace = tmgr_empty_trace_new();
+ p_speedEvent = tmgr_history_add_trace(history, empty_trace, p_availTrace->m_lastTime, 0, this);
}
}
-};
+}
CpuTi::~CpuTi()
{
delete p_actionSet;
}
-void CpuTi::updateState(tmgr_trace_event_t event_type,
+void CpuTi::updateState(tmgr_trace_iterator_t event_type,
double value, double date)
{
CpuTiAction *action;
} else if (event_type == p_stateEvent) {
if (value > 0) {
- if(getState() == SURF_RESOURCE_OFF)
+ if(isOff())
xbt_dynar_push_as(host_that_restart, char*, (char *)getName());
- setState(SURF_RESOURCE_ON);
+ turnOn();
} else {
- setState(SURF_RESOURCE_OFF);
+ turnOff();
/* put all action running on cpu to failed */
for(ActionTiList::iterator it(p_actionSet->begin()), itend(p_actionSet->end())
CpuTiAction *action;
double sum_priority = 0.0, total_area, min_finish = -1;
-/* update remaning amount of actions */
-updateRemainingAmount(now);
+ /* update remaining amount of actions */
+ updateRemainingAmount(now);
for(ActionTiList::iterator it(p_actionSet->begin()), itend(p_actionSet->end())
; it != itend ; ++it) {
action->m_finish,
action->getMaxDuration());
}
-/* remove from modified cpu */
+ /* remove from modified cpu */
modified(false);
}
return Cpu::getAvailableSpeed();
}
-/**
-* \brief Update the remaining amount of actions
-*
-* \param now Current time
-*/
+/** @brief Update the remaining amount of actions */
void CpuTi::updateRemainingAmount(double now)
{
double area_total;
if (m_lastUpdate >= now)
return;
-/* calcule the surface */
+ /* compute the integration area */
area_total = p_availTrace->integrate(m_lastUpdate, now) * m_speedPeak;
XBT_DEBUG("Flops total: %f, Last update %f", area_total,
m_lastUpdate);
CpuAction *CpuTi::execute(double size)
{
XBT_IN("(%s,%g)", getName(), size);
- CpuTiAction *action = new CpuTiAction(static_cast<CpuTiModel*>(getModel()), size, getState() != SURF_RESOURCE_ON, this);
+ CpuTiAction *action = new CpuTiAction(static_cast<CpuTiModel*>(getModel()), size, isOff(), this);
p_actionSet->push_back(*action);
duration = MAX(duration, sg_surf_precision);
XBT_IN("(%s,%g)", getName(), duration);
- CpuTiAction *action = new CpuTiAction(static_cast<CpuTiModel*>(getModel()), 1.0, getState() != SURF_RESOURCE_ON, this);
+ CpuTiAction *action = new CpuTiAction(static_cast<CpuTiModel*>(getModel()), 1.0, isOff(), this);
action->m_maxDuration = duration;
action->m_suspended = 2;
XBT_OUT();
}
-bool CpuTiAction::isSuspended()
-{
- return m_suspended == 1;
-}
-
void CpuTiAction::setMaxDuration(double duration)
{
double min_finish;
