-/* Copyright (c) 2013-2014. The SimGrid Team.
+/* Copyright (c) 2013-2015. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
xbt_assert(!surf_cpu_model_vm,"CPU model already initialized. This should not happen.");
surf_cpu_model_pm = new CpuTiModel();
- surf_cpu_model_vm = new CpuTiModel();
+ surf_cpu_model_vm = new CpuTiModel();
cpu_ti_define_callbacks();
- ModelPtr model_pm = static_cast<ModelPtr>(surf_cpu_model_pm);
- ModelPtr model_vm = static_cast<ModelPtr>(surf_cpu_model_vm);
+ Model *model_pm = static_cast<Model*>(surf_cpu_model_pm);
+ Model *model_vm = static_cast<Model*>(surf_cpu_model_vm);
xbt_dynar_push(model_list, &model_pm);
xbt_dynar_push(model_list, &model_vm);
}
-CpuTiModel::CpuTiModel() : CpuModel("cpu_ti")
+CpuTiModel::CpuTiModel() : CpuModel()
{
p_runningActionSetThatDoesNotNeedBeingChecked = new ActionList();
xbt_heap_free(p_tiActionHeap);
}
-CpuPtr CpuTiModel::createCpu(const char *name,
+Cpu *CpuTiModel::createCpu(const char *name,
xbt_dynar_t powerPeak,
int pstate,
double powerScale,
xbt_dict_t cpuProperties)
{
xbt_assert(core==1,"Multi-core not handled with this model yet");
- xbt_assert(!surf_cpu_resource_priv(surf_cpu_resource_by_name(name)),
+ sg_host_t host = sg_host_by_name(name);
+ xbt_assert(!sg_host_surfcpu(host),
"Host '%s' declared several times in the platform file",
name);
- CpuTiPtr cpu = new CpuTi(this, name, powerPeak, pstate, powerScale, powerTrace,
+ xbt_assert(xbt_dynar_getfirst_as(powerPeak, double) > 0.0,
+ "Power has to be >0.0. Did you forget to specify the mandatory power attribute?");
+ CpuTi *cpu = new CpuTi(this, name, powerPeak, pstate, powerScale, powerTrace,
core, stateInitial, stateTrace, cpuProperties);
- xbt_lib_set(host_lib, name, SURF_CPU_LEVEL, static_cast<ResourcePtr>(cpu));
+ sg_host_surfcpu_set(host, cpu);
return cpu;
}
/* iterates over modified cpus to update share resources */
for(CpuTiList::iterator it(p_modifiedCpu->begin()), itend(p_modifiedCpu->end())
; it != itend ;) {
- CpuTiPtr ti = &*it;
+ CpuTi *ti = &*it;
++it;
ti->updateActionsFinishTime(now);
}
{
while ((xbt_heap_size(p_tiActionHeap) > 0)
&& (xbt_heap_maxkey(p_tiActionHeap) <= now)) {
- CpuTiActionPtr action = (CpuTiActionPtr) xbt_heap_pop(p_tiActionHeap);
+ CpuTiAction *action = (CpuTiAction*) xbt_heap_pop(p_tiActionHeap);
XBT_DEBUG("Action %p: finish", action);
action->finish();
/* set the remains to 0 due to precision problems when updating the remaining amount */
/* 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);
- CpuTiPtr cpu = static_cast<CpuTiPtr>(surf_cpu_resource_priv(surf_cpu_resource_by_name(elm)));
+ CpuTi *cpu = static_cast<CpuTi*>(sg_host_surfcpu(sg_host_by_name(elm)));
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);
- CpuTiPtr cpu = static_cast<CpuTiPtr>(surf_cpu_resource_priv(surf_cpu_resource_by_name(elm)));
+ CpuTi *cpu = static_cast<CpuTi*>(sg_host_surfcpu(sg_host_by_name(elm)));
xbt_assert(cpu, "Host %s undefined", elm);
xbt_assert(trace, "Trace %s undefined", trace_name);
/************
* Resource *
************/
-CpuTi::CpuTi(CpuTiModelPtr model, const char *name, xbt_dynar_t powerPeak,
+CpuTi::CpuTi(CpuTiModel *model, const char *name, xbt_dynar_t powerPeak,
int pstate, double powerScale, tmgr_trace_t powerTrace, int core,
e_surf_resource_state_t stateInitial, tmgr_trace_t stateTrace,
xbt_dict_t properties)
void CpuTi::updateState(tmgr_trace_event_t event_type,
double value, double date)
{
- CpuTiActionPtr action;
+ CpuTiAction *action;
if (event_type == p_powerEvent) {
tmgr_trace_t power_trace;
- CpuTiTgmrPtr trace;
+ CpuTiTgmr *trace;
s_tmgr_event_t val;
XBT_DEBUG("Finish trace date: %f value %f date %f", surf_get_clock(),
action->setFinishTime(date);
action->setState(SURF_ACTION_FAILED);
if (action->m_indexHeap >= 0) {
- CpuTiActionPtr heap_act = (CpuTiActionPtr)
- xbt_heap_remove(static_cast<CpuTiModelPtr>(getModel())->p_tiActionHeap, action->m_indexHeap);
+ CpuTiAction *heap_act = (CpuTiAction*)
+ xbt_heap_remove(static_cast<CpuTiModel*>(getModel())->p_tiActionHeap, action->m_indexHeap);
if (heap_act != action)
DIE_IMPOSSIBLE;
}
void CpuTi::updateActionsFinishTime(double now)
{
- CpuTiActionPtr action;
+ CpuTiAction *action;
double sum_priority = 0.0, total_area, min_finish = -1;
/* update remaning amount of actions */
/* add in action heap */
XBT_DEBUG("action(%p) index %d", action, action->m_indexHeap);
if (action->m_indexHeap >= 0) {
- CpuTiActionPtr heap_act = (CpuTiActionPtr)
- xbt_heap_remove(static_cast<CpuTiModelPtr>(getModel())->p_tiActionHeap, action->m_indexHeap);
+ CpuTiAction *heap_act = (CpuTiAction*)
+ xbt_heap_remove(static_cast<CpuTiModel*>(getModel())->p_tiActionHeap, action->m_indexHeap);
if (heap_act != action)
DIE_IMPOSSIBLE;
}
if (min_finish != NO_MAX_DURATION)
- xbt_heap_push(static_cast<CpuTiModelPtr>(getModel())->p_tiActionHeap, action, min_finish);
+ xbt_heap_push(static_cast<CpuTiModel*>(getModel())->p_tiActionHeap, action, min_finish);
XBT_DEBUG
("Update finish time: Cpu(%s) Action: %p, Start Time: %f Finish Time: %f Max duration %f",
void CpuTi::updateRemainingAmount(double now)
{
double area_total;
- CpuTiActionPtr action;
+ CpuTiAction *action;
/* already updated */
if (m_lastUpdate >= now)
m_lastUpdate = now;
}
-CpuActionPtr CpuTi::execute(double size)
+CpuAction *CpuTi::execute(double size)
{
XBT_IN("(%s,%g)", getName(), size);
- CpuTiActionPtr action = new CpuTiAction(static_cast<CpuTiModelPtr>(getModel()), size, getState() != SURF_RESOURCE_ON, this);
+ CpuTiAction *action = new CpuTiAction(static_cast<CpuTiModel*>(getModel()), size, getState() != SURF_RESOURCE_ON, this);
p_actionSet->push_back(*action);
}
-CpuActionPtr CpuTi::sleep(double duration)
+CpuAction *CpuTi::sleep(double duration)
{
if (duration > 0)
duration = MAX(duration, sg_surf_precision);
XBT_IN("(%s,%g)", getName(), duration);
- CpuTiActionPtr action = new CpuTiAction(static_cast<CpuTiModelPtr>(getModel()), 1.0, getState() != SURF_RESOURCE_ON, this);
+ CpuTiAction *action = new CpuTiAction(static_cast<CpuTiModel*>(getModel()), 1.0, getState() != SURF_RESOURCE_ON, this);
action->m_maxDuration = duration;
action->m_suspended = 2;
/* Move to the *end* of the corresponding action set. This convention
is used to speed up update_resource_state */
action->getStateSet()->erase(action->getStateSet()->iterator_to(*action));
- action->p_stateSet = static_cast<CpuTiModelPtr>(getModel())->p_runningActionSetThatDoesNotNeedBeingChecked;
+ action->p_stateSet = static_cast<CpuTiModel*>(getModel())->p_runningActionSetThatDoesNotNeedBeingChecked;
action->getStateSet()->push_back(*action);
}
}
void CpuTi::modified(bool modified){
- CpuTiListPtr modifiedCpu = static_cast<CpuTiModelPtr>(getModel())->p_modifiedCpu;
+ CpuTiList *modifiedCpu = static_cast<CpuTiModel*>(getModel())->p_modifiedCpu;
if (modified) {
- if (!is_linked()) {
+ if (!cpu_ti_hook.is_linked()) {
modifiedCpu->push_back(*this);
}
} else {
- if (is_linked()) {
+ if (cpu_ti_hook.is_linked()) {
modifiedCpu->erase(modifiedCpu->iterator_to(*this));
}
}
static void cpu_ti_action_update_index_heap(void *action, int i)
{
-((CpuTiActionPtr)action)->updateIndexHeap(i);
+((CpuTiAction*)action)->updateIndexHeap(i);
}
-CpuTiAction::CpuTiAction(CpuTiModelPtr model_, double cost, bool failed,
- CpuTiPtr cpu)
+CpuTiAction::CpuTiAction(CpuTiModel *model_, double cost, bool failed,
+ CpuTi *cpu)
: CpuAction(model_, cost, failed)
{
m_suspended = 0; /* Should be useless because of the
if (actionHook::is_linked())
getStateSet()->erase(getStateSet()->iterator_to(*this));
/* remove from action_set */
- if (actionTiHook::is_linked())
+ if (action_ti_hook.is_linked())
p_cpu->p_actionSet->erase(p_cpu->p_actionSet->iterator_to(*this));
/* remove from heap */
- xbt_heap_remove(static_cast<CpuTiModelPtr>(getModel())->p_tiActionHeap, this->m_indexHeap);
+ xbt_heap_remove(static_cast<CpuTiModel*>(getModel())->p_tiActionHeap, this->m_indexHeap);
p_cpu->modified(true);
delete this;
return 1;
return;
}
-void CpuTiAction::recycle()
-{
- DIE_IMPOSSIBLE;
-}
-
void CpuTiAction::suspend()
{
XBT_IN("(%p)", this);
/* add in action heap */
if (m_indexHeap >= 0) {
- CpuTiActionPtr heap_act = (CpuTiActionPtr)
+ CpuTiAction *heap_act = (CpuTiAction*)
xbt_heap_remove(getModel()->getActionHeap(), m_indexHeap);
if (heap_act != this)
DIE_IMPOSSIBLE;
