<folderInfo id="org.eclipse.linuxtools.cdt.autotools.core.toolChain.1628373792.978950279" name="/" resourcePath="">
<toolChain id="org.eclipse.linuxtools.cdt.autotools.core.toolChain.451718623" name="org.eclipse.linuxtools.cdt.autotools.core.toolChain" superClass="org.eclipse.linuxtools.cdt.autotools.core.toolChain">
<targetPlatform id="org.eclipse.linuxtools.cdt.autotools.core.toolchain.targetPlatform.2070619552" isAbstract="false" name="GNU Autotools Target Platform" superClass="org.eclipse.linuxtools.cdt.autotools.core.toolchain.targetPlatform"/>
- <builder buildPath="${workspace_loc:/simgrid}/build" id="org.eclipse.linuxtools.cdt.autotools.core.toolchain.builder.1564602718" keepEnvironmentInBuildfile="false" managedBuildOn="false" superClass="org.eclipse.linuxtools.cdt.autotools.core.toolchain.builder"/>
+ <builder buildPath="${workspace_loc:/simgrid}/build" command="make" id="org.eclipse.linuxtools.cdt.autotools.core.toolchain.builder.1564602718" keepEnvironmentInBuildfile="false" managedBuildOn="false" superClass="org.eclipse.linuxtools.cdt.autotools.core.toolchain.builder"/>
<tool id="org.eclipse.linuxtools.cdt.autotools.core.gnu.toolchain.tool.configure.2013870946" name="configure" superClass="org.eclipse.linuxtools.cdt.autotools.core.gnu.toolchain.tool.configure">
<option id="org.eclipse.linuxtools.cdt.autotools.core.option.configure.name.1303771952" name="Name" superClass="org.eclipse.linuxtools.cdt.autotools.core.option.configure.name" value="org.eclipse.linuxtools.cdt.autotools.core.toolChain.1628373792" valueType="string"/>
</tool>
extern "C" {
#endif
char *surf_routing_edge_name(sg_routing_edge_t edge);
-
+void *surf_as_cluster_get_backbone(AS_t as);
+void surf_as_cluster_set_backbone(AS_t as, void* backbone);
const char *surf_model_name(surf_model_t model);
xbt_swag_t surf_model_done_action_set(surf_model_t model);
xbt_swag_t surf_model_failed_action_set(surf_model_t model);
#include "surf/trace_mgr.h"
#include "surf/surf_resource.h"
-
+#ifdef TOMATO
static XBT_INLINE
surf_resource_lmm_t surf_resource_lmm_new(size_t childsize,
/* for superclass */
tmgr_history_add_trace(history, metric_trace, 0.0, 0, res);
return res;
}
-
+#endif
static XBT_INLINE e_surf_resource_state_t surf_resource_lmm_get_state(void
*r)
xbt_swag_t running_actions = p_runningActionSet;
xbt_swag_foreach_safe(_action, _next_action, running_actions) {
- action = (ActionLmmPtr) _action;
+ action = dynamic_cast<ActionLmmPtr>(static_cast<ActionPtr>(_action));
#ifdef HAVE_TRACING
if (TRACE_is_enabled()) {
CpuPtr x = (CpuPtr) lmm_constraint_id(lmm_get_cnst_from_var
Cpu(CpuModelPtr model, const char* name, xbt_dict_t properties) : Resource(model, name, properties) {};
virtual ActionPtr execute(double size)=0;
virtual ActionPtr sleep(double duration)=0;
- int getCore();
- double getSpeed(double load);
- double getAvailableSpeed();
+ virtual int getCore();
+ virtual double getSpeed(double load);
+ virtual double getAvailableSpeed();
void addTraces(void);
double m_powerPeak; /*< CPU power peak */
double m_powerScale; /*< Percentage of CPU disponible */
if (power_trace)
cpu->power_event =
- tmgr_history_add_trace(history, power_trace, 0.0, 0, cpu);
+ tmgr_history_add_trace(history, power_trace, 0.0, 0, static_cast<ResourcePtr>(cpu));
cpu->state_current = state_initial;
if (state_trace)
return;
if (!strcmp(optim, "TI")) {
- surf_cpu_model = new CpuTiModel();
+ surf_cpu_model_init_ti();
return;
}
host->state_trace,
host->properties);
}
+
CpuCas01LmmPtr CpuCas01Model::createResource(const char *name, double power_peak, double power_scale,
tmgr_trace_t power_trace, int core,
e_surf_resource_state_t state_initial,
double CpuCas01Model::shareResourcesFull(double now)
{
- CpuCas01ActionLmm action;
- Model::shareResourcesMaxMin(p_runningActionSet,
- xbt_swag_offset(action, p_variable),
+ return Model::shareResourcesMaxMin(p_runningActionSet,
p_maxminSystem, lmm_solve);
- return 0;
}
void CpuCas01Model::addTraces()
/* 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);
- CpuCas01LmmPtr host = (CpuCas01LmmPtr) surf_cpu_resource_priv(surf_cpu_resource_by_name(elm));
+ CpuCas01LmmPtr host = static_cast<CpuCas01LmmPtr>(surf_cpu_resource_priv(surf_cpu_resource_by_name(elm)));
xbt_assert(host, "Host %s undefined", elm);
xbt_assert(trace, "Trace %s undefined", trace_name);
host->p_stateEvent =
- tmgr_history_add_trace(history, trace, 0.0, 0, (ResourcePtr) host);
+ tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(host));
}
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);
- CpuCas01LmmPtr host = (CpuCas01LmmPtr) surf_cpu_resource_priv(surf_cpu_resource_by_name(elm));
+ CpuCas01LmmPtr host = dynamic_cast<CpuCas01LmmPtr>(static_cast<ResourcePtr>(surf_cpu_resource_priv(surf_cpu_resource_by_name(elm))));
xbt_assert(host, "Host %s undefined", elm);
xbt_assert(trace, "Trace %s undefined", trace_name);
host->p_powerEvent =
- tmgr_history_add_trace(history, trace, 0.0, 0, (ResourcePtr) host);
+ tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(host));
}
}
double total_time = 0.0;
s_tmgr_event_t val;
unsigned int cpt;
+ p_trace = 0;
/* no availability file, fixed trace */
if (!power_trace) {
return low;
}
+/*************
+ * CallBacks *
+ *************/
+
+static void parse_cpu_ti_init(sg_platf_host_cbarg_t host){
+ ((CpuTiModelPtr)surf_cpu_model)->parseInit(host);
+}
+
+static void add_traces_cpu_ti(){
+ surf_cpu_model->addTraces();
+}
+
+static void cpu_ti_define_callbacks()
+{
+ sg_platf_host_add_cb(parse_cpu_ti_init);
+ sg_platf_postparse_add_cb(add_traces_cpu_ti);
+}
+
/*********
* Model *
*********/
+void surf_cpu_model_init_ti()
+{
+ xbt_assert(!surf_cpu_model,"CPU model already initialized. This should not happen.");
+ surf_cpu_model = new CpuTiModel();
+ cpu_ti_define_callbacks();
+ ModelPtr model = static_cast<ModelPtr>(surf_cpu_model);
+ xbt_dynar_push(model_list, &model);
+}
+
CpuTiModel::CpuTiModel() : CpuModel("cpu_ti")
{
xbt_assert(!surf_cpu_model,"CPU model already initialized. This should not happen.");
- surf_cpu_model = this;
- CpuTiAction action;
+ ActionPtr action;
CpuTi cpu;
cpu_ti_running_action_set_that_does_not_need_being_checked =
- xbt_swag_new(xbt_swag_offset(action, p_stateHookup));
+ xbt_swag_new(xbt_swag_offset(*action, p_stateHookup));
cpu_ti_modified_cpu =
xbt_swag_new(xbt_swag_offset(cpu, p_modifiedCpuHookup));
cpu_ti_action_heap = xbt_heap_new(8, NULL);
xbt_heap_set_update_callback(cpu_ti_action_heap,
cpu_ti_action_update_index_heap);
- /* Define callbacks */
- //TODO sg_platf_host_add_cb(parse_cpu_ti_init);
- //TODO sg_platf_postparse_add_cb(add_traces_cpu_ti);
-
- xbt_dynar_push(model_list, &surf_cpu_model);
}
CpuTiModel::~CpuTiModel()
}
}
- delete surf_cpu_model;
surf_cpu_model = NULL;
xbt_swag_free
/* iterates over modified cpus to update share resources */
xbt_swag_foreach_safe(_cpu, _cpu_next, cpu_ti_modified_cpu) {
- ((CpuTiPtr)_cpu)->updateActionFinishDate(now);
+ static_cast<CpuTiPtr>(_cpu)->updateActionFinishDate(now);
}
/* get the min next event if heap not empty */
if (xbt_heap_size(cpu_ti_action_heap) > 0)
/* 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 = (CpuTiPtr) surf_cpu_resource_priv(surf_cpu_resource_by_name(elm));
+ CpuTiPtr cpu = static_cast<CpuTiPtr>(surf_cpu_resource_priv(surf_cpu_resource_by_name(elm)));
xbt_assert(cpu, "Host %s undefined", elm);
xbt_assert(trace, "Trace %s undefined", trace_name);
continue;
}
XBT_DEBUG("Add state trace: %s to CPU(%s)", trace_name, elm);
- cpu->p_stateEvent = tmgr_history_add_trace(history, trace, 0.0, 0, cpu);
+ cpu->p_stateEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(cpu));
}
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 = (CpuTiPtr) surf_cpu_resource_priv(surf_cpu_resource_by_name(elm));
+ CpuTiPtr cpu = dynamic_cast<CpuTiPtr>(static_cast<ResourcePtr>(surf_cpu_resource_priv(surf_cpu_resource_by_name(elm))));
xbt_assert(cpu, "Host %s undefined", elm);
xbt_assert(trace, "Trace %s undefined", trace_name);
empty_trace = tmgr_empty_trace_new();
cpu->p_powerEvent =
tmgr_history_add_trace(history, empty_trace,
- cpu->p_availTrace->m_lastTime, 0, cpu);
+ cpu->p_availTrace->m_lastTime, 0, static_cast<ResourcePtr>(cpu));
}
}
}
double powerScale, tmgr_trace_t powerTrace, int core,
e_surf_resource_state_t stateInitial, tmgr_trace_t stateTrace,
xbt_dict_t properties) :
- Cpu(model, name, properties), p_stateCurrent(stateInitial) {
+ Resource(model, name, properties), Cpu(model, name, properties) {
+ p_stateCurrent = stateInitial;
m_powerPeak = powerPeak;
m_powerScale = powerScale;
m_core = core;
xbt_assert(core==1,"Multi-core not handled with this model yet");
XBT_DEBUG("power scale %lf", powerScale);
p_availTrace = new CpuTiTgmr(powerTrace, powerScale);
+
+ CpuTiActionPtr action;
+ p_actionSet = xbt_swag_new(xbt_swag_offset(*action, p_cpuListHookup));
+
+ p_modifiedCpuHookup.prev = 0;
+ p_modifiedCpuHookup.next = 0;
+
if (stateTrace)
- p_stateEvent = tmgr_history_add_trace(history, stateTrace, 0.0, 0, this);
+ p_stateEvent = tmgr_history_add_trace(history, stateTrace, 0.0, 0, static_cast<ResourcePtr>(this));
if (powerTrace && xbt_dynar_length(powerTrace->s_list.event_list) > 1) {
// add a fake trace event if periodicity == 0
xbt_dynar_get_cpy(powerTrace->s_list.event_list,
empty_trace = tmgr_empty_trace_new();
p_powerEvent =
tmgr_history_add_trace(history, empty_trace,
- p_availTrace->m_lastTime, 0, this);
+ p_availTrace->m_lastTime, 0, static_cast<ResourcePtr>(this));
}
}
};
/* put all action running on cpu to failed */
xbt_swag_foreach(_action, p_actionSet) {
- action = (CpuTiActionPtr) _action;
+ action = static_cast<CpuTiActionPtr>(_action);
if (action->getState() == SURF_ACTION_RUNNING
|| action->getState() == SURF_ACTION_READY
|| action->getState() == SURF_ACTION_NOT_IN_THE_SYSTEM) {
updateRemainingAmount(now);
xbt_swag_foreach(_action, p_actionSet) {
- action = (CpuTiActionPtr) _action;
+ action = static_cast<CpuTiActionPtr>(_action);
/* action not running, skip it */
if (action->p_stateSet !=
surf_cpu_model->p_runningActionSet)
m_sumPriority = sum_priority;
xbt_swag_foreach(_action, p_actionSet) {
- action = (CpuTiActionPtr) _action;
+ action = static_cast<CpuTiActionPtr>(_action);
min_finish = -1;
/* action not running, skip it */
if (action->p_stateSet !=
xbt_swag_remove(this, cpu_ti_modified_cpu);
}
-CpuTiModelPtr CpuTi::getModel()
-{
- return static_cast<CpuTiModelPtr>(p_model);
-};
-
bool CpuTi::isUsed()
{
return xbt_swag_size(p_actionSet);
m_lastUpdate);
xbt_swag_foreach(_action, p_actionSet) {
- action = (CpuTiActionPtr) _action;
+ action = static_cast<CpuTiActionPtr>(_action);
/* action not running, skip it */
if (action->p_stateSet !=
getModel()->p_runningActionSet)
CpuActionPtr CpuTi::execute(double size)
{
- return execute(size);
+ return _execute(size);
}
CpuTiActionPtr CpuTi::_execute(double size)
{
XBT_IN("(%s,%g)", m_name, size);
- CpuTiActionPtr action = new CpuTiAction((CpuTiModelPtr) p_model, size, p_stateCurrent != SURF_RESOURCE_ON);
+ CpuTiActionPtr action = new CpuTiAction(static_cast<CpuTiModelPtr>(p_model), size, p_stateCurrent != SURF_RESOURCE_ON);
action->p_cpu = this;
action->m_indexHeap = -1;
xbt_swag_insert(action, p_actionSet);
action->m_suspended = 0; /* Should be useless because of the
- calloc but it seems to help valgrind... */
+ » calloc but it seems to help valgrind... */
XBT_OUT();
return action;
void CpuTiAction::setState(e_surf_action_state_t state)
{
Action::setState(state);
- xbt_swag_insert(surf_cpu_resource_priv(p_cpu), cpu_ti_modified_cpu);
+ xbt_swag_insert(p_cpu, cpu_ti_modified_cpu);
}
int CpuTiAction::unref()
if (!m_refcount) {
xbt_swag_remove(static_cast<ActionPtr>(this), p_stateSet);
/* remove from action_set */
- xbt_swag_remove(this, ((CpuTiPtr)surf_cpu_resource_priv(p_cpu))->p_actionSet);
+ xbt_swag_remove(this, p_cpu->p_actionSet);
/* remove from heap */
xbt_heap_remove(cpu_ti_action_heap, this->m_indexHeap);
- xbt_swag_insert(surf_cpu_resource_priv(p_cpu), cpu_ti_modified_cpu);
+ xbt_swag_insert(p_cpu, cpu_ti_modified_cpu);
delete this;
return 1;
}
{
this->setState(SURF_ACTION_FAILED);
xbt_heap_remove(cpu_ti_action_heap, this->m_indexHeap);
- xbt_swag_insert(surf_cpu_resource_priv(p_cpu), cpu_ti_modified_cpu);
+ xbt_swag_insert(p_cpu, cpu_ti_modified_cpu);
return;
}
if (m_suspended != 2) {
m_suspended = 1;
xbt_heap_remove(cpu_ti_action_heap, m_indexHeap);
- xbt_swag_insert(surf_cpu_resource_priv(p_cpu), cpu_ti_modified_cpu);
+ xbt_swag_insert(p_cpu, cpu_ti_modified_cpu);
}
XBT_OUT();
}
XBT_IN("(%p)", this);
if (m_suspended != 2) {
m_suspended = 0;
- xbt_swag_insert(surf_cpu_resource_priv(p_cpu), cpu_ti_modified_cpu);
+ xbt_swag_insert(p_cpu, cpu_ti_modified_cpu);
}
XBT_OUT();
}
{
XBT_IN("(%p,%g)", this, priority);
m_priority = priority;
- xbt_swag_insert(surf_cpu_resource_priv(p_cpu), cpu_ti_modified_cpu);
+ xbt_swag_insert(p_cpu, cpu_ti_modified_cpu);
XBT_OUT();
}
double CpuTiAction::getRemains()
{
XBT_IN("(%p)", this);
- ((CpuTiPtr)p_cpu)->updateRemainingAmount(surf_get_clock());
+ p_cpu->updateRemainingAmount(surf_get_clock());
XBT_OUT();
return m_remains;
}
void updateActionFinishDate(double now);
bool isUsed();
void printCpuTiModel();
- CpuTiModelPtr getModel();
CpuActionPtr execute(double size);
CpuTiActionPtr _execute(double size);
CpuActionPtr sleep(double duration);
double getAvailableSpeed();
CpuTiTgmrPtr p_availTrace; /*< Structure with data needed to integrate trace file */
- e_surf_resource_state_t p_stateCurrent; /*< CPU current state (ON or OFF) */
tmgr_trace_event_t p_stateEvent; /*< trace file with states events (ON or OFF) */
tmgr_trace_event_t p_powerEvent; /*< trace file with availabitly events */
xbt_swag_t p_actionSet; /*< set with all actions running on cpu */
/**********
* Action *
**********/
+
class CpuTiAction: public CpuAction {
public:
CpuTiAction() {};
- CpuTiAction(CpuTiModelPtr model, double cost, bool failed): CpuAction(model, cost, failed) {};
+ CpuTiAction(CpuTiModelPtr model, double cost, bool failed)
+ : Action(model, cost, failed), CpuAction(model, cost, failed) {
+ p_cpuListHookup.next = 0;
+ p_cpuListHookup.prev = 0;
+ };
void setState(e_surf_action_state_t state);
int unref();
double getRemains();
CpuTiPtr p_cpu;
int m_indexHeap;
+ s_xbt_swag_hookup_t p_cpuListHookup;
int m_suspended;
private:
};
"Cannot connect trace %s to link %s: trace undefined",
trace_name, elm);
- link->p_stateEvent = tmgr_history_add_trace(history, trace, 0.0, 0, link);
+ link->p_stateEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(link));
}
xbt_dict_foreach(trace_connect_list_bandwidth, cursor, trace_name, elm) {
"Cannot connect trace %s to link %s: trace undefined",
trace_name, elm);
- link->p_power.event = tmgr_history_add_trace(history, trace, 0.0, 0, link);
+ link->p_power.event = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(link));
}
xbt_dict_foreach(trace_connect_list_latency, cursor, trace_name, elm) {
"Cannot connect trace %s to link %s: trace undefined",
trace_name, elm);
- link->p_latEvent = tmgr_history_add_trace(history, trace, 0.0, 0, link);
+ link->p_latEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(link));
}
}
if (!p_maxminSystem)
p_maxminSystem = lmm_system_new(m_selectiveUpdate);
- routing_model_create(createResource("__loopback__",
+ routing_model_create(static_cast<NetworkCm02LinkPtr>(createResource("__loopback__",
498000000, NULL, 0.000015, NULL,
SURF_RESOURCE_ON, NULL,
- SURF_LINK_FATPIPE, NULL));
+ SURF_LINK_FATPIPE, NULL)));
if (p_updateMechanism == UM_LAZY) {
p_actionHeap = xbt_heap_new(8, NULL);
{
m_latCurrent = lat_initial;
if (lat_trace)
- p_latEvent = tmgr_history_add_trace(history, lat_trace, 0.0, 0, this);
+ p_latEvent = tmgr_history_add_trace(history, lat_trace, 0.0, 0, static_cast<ResourcePtr>(this));
if (policy == SURF_LINK_FATPIPE)
lmm_constraint_shared(p_constraint);
*********/
class NetworkCm02Model : public Model {
public:
+ NetworkCm02Model(int i) : Model("network") {};//FIXME: add network clean interface
NetworkCm02Model(string name);
NetworkCm02Model();
//FIXME:NetworkCm02LinkPtr createResource(string name);
NetworkCm02Link(){};
NetworkCm02Link(NetworkCm02ModelPtr model, const char* name, xbt_dict_t properties) : Resource(model, name, properties) {};
virtual double getBandwidth()=0;
- double getLatency();
+ virtual double getLatency();
virtual bool isShared()=0;
/* Using this object with the public part of
model does not make sense */
class NetworkCm02LinkLmm : public ResourceLmm, public NetworkCm02Link {
public:
+ NetworkCm02LinkLmm(NetworkCm02ModelPtr model, const char* name, xbt_dict_t properties)
+ : ResourceLmm(), NetworkCm02Link(model, name, properties) {};
NetworkCm02LinkLmm(NetworkCm02ModelPtr model, const char *name, xbt_dict_t props,
lmm_system_t system,
double constraint_value,
double StorageModel::shareResources(double now)
{
XBT_DEBUG("storage_share_resources %f", now);
- StorageActionLmm action;
unsigned int i, j;
StoragePtr storage;
StorageActionLmmPtr write_action;
double min_completion = shareResourcesMaxMin(p_runningActionSet,
- xbt_swag_offset(action, p_variable),
storage_maxmin_system, lmm_solve);
double rate;
*********/
Model::Model(string name)
- : m_name(name), m_resOnCB(0), m_resOffCB(0), m_actSuspendCB(0), m_actCancelCB(0), m_actResumeCB(0)
+ : m_name(name), m_resOnCB(0), m_resOffCB(0),
+ m_actSuspendCB(0), m_actCancelCB(0), m_actResumeCB(0),
+ p_maxminSystem(0)
{
ActionPtr action;
p_readyActionSet = xbt_swag_new(xbt_swag_offset(*action, p_stateHookup));
double Model::shareResourcesMaxMin(xbt_swag_t running_actions,
- size_t offset,
lmm_system_t sys,
void (*solve) (lmm_system_t))
{
void *_action = NULL;
- ActionPtr action = NULL;
+ ActionLmmPtr action = NULL;
double min = -1;
double value = -1;
-#define VARIABLE(action) (*((lmm_variable_t*)(((char *) (action)) + (offset))))
solve(sys);
xbt_swag_foreach(_action, running_actions) {
- action = (ActionPtr)_action;
- value = lmm_variable_getvalue(VARIABLE(action));
+ action = dynamic_cast<ActionLmmPtr>(static_cast<ActionPtr>(_action));
+ value = lmm_variable_getvalue(action->p_variable);
if ((value > 0) || (action->m_maxDuration >= 0))
break;
}
- if (!action)
+ if (!_action)
return -1.0;
if (value > 0) {
min = action->m_maxDuration;
- for (action = (ActionPtr) xbt_swag_getNext(action, running_actions->offset);
- action;
- action = (ActionPtr) xbt_swag_getNext(action, running_actions->offset)) {
- value = lmm_variable_getvalue(VARIABLE(action));
+ for (_action = xbt_swag_getNext(static_cast<ActionPtr>(action), running_actions->offset);
+ _action;
+ _action = xbt_swag_getNext(static_cast<ActionPtr>(action), running_actions->offset)) {
+ action = dynamic_cast<ActionLmmPtr>(static_cast<ActionPtr>(_action));
+ value = lmm_variable_getvalue(action->p_variable);
if (value > 0) {
if (action->m_remains > 0)
value = action->m_remains / value;
}
XBT_DEBUG("min value : %f", min);
-#undef VARIABLE
return min;
}
p_constraint = lmm_constraint_new(system, this, constraint_value);
p_stateCurrent = state_init;
if (state_trace)
- p_stateEvent = tmgr_history_add_trace(history, state_trace, 0.0, 0, this);
+ p_stateEvent = tmgr_history_add_trace(history, state_trace, 0.0, 0, static_cast<ResourcePtr>(this));
p_power.scale = 1.0;
p_power.peak = metric_peak;
if (metric_trace)
- p_power.event = tmgr_history_add_trace(history, metric_trace, 0.0, 0, this);
+ p_power.event = tmgr_history_add_trace(history, metric_trace, 0.0, 0, static_cast<ResourcePtr>(this));
}
/**********
virtual double shareResourcesLazy(double now);
virtual double shareResourcesFull(double now);
double shareResourcesMaxMin(xbt_swag_t running_actions,
- size_t offset,
lmm_system_t sys,
void (*solve) (lmm_system_t));
virtual void updateActionsState(double now, double delta);
s_xbt_swag_hookup_t p_stateHookup;
e_surf_action_state_t getState(); /**< get the state*/
- void setState(e_surf_action_state_t state); /**< Change state*/
+ virtual void setState(e_surf_action_state_t state); /**< Change state*/
double getStartTime(); /**< Return the start time of an action */
double getFinishTime(); /**< Return the finish time of an action */
void setData(void* data);
#include "surf.hpp"
#include "workstation.hpp"
#include "network.hpp"
+#include "surf_routing_cluster.hpp"
#include "instr/instr_private.h"
XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_kernel);
* MODEL *
*********/
+void *surf_as_cluster_get_backbone(AS_t as){
+ return static_cast<AsClusterPtr>(as)->p_backbone;
+}
+
+void surf_as_cluster_set_backbone(AS_t as, void* backbone){
+ static_cast<AsClusterPtr>(as)->p_backbone = static_cast<NetworkCm02LinkPtr>(backbone);
+}
+
const char *surf_model_name(surf_model_t model){
return model->m_name.c_str();
}
}
xbt_dict_t surf_resource_get_properties(surf_cpp_resource_t resource){
- return resource->m_properties;
+ return resource->getProperties();
}
e_surf_resource_state_t surf_resource_get_state(surf_cpp_resource_t resource){
}
void surf_action_resume(surf_action_t action){
- action->suspend();
+ action->resume();
}
void surf_action_cancel(surf_action_t action){
/* Check whether a direct bypass is defined */
sg_platf_route_cbarg_t e_route_bypass = NULL;
//FIXME:REMOVE:if (common_father->get_bypass_route)
- common_father->test();
e_route_bypass = common_father->getBypassRoute(src, dst, latency);
"negative latency on route between \"%s\" and \"%s\"", src->p_name, dst->p_name);
}
-static xbt_dynar_t recursive_get_onelink_routes(AsPtr rc)
+xbt_dynar_t RoutingPlatf::getOneLinkRoutes(){
+ return recursiveGetOneLinkRoutes(p_root);
+}
+
+xbt_dynar_t RoutingPlatf::recursiveGetOneLinkRoutes(AsPtr rc)
{
xbt_dynar_t ret = xbt_dynar_new(sizeof(OnelinkPtr), xbt_free);
xbt_dict_cursor_t cursor = NULL;
AS_t rc_child;
xbt_dict_foreach(rc->p_routingSons, cursor, key, rc_child) {
- xbt_dynar_t onelink_child = recursive_get_onelink_routes(rc_child);
+ xbt_dynar_t onelink_child = recursiveGetOneLinkRoutes(rc_child);
if (onelink_child)
xbt_dynar_merge(&ret,&onelink_child);
}
return ret;
}
-static xbt_dynar_t get_onelink_routes(void)
-{
- return recursive_get_onelink_routes(routing_platf->p_root);
-}
-
e_surf_network_element_type_t routing_get_network_element_type(const char *name)
{
RoutingEdgePtr rc = sg_routing_edge_by_name_or_null(name);
/* config the uniq global routing */
routing_platf = new RoutingPlatf();
routing_platf->p_root = NULL;
- //FIXME:routing_platf->get_onelink_routes = get_onelink_routes;
- //FIXME:routing_platf->loopback = loopback;
+ routing_platf->p_loopback = loopback;
routing_platf->p_lastRoute = xbt_dynar_new(sizeof(sg_routing_link_t),NULL);
/* no current routing at moment */
current_routing = NULL;
void routing_cluster_add_backbone(void* bb) {
xbt_assert(current_routing->p_modelDesc == &routing_models[SURF_MODEL_CLUSTER],
"You have to be in model Cluster to use tag backbone!");
- /*FIXME:xbt_assert(!((as_cluster_t)current_routing)->p_backbone, "The backbone link is already defined!");
- ((as_cluster_t)current_routing)->p_backbone = bb;*/
- XBT_DEBUG("Add a backbone to AS '%s'",current_routing->p_name);
+ xbt_assert(!surf_as_cluster_get_backbone(current_routing), "The backbone link is already defined!");
+ surf_as_cluster_set_backbone(current_routing, bb);
+ XBT_DEBUG("Add a backbone to AS '%s'", current_routing->p_name);
}
static void routing_parse_cabinet(sg_platf_cabinet_cbarg_t cabinet)
As(){};
~As(){};
- int test(){return 3;};
+
virtual void getRouteAndLatency(RoutingEdgePtr src, RoutingEdgePtr dst, sg_platf_route_cbarg_t into, double *latency)=0;
virtual xbt_dynar_t getOneLinkRoutes()=0;
virtual void getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges)=0;
void *p_loopback;
xbt_dynar_t p_lastRoute;
xbt_dynar_t getOneLinkRoutes(void);
+ xbt_dynar_t recursiveGetOneLinkRoutes(AsPtr rc);
void getRouteAndLatency(RoutingEdgePtr src, RoutingEdgePtr dst, xbt_dynar_t * links, double *latency);
};
}
AS_t model_none_create(void)
-{//FIXME:
+{
+ return new AsNone();
}
xbt_dynar_t AsNone::getOneLinkRoutes() {
#include "surf_routing_private.h"
+#include "surf_routing_vivaldi.hpp"
extern "C" {
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route_vivaldi, surf, "Routing part of surf");
}
+static XBT_INLINE double euclidean_dist_comp(int index, xbt_dynar_t src, xbt_dynar_t dst) {
+ double src_coord, dst_coord;
+
+ src_coord = xbt_dynar_get_as(src, index, double);
+ dst_coord = xbt_dynar_get_as(dst, index, double);
+
+ return (src_coord-dst_coord)*(src_coord-dst_coord);
+}
AS_t model_vivaldi_create(void)
-{//FIXME:
+{
+ return new AsVivaldi();
+}
+
+void AsVivaldi::getRouteAndLatency(RoutingEdgePtr src, RoutingEdgePtr dst, sg_platf_route_cbarg_t route, double *lat)
+{
+ s_surf_parsing_link_up_down_t info;
+
+ XBT_DEBUG("vivaldi_get_route_and_latency from '%s'[%d] '%s'[%d]",
+ src->p_name, src->m_id, dst->p_name, dst->m_id);
+
+ if(src->p_rcType == SURF_NETWORK_ELEMENT_AS) {
+ route->gw_src = (sg_routing_edge_t) xbt_lib_get_or_null(as_router_lib, ROUTER_PEER(src->p_name), ROUTING_ASR_LEVEL);
+ route->gw_dst = (sg_routing_edge_t) xbt_lib_get_or_null(as_router_lib, ROUTER_PEER(dst->p_name), ROUTING_ASR_LEVEL);
+ }
+
+ double euclidean_dist;
+ xbt_dynar_t src_ctn, dst_ctn;
+ char *tmp_src_name, *tmp_dst_name;
+
+ if(src->p_rcType == SURF_NETWORK_ELEMENT_HOST){
+ tmp_src_name = HOST_PEER(src->p_name);
+
+ if(p_linkUpDownList){
+ info = xbt_dynar_get_as(p_linkUpDownList, src->m_id, s_surf_parsing_link_up_down_t);
+ if(info.link_up) { // link up
+ xbt_dynar_push_as(route->link_list, void*, info.link_up);
+ if (lat)
+ *lat += static_cast<NetworkCm02LinkPtr>(info.link_up)->getLatency();
+ }
+ }
+ src_ctn = (xbt_dynar_t) xbt_lib_get_or_null(host_lib, tmp_src_name, COORD_HOST_LEVEL);
+ if(!src_ctn ) src_ctn = (xbt_dynar_t) xbt_lib_get_or_null(host_lib, src->p_name, COORD_HOST_LEVEL);
+ }
+ else if(src->p_rcType == SURF_NETWORK_ELEMENT_ROUTER || src->p_rcType == SURF_NETWORK_ELEMENT_AS){
+ tmp_src_name = ROUTER_PEER(src->p_name);
+ src_ctn = (xbt_dynar_t) xbt_lib_get_or_null(as_router_lib, tmp_src_name, COORD_ASR_LEVEL);
+ }
+ else{
+ THROW_IMPOSSIBLE;
+ }
+
+ if(dst->p_rcType == SURF_NETWORK_ELEMENT_HOST){
+ tmp_dst_name = HOST_PEER(dst->p_name);
+
+ if(p_linkUpDownList){
+ info = xbt_dynar_get_as(p_linkUpDownList, dst->m_id, s_surf_parsing_link_up_down_t);
+ if(info.link_down) { // link down
+ xbt_dynar_push_as(route->link_list,void*,info.link_down);
+ if (lat)
+ *lat += static_cast<NetworkCm02LinkPtr>(info.link_down)->getLatency();
+ }
+ }
+ dst_ctn = (xbt_dynar_t) xbt_lib_get_or_null(host_lib, tmp_dst_name, COORD_HOST_LEVEL);
+ if(!dst_ctn ) dst_ctn = (xbt_dynar_t) xbt_lib_get_or_null(host_lib, dst->p_name, COORD_HOST_LEVEL);
+ }
+ else if(dst->p_rcType == SURF_NETWORK_ELEMENT_ROUTER || dst->p_rcType == SURF_NETWORK_ELEMENT_AS){
+ tmp_dst_name = ROUTER_PEER(dst->p_name);
+ dst_ctn = (xbt_dynar_t) xbt_lib_get_or_null(as_router_lib, tmp_dst_name, COORD_ASR_LEVEL);
+ }
+ else{
+ THROW_IMPOSSIBLE;
+ }
+
+ xbt_assert(src_ctn,"No coordinate found for element '%s'",tmp_src_name);
+ xbt_assert(dst_ctn,"No coordinate found for element '%s'",tmp_dst_name);
+ free(tmp_src_name);
+ free(tmp_dst_name);
+
+ euclidean_dist = sqrt (euclidean_dist_comp(0,src_ctn,dst_ctn)+euclidean_dist_comp(1,src_ctn,dst_ctn))
+ + fabs(xbt_dynar_get_as(src_ctn, 2, double))+fabs(xbt_dynar_get_as(dst_ctn, 2, double));
+
+ if (lat){
+ XBT_DEBUG("Updating latency %f += %f",*lat,euclidean_dist);
+ *lat += euclidean_dist / 1000.0; //From .ms to .s
+ }
+}
+
+int AsVivaldi::parsePU(RoutingEdgePtr elm) {
+ XBT_DEBUG("Load process unit \"%s\"", elm->p_name);
+ xbt_dynar_push_as(p_indexNetworkElm, sg_routing_edge_t, elm);
+ return xbt_dynar_length(p_indexNetworkElm)-1;
}
--- /dev/null
+#include "surf_routing_generic.hpp"
+#include "network.hpp"
+
+#ifndef SURF_ROUTING_VIVALDI_HPP_
+#define SURF_ROUTING_VIVALDI_HPP_
+
+/***********
+ * Classes *
+ ***********/
+class AsVivaldi;
+typedef AsVivaldi *AsVivaldiPtr;
+
+class AsVivaldi: public AsGeneric {
+public:
+ sg_platf_route_cbarg_t *p_routingTable;
+
+ AsVivaldi() : AsGeneric() {};
+ ~AsVivaldi() {};
+
+ void getRouteAndLatency(RoutingEdgePtr src, RoutingEdgePtr dst, sg_platf_route_cbarg_t into, double *latency);
+ //void getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges);
+ //sg_platf_route_cbarg_t getBypassRoute(RoutingEdgePtr src, RoutingEdgePtr dst, double *lat);
+
+ /* The parser calls the following functions to inform the routing models
+ * that a new element is added to the AS currently built.
+ *
+ * Of course, only the routing model of this AS is informed, not every ones */
+ int parsePU(RoutingEdgePtr elm); /* A host or a router, whatever */
+ //virtual int parseAS( RoutingEdgePtr elm)=0;
+
+ //virtual void parseBypassroute(sg_platf_route_cbarg_t e_route)=0;
+};
+
+
+#endif /* SURF_ROUTING_VIVALDI_HPP_ */
WorkstationModel(string name): Model(name) {};
WorkstationModel();
~WorkstationModel();
- void parseInit(sg_platf_host_cbarg_t host);
+ virtual void parseInit(sg_platf_host_cbarg_t host);
WorkstationCLM03Ptr createResource(string name);
double shareResources(double now);
void updateActionsState(double now, double delta);
- ActionPtr executeParallelTask(int workstation_nb,
+ virtual ActionPtr executeParallelTask(int workstation_nb,
void **workstation_list,
double *computation_amount,
double *communication_amount,
double rate);
- xbt_dynar_t getRoute(WorkstationCLM03Ptr src, WorkstationCLM03Ptr dst);
- ActionPtr communicate(WorkstationCLM03Ptr src, WorkstationCLM03Ptr dst, double size, double rate);
+ virtual xbt_dynar_t getRoute(WorkstationCLM03Ptr src, WorkstationCLM03Ptr dst);
+ virtual ActionPtr communicate(WorkstationCLM03Ptr src, WorkstationCLM03Ptr dst, double size, double rate);
};
/************
void updateState(tmgr_trace_event_t event_type, double value, double date);
- ActionPtr execute(double size);
- ActionPtr sleep(double duration);
+ virtual ActionPtr execute(double size);
+ virtual ActionPtr sleep(double duration);
e_surf_resource_state_t getState();
- int getCore();
- double getSpeed(double load);
- double getAvailableSpeed();
+ virtual int getCore();
+ virtual double getSpeed(double load);
+ virtual double getAvailableSpeed();
xbt_dict_t getProperties();
class WorkstationCLM03Lmm : public WorkstationCLM03, public ResourceLmm {
public:
- WorkstationCLM03Lmm(WorkstationModelPtr model, const char* name, xbt_dict_t props): WorkstationCLM03(model, name, props, NULL, NULL, NULL){};
+ WorkstationCLM03Lmm(WorkstationModelPtr model, const char* name, xbt_dict_t props, xbt_dynar_t storage, RoutingEdgePtr netElm, CpuPtr cpu):
+ WorkstationCLM03(model, name, props, storage, netElm, cpu){};
e_surf_resource_state_t getState();
};
WorkstationL07Model::WorkstationL07Model() : WorkstationModel("Workstation ptask_L07") {
if (!ptask_maxmin_system)
ptask_maxmin_system = lmm_system_new(1);
- routing_model_create(createLinkResource("__loopback__",
+ routing_model_create(p_networkModel->createResource("__loopback__",
498000000, NULL,
0.000015, NULL,
SURF_RESOURCE_ON, NULL,
SURF_LINK_FATPIPE, NULL));
surf_network_model = new NetworkL07Model();
+ surf_cpu_model = new CpuL07Model();
}
double WorkstationL07Model::shareResources(double now)
void *_action;
WorkstationL07ActionLmmPtr action;
- xbt_swag_t running_actions = surf_workstation_model->p_runningActionSet;
+ xbt_swag_t running_actions = this->p_runningActionSet;
double min = this->shareResourcesMaxMin(running_actions,
- xbt_swag_offset((*action),
- p_variable),
ptask_maxmin_system,
bottleneck_solve);
xbt_swag_foreach(_action, running_actions) {
- action = (WorkstationL07ActionLmmPtr) _action;
+ action = dynamic_cast<WorkstationL07ActionLmmPtr>(static_cast<ActionPtr>(_action));
if (action->m_latency > 0) {
if (min < 0) {
min = action->m_latency;
double deltap = 0.0;
void *_action, *_next_action;
WorkstationL07ActionLmmPtr action;
- xbt_swag_t running_actions =
- surf_workstation_model->p_runningActionSet;
- xbt_swag_foreach_safe(_action, _next_action, running_actions) {
- action = (WorkstationL07ActionLmmPtr) _action;
+ xbt_swag_foreach_safe(_action, _next_action, p_runningActionSet) {
+ action = dynamic_cast<WorkstationL07ActionLmmPtr>(static_cast<ActionPtr>(_action));
+
deltap = delta;
if (action->m_latency > 0) {
if (action->m_latency > deltap) {
i++))) {
constraint_id = lmm_constraint_id(cnst);
- if (((WorkstationCLM03LmmPtr)constraint_id)->p_stateCurrent == SURF_RESOURCE_OFF) {
+ if (static_cast<WorkstationCLM03LmmPtr>(constraint_id)->p_stateCurrent == SURF_RESOURCE_OFF) {
XBT_DEBUG("Action (%p) Failed!!", action);
action->m_finish = surf_get_clock();
action->setState(SURF_ACTION_FAILED);
if (communication_amount[i * workstation_nb + j] > 0) {
double lat=0.0;
unsigned int cpt;
+ void *_link;
LinkL07Ptr link;
- routing_platf->getRouteAndLatency(((CpuL07Ptr)workstation_list[i])->p_info, ((CpuL07Ptr)workstation_list[j])->p_info, &route,&lat);
+ routing_platf->getRouteAndLatency(dynamic_cast<WorkstationL07Ptr>(
+ static_cast<ResourcePtr>(
+ surf_workstation_resource_priv(workstation_list[i])))->p_netElm,
+ dynamic_cast<WorkstationL07Ptr>(
+ static_cast<ResourcePtr>(
+ surf_workstation_resource_priv(workstation_list[j])))->p_netElm,
+ &route,
+ &lat);
latency = MAX(latency, lat);
- xbt_dynar_foreach(route, cpt, link) {
- xbt_dict_set(ptask_parallel_task_link_set,link->m_name,link,NULL);
+ xbt_dynar_foreach(route, cpt, _link) {
+ link = dynamic_cast<LinkL07Ptr>(static_cast<NetworkCm02LinkPtr>(_link));
+ xbt_dict_set(ptask_parallel_task_link_set, link->m_name, link, NULL);
}
}
}
lmm_update_variable_weight(ptask_maxmin_system, action->p_variable, 0.0);
for (i = 0; i < workstation_nb; i++)
- lmm_expand(ptask_maxmin_system, ((CpuL07Ptr)workstation_list[i])->p_constraint,
+ lmm_expand(ptask_maxmin_system,
+ static_cast<CpuLmmPtr>(dynamic_cast<WorkstationL07Ptr>(
+ static_cast<ResourcePtr>(
+ surf_workstation_resource_priv(workstation_list[i])))->p_cpu)->p_constraint,
action->p_variable, computation_amount[i]);
for (i = 0; i < workstation_nb; i++) {
for (j = 0; j < workstation_nb; j++) {
+ void *_link;
LinkL07Ptr link;
xbt_dynar_t route=NULL;
if (communication_amount[i * workstation_nb + j] == 0.0)
continue;
- routing_platf->getRouteAndLatency(((CpuL07Ptr)workstation_list[i])->p_info, ((CpuL07Ptr)workstation_list[j])->p_info, &route,NULL);
+ routing_platf->getRouteAndLatency(dynamic_cast<WorkstationL07Ptr>(
+ static_cast<ResourcePtr>(
+ surf_workstation_resource_priv(workstation_list[i])))->p_netElm,
+ dynamic_cast<WorkstationL07Ptr>(
+ static_cast<ResourcePtr>(
+ surf_workstation_resource_priv(workstation_list[j])))->p_netElm,
+ &route, NULL);
- xbt_dynar_foreach(route, cpt, link) {
+ xbt_dynar_foreach(route, cpt, _link) {
+ link = static_cast<LinkL07Ptr>(static_cast<NetworkCm02LinkPtr>(_link));
lmm_expand_add(ptask_maxmin_system, link->p_constraint,
action->p_variable,
communication_amount[i * workstation_nb + j]);
action->m_remains = 0.0;
}
- return (surf_action_t) action;
+ return static_cast<ActionPtr>(action);
+}
+
+ResourcePtr WorkstationL07Model::createResource(const char *name, double power_scale,
+ double power_initial,
+ tmgr_trace_t power_trace,
+ e_surf_resource_state_t state_initial,
+ tmgr_trace_t state_trace,
+ xbt_dict_t cpu_properties)
+{
+ WorkstationL07Ptr wk = NULL;
+ xbt_assert(!surf_workstation_resource_priv(surf_workstation_resource_by_name(name)),
+ "Host '%s' declared several times in the platform file.",
+ name);
+
+ wk = new WorkstationL07(this, name, cpu_properties,
+ static_cast<RoutingEdgePtr>(xbt_lib_get_or_null(host_lib, name, ROUTING_HOST_LEVEL)),
+ dynamic_cast<CpuPtr>(static_cast<ResourcePtr>(xbt_lib_get_or_null(host_lib, name, SURF_CPU_LEVEL))));
+
+ xbt_lib_set(host_lib, name, SURF_WKS_LEVEL, static_cast<ResourcePtr>(wk));
+
+ return wk;//FIXME:xbt_lib_get_elm_or_null(host_lib, name);
}
ActionPtr WorkstationL07Model::communicate(WorkstationCLM03Ptr src, WorkstationCLM03Ptr dst,
double *communication_amount = xbt_new0(double, 4);
ActionPtr res = NULL;
- workstation_list[0] = src;
- workstation_list[1] = dst;
+ workstation_list[0] = static_cast<ResourcePtr>(src);
+ workstation_list[1] = static_cast<ResourcePtr>(dst);
communication_amount[1] = size;
res = executeParallelTask(2, workstation_list,
xbt_dynar_t WorkstationL07Model::getRoute(WorkstationCLM03Ptr src, WorkstationCLM03Ptr dst)
{
xbt_dynar_t route=NULL;
- routing_platf->getRouteAndLatency(((CpuL07Ptr)src)->p_info, ((CpuL07Ptr)dst)->p_info, &route,NULL);
+ routing_platf->getRouteAndLatency(src->p_netElm, dst->p_netElm, &route, NULL);
return route;
}
-WorkstationCLM03Ptr WorkstationL07Model::createCpuResource(const char *name, double power_scale,
+ResourcePtr CpuL07Model::createResource(const char *name, double power_scale,
double power_initial,
tmgr_trace_t power_trace,
e_surf_resource_state_t state_initial,
cpu = new CpuL07(this, name, cpu_properties);
- cpu->p_info = (RoutingEdgePtr) xbt_lib_get_or_null(host_lib, name, ROUTING_HOST_LEVEL);
- if(!(cpu->p_info)) xbt_die("Don't find ROUTING_HOST_LEVEL for '%s'",name);
-
cpu->p_power.scale = power_scale;
xbt_assert(cpu->p_power.scale > 0, "Power has to be >0");
cpu->m_powerCurrent = power_initial;
if (power_trace)
cpu->p_power.event =
- tmgr_history_add_trace(history, power_trace, 0.0, 0, cpu);
+ tmgr_history_add_trace(history, power_trace, 0.0, 0, static_cast<ResourcePtr>(cpu));
cpu->p_stateCurrent = state_initial;
if (state_trace)
cpu->p_stateEvent =
- tmgr_history_add_trace(history, state_trace, 0.0, 0, cpu);
+ tmgr_history_add_trace(history, state_trace, 0.0, 0, static_cast<ResourcePtr>(cpu));
cpu->p_constraint =
lmm_constraint_new(ptask_maxmin_system, cpu,
cpu->m_powerCurrent * cpu->p_power.scale);
- xbt_lib_set(host_lib, name, SURF_WKS_LEVEL, static_cast<ResourcePtr>(cpu));
+ xbt_lib_set(host_lib, name, SURF_CPU_LEVEL, static_cast<ResourcePtr>(cpu));
return cpu;//FIXME:xbt_lib_get_elm_or_null(host_lib, name);
}
-WorkstationCLM03Ptr WorkstationL07Model::createLinkResource(const char *name,
+ResourcePtr NetworkL07Model::createResource(const char *name,
double bw_initial,
tmgr_trace_t bw_trace,
double lat_initial,
nw_link->m_bwCurrent = bw_initial;
if (bw_trace)
nw_link->p_bwEvent =
- tmgr_history_add_trace(history, bw_trace, 0.0, 0, nw_link);
+ tmgr_history_add_trace(history, bw_trace, 0.0, 0, static_cast<ResourcePtr>(nw_link));
nw_link->p_stateCurrent = state_initial;
nw_link->m_latCurrent = lat_initial;
if (lat_trace)
nw_link->p_latEvent =
- tmgr_history_add_trace(history, lat_trace, 0.0, 0, nw_link);
+ tmgr_history_add_trace(history, lat_trace, 0.0, 0, static_cast<ResourcePtr>(nw_link));
if (state_trace)
nw_link->p_stateEvent =
- tmgr_history_add_trace(history, state_trace, 0.0, 0, nw_link);
+ tmgr_history_add_trace(history, state_trace, 0.0, 0, static_cast<ResourcePtr>(nw_link));
nw_link->p_constraint =
lmm_constraint_new(ptask_maxmin_system, nw_link,
if (policy == SURF_LINK_FATPIPE)
lmm_constraint_shared(nw_link->p_constraint);
- xbt_lib_set(link_lib, name, SURF_LINK_LEVEL, nw_link);
+ xbt_lib_set(link_lib, name, SURF_LINK_LEVEL, static_cast<NetworkCm02LinkPtr>(nw_link));
return nw_link;
}
xbt_assert(host, "Host %s undefined", elm);
xbt_assert(trace, "Trace %s undefined", trace_name);
- host->p_stateEvent = tmgr_history_add_trace(history, trace, 0.0, 0, host);
+ host->p_stateEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(host));
}
xbt_dict_foreach(trace_connect_list_power, cursor, trace_name, elm) {
xbt_assert(host, "Host %s undefined", elm);
xbt_assert(trace, "Trace %s undefined", trace_name);
- host->p_power.event = tmgr_history_add_trace(history, trace, 0.0, 0, host);
+ host->p_power.event = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(host));
}
/* Connect traces relative to network */
xbt_assert(link, "Link %s undefined", elm);
xbt_assert(trace, "Trace %s undefined", trace_name);
- link->p_stateEvent = tmgr_history_add_trace(history, trace, 0.0, 0, link);
+ link->p_stateEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(link));
}
xbt_dict_foreach(trace_connect_list_bandwidth, cursor, trace_name, elm) {
xbt_assert(link, "Link %s undefined", elm);
xbt_assert(trace, "Trace %s undefined", trace_name);
- link->p_bwEvent = tmgr_history_add_trace(history, trace, 0.0, 0, link);
+ link->p_bwEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(link));
}
xbt_dict_foreach(trace_connect_list_latency, cursor, trace_name, elm) {
xbt_assert(link, "Link %s undefined", elm);
xbt_assert(trace, "Trace %s undefined", trace_name);
- link->p_latEvent = tmgr_history_add_trace(history, trace, 0.0, 0, link);
+ link->p_latEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(link));
}
}
* Resource *
************/
-CpuL07::CpuL07(WorkstationL07ModelPtr model, const char* name, xbt_dict_t props) : WorkstationCLM03Lmm(model, name, props) {
-
+WorkstationL07::WorkstationL07(WorkstationModelPtr model, const char* name, xbt_dict_t props, RoutingEdgePtr netElm, CpuPtr cpu)
+ : Resource(model, name, props), WorkstationCLM03Lmm(model, name, props, NULL, netElm, cpu)
+{
}
-LinkL07::LinkL07(WorkstationL07ModelPtr model, const char* name, xbt_dict_t props) : WorkstationCLM03Lmm(model, name, props) {
+CpuL07::CpuL07(CpuL07ModelPtr model, const char* name, xbt_dict_t props)
+ : Resource(model, name, props), CpuLmm(model, name, props) {
}
-bool CpuL07::isUsed(){
- return lmm_constraint_used(ptask_maxmin_system, p_constraint);
+LinkL07::LinkL07(NetworkL07ModelPtr model, const char* name, xbt_dict_t props)
+ : Resource(model, name, props), NetworkCm02LinkLmm(model, name, props) {
+
}
-bool LinkL07::isUsed(){
+bool WorkstationL07::isUsed(){
return lmm_constraint_used(ptask_maxmin_system, p_constraint);
}
return;
}
+e_surf_resource_state_t WorkstationL07::getState()
+{
+ return p_cpu->p_stateCurrent;
+}
e_surf_resource_state_t CpuL07::getState()
{
return m_powerCurrent;
}
-ActionPtr CpuL07::execute(double size)
+ActionPtr WorkstationL07::execute(double size)
{
void **workstation_list = xbt_new0(void *, 1);
double *computation_amount = xbt_new0(double, 1);
double *communication_amount = xbt_new0(double, 1);
- workstation_list[0] = this;
+ workstation_list[0] = static_cast<ResourcePtr>(this);
communication_amount[0] = 0.0;
computation_amount[0] = size;
- return ((WorkstationL07ModelPtr)p_model)->executeParallelTask(1, workstation_list,
+ return static_cast<WorkstationL07ModelPtr>(p_model)->executeParallelTask(1, workstation_list,
computation_amount,
communication_amount, -1);
}
-ActionPtr CpuL07::sleep(double duration)
+ActionPtr WorkstationL07::sleep(double duration)
{
WorkstationL07ActionLmmPtr action = NULL;
if (p_communicationAmount[i * m_workstationNb + j] > 0) {
double lat = 0.0;
- routing_platf->getRouteAndLatency(((CpuL07Ptr) p_workstationList[i])->p_info, ((CpuL07Ptr)p_workstationList[j])->p_info, &route, &lat);
+ routing_platf->getRouteAndLatency(dynamic_cast<WorkstationL07Ptr>(
+ static_cast<ResourcePtr>(
+ surf_workstation_resource_priv(p_workstationList[i])))->p_netElm,
+ dynamic_cast<WorkstationL07Ptr>(
+ static_cast<ResourcePtr>(
+ surf_workstation_resource_priv(p_workstationList[j])))->p_netElm,
+ &route, &lat);
lat_current = MAX(lat_current, lat * p_communicationAmount[i * m_workstationNb + j]);
}
/*** Resource Creation & Destruction **/
/**************************************/
-
+static void ptask_parse_workstation_init(sg_platf_host_cbarg_t host)
+{
+ static_cast<WorkstationL07ModelPtr>(surf_workstation_model)->createResource(
+ host->id,
+ host->power_peak,
+ host->power_scale,
+ host->power_trace,
+ host->initial_state,
+ host->state_trace,
+ host->properties);
+}
static void ptask_parse_cpu_init(sg_platf_host_cbarg_t host)
{
- ((WorkstationL07ModelPtr)surf_workstation_model)->createCpuResource(
+ static_cast<CpuL07ModelPtr>(surf_cpu_model)->createResource(
host->id,
host->power_peak,
host->power_scale,
if (link->policy == SURF_LINK_FULLDUPLEX) {
char *link_id;
link_id = bprintf("%s_UP", link->id);
- ((WorkstationL07ModelPtr)surf_workstation_model)->createLinkResource(link_id,
+ static_cast<NetworkL07ModelPtr>(surf_network_model)->createResource(link_id,
link->bandwidth,
link->bandwidth_trace,
link->latency,
link->properties);
xbt_free(link_id);
link_id = bprintf("%s_DOWN", link->id);
- ((WorkstationL07ModelPtr)surf_workstation_model)->createLinkResource(link_id,
+ static_cast<NetworkL07ModelPtr>(surf_network_model)->createResource(link_id,
link->bandwidth,
link->bandwidth_trace,
link->latency,
* it */
xbt_free(link_id);
} else {
- ((WorkstationL07ModelPtr)surf_workstation_model)->createLinkResource(link->id,
+ static_cast<NetworkL07ModelPtr>(surf_network_model)->createResource(link->id,
link->bandwidth,
link->bandwidth_trace,
link->latency,
current_property_set = NULL;
}
-
+static void ptask_add_traces(){
+ static_cast<WorkstationL07ModelPtr>(surf_workstation_model)->addTraces();
+}
static void ptask_define_callbacks()
{
sg_platf_host_add_cb(ptask_parse_cpu_init);
+ sg_platf_host_add_cb(ptask_parse_workstation_init);
sg_platf_link_add_cb(ptask_parse_link_init);
- //FIXME:sg_platf_postparse_add_cb(ptask_add_traces);
+ sg_platf_postparse_add_cb(ptask_add_traces);
}
/**************************************/
xbt_assert(!surf_cpu_model, "CPU model type already defined");
xbt_assert(!surf_network_model, "network model type already defined");
ptask_define_callbacks();
- new WorkstationL07Model();
- xbt_dynar_push(model_list, &surf_workstation_model);
+ surf_workstation_model = new WorkstationL07Model();
+ ModelPtr model = static_cast<ModelPtr>(surf_workstation_model);
+ xbt_dynar_push(model_list, &model);
}
class WorkstationL07Model;
typedef WorkstationL07Model *WorkstationL07ModelPtr;
+class CpuL07Model;
+typedef CpuL07Model *CpuL07ModelPtr;
+
+class NetworkL07Model;
+typedef NetworkL07Model *NetworkL07ModelPtr;
+
+class WorkstationL07;
+typedef WorkstationL07 *WorkstationL07Ptr;
+
class CpuL07;
typedef CpuL07 *CpuL07Ptr;
class WorkstationL07Model : public WorkstationModel {
public:
WorkstationL07Model();
- void parseInit(sg_platf_host_cbarg_t host);
- WorkstationCLM03Ptr createCpuResource(const char *name, double power_scale,
+
+ double shareResources(double now);
+ void updateActionsState(double now, double delta);
+ ResourcePtr createResource(const char *name, double power_scale,
double power_initial,
tmgr_trace_t power_trace,
e_surf_resource_state_t state_initial,
tmgr_trace_t state_trace,
xbt_dict_t cpu_properties);
- WorkstationCLM03Ptr createLinkResource(const char *name,
- double bw_initial,
- tmgr_trace_t bw_trace,
- double lat_initial,
- tmgr_trace_t lat_trace,
- e_surf_resource_state_t
- state_initial,
- tmgr_trace_t state_trace,
- e_surf_link_sharing_policy_t
- policy, xbt_dict_t properties);
- double shareResources(double now);
- void updateActionsState(double now, double delta);
- void addTraces();
-
ActionPtr executeParallelTask(int workstation_nb,
void **workstation_list,
double *computation_amount,
double *communication_amount,
double rate);
- xbt_dynar_t getRoute(WorkstationCLM03Ptr src, WorkstationCLM03Ptr dst);
- ActionPtr communicate(WorkstationCLM03Ptr src, WorkstationCLM03Ptr dst, double size, double rate);
+ xbt_dynar_t getRoute(WorkstationCLM03Ptr src, WorkstationCLM03Ptr dst);
+ ActionPtr communicate(WorkstationCLM03Ptr src, WorkstationCLM03Ptr dst, double size, double rate);
+ void addTraces();
+ CpuL07ModelPtr p_cpuModel;
+ NetworkL07ModelPtr p_networkModel;
+};
+
+class CpuL07Model : public CpuModel {
+public:
+ CpuL07Model() : CpuModel("cpuL07") {};
+ ResourcePtr createResource(const char *name, double power_scale,
+ double power_initial,
+ tmgr_trace_t power_trace,
+ e_surf_resource_state_t state_initial,
+ tmgr_trace_t state_trace,
+ xbt_dict_t cpu_properties);
+ void addTraces() {DIE_IMPOSSIBLE;};
+ WorkstationL07ModelPtr p_workstationModel;
};
class NetworkL07Model : public NetworkCm02Model {
public:
- NetworkL07Model(): NetworkCm02Model() {};
+ NetworkL07Model() : NetworkCm02Model(0) {};
+ ResourcePtr createResource(const char *name,
+ double bw_initial,
+ tmgr_trace_t bw_trace,
+ double lat_initial,
+ tmgr_trace_t lat_trace,
+ e_surf_resource_state_t
+ state_initial,
+ tmgr_trace_t state_trace,
+ e_surf_link_sharing_policy_t
+ policy, xbt_dict_t properties);
+ NetworkCm02ActionPtr communicate(RoutingEdgePtr src, RoutingEdgePtr dst,
+ double size, double rate);
xbt_dynar_t getRoute(WorkstationCLM03Ptr src, WorkstationCLM03Ptr dst) {DIE_IMPOSSIBLE;};
ActionPtr communicate(WorkstationCLM03Ptr src, WorkstationCLM03Ptr dst, double size, double rate) {DIE_IMPOSSIBLE;};
void addTraces() {DIE_IMPOSSIBLE;};
+ WorkstationL07ModelPtr p_workstationModel;
};
/************
* Resource *
************/
-class CpuL07 : public WorkstationCLM03Lmm {
+class WorkstationL07 : public WorkstationCLM03Lmm {
public:
- CpuL07(WorkstationL07ModelPtr model, const char* name, xbt_dict_t properties);
+ WorkstationL07(WorkstationModelPtr model, const char* name, xbt_dict_t props, RoutingEdgePtr netElm, CpuPtr cpu);
bool isUsed();
+ void updateState(tmgr_trace_event_t event_type, double value, double date) {DIE_IMPOSSIBLE;};
+ ActionPtr execute(double size);
+ ActionPtr sleep(double duration);
+ e_surf_resource_state_t getState();
+};
+
+class CpuL07 : public CpuLmm {
+public:
+ CpuL07(CpuL07ModelPtr model, const char* name, xbt_dict_t properties);
+ bool isUsed() {DIE_IMPOSSIBLE;};
void updateState(tmgr_trace_event_t event_type, double value, double date);
e_surf_resource_state_t getState();
double getSpeed(double load);
double getAvailableSpeed();
- ActionPtr execute(double size);
- ActionPtr sleep(double duration);
-
+ ActionPtr execute(double size) {DIE_IMPOSSIBLE;};
+ ActionPtr sleep(double duration) {DIE_IMPOSSIBLE;};
double m_powerCurrent;
- RoutingEdgePtr p_info;
};
-class LinkL07 : public WorkstationCLM03Lmm {
+class LinkL07 : public NetworkCm02LinkLmm {
public:
- LinkL07(WorkstationL07ModelPtr model, const char* name, xbt_dict_t props);
- bool isUsed();
+ LinkL07(NetworkL07ModelPtr model, const char* name, xbt_dict_t props);
+ bool isUsed() {DIE_IMPOSSIBLE;};
void updateState(tmgr_trace_event_t event_type, double value, double date);
double getBandwidth();
double getLatency();
**********/
class WorkstationL07ActionLmm : public WorkstationActionLmm {
public:
- WorkstationL07ActionLmm(ModelPtr model, double cost, bool failed): WorkstationActionLmm(model, cost, failed) {};
+ WorkstationL07ActionLmm(ModelPtr model, double cost, bool failed)
+ : Action(model, cost, failed), WorkstationActionLmm(model, cost, failed) {};
~WorkstationL07ActionLmm();
void updateBound();
