if (!p_maxminSystem)
p_maxminSystem = lmm_system_new(m_selectiveUpdate);
- routing_model_create(createLink("__loopback__",
- 498000000, NULL, 0.000015, NULL,
- SURF_LINK_FATPIPE, NULL));
+ routing_model_create(createLink("__loopback__", 498000000, 0.000015, SURF_LINK_FATPIPE, NULL));
if (p_updateMechanism == UM_LAZY) {
p_actionHeap = xbt_heap_new(8, NULL);
}
}
-Link* NetworkCm02Model::createLink(const char *name,
- double bw_initial, tmgr_trace_t bw_trace,
- double lat_initial, tmgr_trace_t lat_trace,
- e_surf_link_sharing_policy_t policy, xbt_dict_t properties)
+Link* NetworkCm02Model::createLink(const char *name, double bandwidth, double latency, e_surf_link_sharing_policy_t policy, xbt_dict_t properties)
{
- xbt_assert(NULL == Link::byName(name),
- "Link '%s' declared several times in the platform",
- name);
+ xbt_assert(NULL == Link::byName(name), "Link '%s' declared several times in the platform", name);
- Link* link = new NetworkCm02Link(this, name, properties, p_maxminSystem, sg_bandwidth_factor * bw_initial,
- bw_initial, bw_trace, lat_initial, lat_trace, policy);
+ Link* link = new NetworkCm02Link(this, name, properties, p_maxminSystem, sg_bandwidth_factor * bandwidth, bandwidth, latency, policy);
Link::onCreation(link);
return link;
}
NetworkCm02Link::NetworkCm02Link(NetworkCm02Model *model, const char *name, xbt_dict_t props,
lmm_system_t system,
double constraint_value,
- double bw_peak, tmgr_trace_t bw_trace,
- double lat_initial, tmgr_trace_t lat_trace,
+ double bw_peak, double lat_initial,
e_surf_link_sharing_policy_t policy)
: Link(model, name, props, lmm_constraint_new(system, this, constraint_value))
{
m_bandwidth.scale = 1.0;
m_bandwidth.peak = bw_peak;
- if (bw_trace)
- m_bandwidth.event = future_evt_set->add_trace(bw_trace, 0.0, this);
- else
- m_bandwidth.event = NULL;
m_latency.scale = 1.0;
m_latency.peak = lat_initial;
- if (lat_trace)
- m_latency.event = future_evt_set->add_trace(lat_trace, 0.0, this);
if (policy == SURF_LINK_FATPIPE)
lmm_constraint_shared(getConstraint());
public:
NetworkCm02Model();
~NetworkCm02Model() { }
- Link* createLink(const char *name,
- double bw_initial, tmgr_trace_t bw_trace,
- double lat_initial, tmgr_trace_t lat_trace,
- e_surf_link_sharing_policy_t policy,
+ Link* createLink(const char *name, double bandwidth, double latency, e_surf_link_sharing_policy_t policy,
xbt_dict_t properties) override;
void updateActionsStateLazy(double now, double delta) override;
void updateActionsStateFull(double now, double delta) override;
public:
NetworkCm02Link(NetworkCm02Model *model, const char *name, xbt_dict_t props,
lmm_system_t system,
- double constraint_value,
- double bw_peak, tmgr_trace_t bw_trace,
- double lat_initial, tmgr_trace_t lat_trace,
+ double constraint_value, double bw_peak, double lat_initial,
e_surf_link_sharing_policy_t policy);
void apply_event(tmgr_trace_iterator_t event, double value) override;
bool next_occuring_event_isIdempotent() override {return true;}
void updateActionsState(double now, double delta) override;
- Link*
- createLink(const char *name,
- double bw_initial, tmgr_trace_t bw_trace,
- double lat_initial, tmgr_trace_t lat_trace,
- e_surf_link_sharing_policy_t policy,
- xbt_dict_t properties) override { DIE_IMPOSSIBLE; }
+ Link* createLink(const char *name, double bw, double lat, e_surf_link_sharing_policy_t policy, xbt_dict_t properties) override
+ { DIE_IMPOSSIBLE; }
};
/**********
if (link->policy == SURF_LINK_FULLDUPLEX) {
char *link_id;
link_id = bprintf("%s_UP", link->id);
- Link *l = surf_network_model->createLink(link_id,
- link->bandwidth,
- link->bandwidth_trace,
- link->latency,
- link->latency_trace,
+ Link *l = surf_network_model->createLink(link_id, link->bandwidth, link->latency,
link->policy, link->properties);
+ if (link->latency_trace)
+ l->setLatencyTrace(link->latency_trace);
+ if (link->bandwidth_trace)
+ l->setBandwidthTrace(link->bandwidth_trace);
if (link->state_trace)
l->setStateTrace(link->state_trace);
xbt_free(link_id);
link_id = bprintf("%s_DOWN", link->id);
- l = surf_network_model->createLink(link_id,
- link->bandwidth,
- link->bandwidth_trace,
- link->latency,
- link->latency_trace,
+ l = surf_network_model->createLink(link_id, link->bandwidth, link->latency,
link->policy, link->properties);
+ if (link->latency_trace)
+ l->setLatencyTrace(link->latency_trace);
+ if (link->bandwidth_trace)
+ l->setBandwidthTrace(link->bandwidth_trace);
if (link->state_trace)
l->setStateTrace(link->state_trace);
xbt_free(link_id);
} else {
- Link *l=surf_network_model->createLink(link->id,
- link->bandwidth,
- link->bandwidth_trace,
- link->latency,
- link->latency_trace,
+ Link *l=surf_network_model->createLink(link->id, link->bandwidth, link->latency,
link->policy, link->properties);
+ if (link->latency_trace)
+ l->setLatencyTrace(link->latency_trace);
+ if (link->bandwidth_trace)
+ l->setBandwidthTrace(link->bandwidth_trace);
if (link->state_trace)
l->setStateTrace(link->state_trace);
}
XBT_DEBUG("Create link '%s'",name);
}
- void Link::setStateTrace(tmgr_trace_t trace) {
- if (m_stateEvent != nullptr)
- XBT_INFO("Changing the state trace is not well tested. You're on your own.");
- m_stateEvent = future_evt_set->add_trace(trace, 0.0, this);
- }
/** @brief use destroy() instead of this destructor */
Link::~Link() {
onStateChange(this);
}
}
- void Link::set_state_trace(tmgr_trace_t trace)
- {
+ void Link::setStateTrace(tmgr_trace_t trace) {
xbt_assert(m_stateEvent==NULL,"Cannot set a second state trace to Link %s", getName());
-
m_stateEvent = future_evt_set->add_trace(trace, 0.0, this);
}
- void Link::set_bandwidth_trace(tmgr_trace_t trace)
+ void Link::setBandwidthTrace(tmgr_trace_t trace)
{
xbt_assert(m_bandwidth.event==NULL,"Cannot set a second bandwidth trace to Link %s", getName());
-
m_bandwidth.event = future_evt_set->add_trace(trace, 0.0, this);
}
- void Link::set_latency_trace(tmgr_trace_t trace)
+ void Link::setLatencyTrace(tmgr_trace_t trace)
{
xbt_assert(m_latency.event==NULL,"Cannot set a second latency trace to Link %s", getName());
-
m_latency.event = future_evt_set->add_trace(trace, 0.0, this);
}
* @brief Create a Link
*
* @param name The name of the Link
- * @param bw_initial The initial bandwidth of the Link in bytes per second
- * @param bw_trace The trace associated to the Link bandwidth
- * @param lat_initial The initial latency of the Link in seconds
- * @param lat_trace The trace associated to the Link latency
+ * @param bandwidth The initial bandwidth of the Link in bytes per second
+ * @param latency The initial latency of the Link in seconds
* @param policy The sharing policy of the Link
* @param properties Dictionary of properties associated to this Resource
* @return The created Link
*/
- virtual Link* createLink(const char *name,
- double bw_initial,
- tmgr_trace_t bw_trace,
- double lat_initial,
- tmgr_trace_t lat_trace,
- e_surf_link_sharing_policy_t policy,
- xbt_dict_t properties)=0;
+ virtual Link* createLink(const char *name, double bandwidth, double latency,
+ e_surf_link_sharing_policy_t policy, xbt_dict_t properties)=0;
/**
* @brief Create a communication between two hosts.
*/
Link(simgrid::surf::NetworkModel *model, const char *name, xbt_dict_t props, lmm_constraint_t constraint);
- /** @brief State traces are used to model the on/off state of the link */
- void setStateTrace(tmgr_trace_t trace);
-
/* Link destruction logic */
/**************************/
protected:
void turnOn() override;
void turnOff() override;
- virtual void set_state_trace(tmgr_trace_t trace); /*< setup the trace file with states events (ON or OFF). Trace must contain boolean values. */
- virtual void set_bandwidth_trace(tmgr_trace_t trace); /*< setup the trace file with bandwidth events (peak speed changes due to external load). Trace must contain percentages (value between 0 and 1). */
- virtual void set_latency_trace(tmgr_trace_t trace); /*< setup the trace file with latency events (peak latency changes due to external load). Trace must contain absolute values */
+ virtual void setStateTrace(tmgr_trace_t trace); /*< setup the trace file with states events (ON or OFF). Trace must contain boolean values. */
+ virtual void setBandwidthTrace(tmgr_trace_t trace); /*< setup the trace file with bandwidth events (peak speed changes due to external load). Trace must contain percentages (value between 0 and 1). */
+ virtual void setLatencyTrace(tmgr_trace_t trace); /*< setup the trace file with latency events (peak latency changes due to external load). Trace must contain absolute values */
tmgr_trace_iterator_t m_stateEvent = NULL;
s_surf_metric_t m_latency = {1.0,0,NULL};
if(!IPV4addr)
IPV4addr = xbt_dynar_new(sizeof(char*),free);
- Link *l = surf_network_model->createLink(link->id,
- link->bandwidth, link->bandwidth_trace,
- link->latency, link->latency_trace,
+ Link *l = surf_network_model->createLink(link->id, link->bandwidth, link->latency,
link->policy, link->properties);
+ if (link->bandwidth_trace)
+ l->setBandwidthTrace(link->latency_trace);
+ if (link->latency_trace)
+ l->setLatencyTrace(link->latency_trace);
if (link->state_trace)
l->setStateTrace(link->state_trace);
}
-
static void simgrid_ns3_add_router(simgrid::surf::NetCard* router)
{
const char* router_id = router->name();
xbt_dict_free(&dict_socket);
}
-Link* NetworkNS3Model::createLink(const char *name,
- double bw_initial, tmgr_trace_t bw_trace,
- double lat_initial, tmgr_trace_t lat_trace,
- e_surf_link_sharing_policy_t policy,
+Link* NetworkNS3Model::createLink(const char *name, double bandwidth, double latency, e_surf_link_sharing_policy_t policy,
xbt_dict_t properties){
- if (bw_trace)
- XBT_INFO("The NS3 network model doesn't support bandwidth state traces");
- if (lat_trace)
- XBT_INFO("The NS3 network model doesn't support latency state traces");
- Link* link = new NetworkNS3Link(this, name, properties, bw_initial, lat_initial);
+ Link* link = new NetworkNS3Link(this, name, properties, bandwidth, latency);
Link::onCreation(link);
return link;
}
{
THROW_UNIMPLEMENTED;
}
+void NetworkNS3Link::setBandwidthTrace(tmgr_trace_t trace) {
+ xbt_die("The NS3 network model doesn't support latency state traces");
+}
+void NetworkNS3Link::setLatencyTrace(tmgr_trace_t trace) {
+ xbt_die("The NS3 network model doesn't support latency state traces");
+}
/**********
* Action *
class NetworkNS3Model : public NetworkModel {
public:
NetworkNS3Model();
-
~NetworkNS3Model();
- Link* createLink(const char *name,
- double bw_initial, tmgr_trace_t bw_trace,
- double lat_initial, tmgr_trace_t lat_trace,
- e_surf_link_sharing_policy_t policy,
- xbt_dict_t properties) override;
+ Link* createLink(const char *name, double bandwidth, double latency,
+ e_surf_link_sharing_policy_t policy, xbt_dict_t properties) override;
Action *communicate(NetCard *src, NetCard *dst, double size, double rate);
double next_occuring_event(double now) override;
bool next_occuring_event_isIdempotent() {return false;}
************/
class NetworkNS3Link : public Link {
public:
- NetworkNS3Link(NetworkNS3Model *model, const char *name, xbt_dict_t props,
- double bw_initial, double lat_initial);
+ NetworkNS3Link(NetworkNS3Model *model, const char *name, xbt_dict_t props, double bandwidth, double latency);
~NetworkNS3Link();
void apply_event(tmgr_trace_iterator_t event, double value) override;
void updateBandwidth(double value) override {THROW_UNIMPLEMENTED;}
void updateLatency(double value) override {THROW_UNIMPLEMENTED;}
+ void setBandwidthTrace(tmgr_trace_t trace) override;
+ void setLatencyTrace(tmgr_trace_t trace) override;
//private:
int m_created;
double bandwidthConstraint(double rate, double bound, double size);
void communicateCallBack() {};
};
-
-
- /************
- * Resource *
- ************/
-
-
- /**********
- * Action *
- **********/
-
}
}
surf_network_model = new NetworkL07Model(this,p_maxminSystem);
surf_cpu_model_pm = new CpuL07Model(this,p_maxminSystem);
- routing_model_create(surf_network_model->createLink("__loopback__",
- 498000000, NULL,
- 0.000015, NULL,
- SURF_LINK_FATPIPE, NULL));
+ routing_model_create(surf_network_model->createLink("__loopback__", 498000000, 0.000015, SURF_LINK_FATPIPE, NULL));
}
HostL07Model::~HostL07Model() {
return cpu;
}
-Link* NetworkL07Model::createLink(const char *name,
- double bw_initial, tmgr_trace_t bw_trace,
- double lat_initial, tmgr_trace_t lat_trace,
+Link* NetworkL07Model::createLink(const char *name, double bandwidth, double latency,
e_surf_link_sharing_policy_t policy, xbt_dict_t properties)
{
xbt_assert(!Link::byName(name),
"Link '%s' declared several times in the platform.", name);
- Link* link = new LinkL07(this, name, properties, bw_initial, bw_trace, lat_initial, lat_trace, policy);
+ Link* link = new LinkL07(this, name, properties, bandwidth, latency, policy);
Link::onCreation(link);
return link;
}
{
}
-LinkL07::LinkL07(NetworkL07Model *model, const char* name, xbt_dict_t props,
- double bw_initial, tmgr_trace_t bw_trace,
- double lat_initial, tmgr_trace_t lat_trace,
+LinkL07::LinkL07(NetworkL07Model *model, const char* name, xbt_dict_t props, double bandwidth, double latency,
e_surf_link_sharing_policy_t policy)
- : Link(model, name, props, lmm_constraint_new(model->getMaxminSystem(), this, bw_initial))
+ : Link(model, name, props, lmm_constraint_new(model->getMaxminSystem(), this, bandwidth))
{
- m_bandwidth.peak = bw_initial;
- if (bw_trace)
- m_bandwidth.event = future_evt_set->add_trace(bw_trace, 0.0, this);
-
- m_latency.peak = lat_initial;
- if (lat_trace)
- m_latency.event = future_evt_set->add_trace(lat_trace, 0.0, this);
+ m_bandwidth.peak = bandwidth;
+ m_latency.peak = latency;
if (policy == SURF_LINK_FATPIPE)
lmm_constraint_shared(getConstraint());
public:
NetworkL07Model(HostL07Model *hmodel, lmm_system_t sys);
~NetworkL07Model();
- Link* createLink(const char *name,
- double bw_initial,
- tmgr_trace_t bw_trace,
- double lat_initial,
- tmgr_trace_t lat_trace,
+ Link* createLink(const char *name, double bandwidth, double latency,
e_surf_link_sharing_policy_t policy,
xbt_dict_t properties) override;
class LinkL07 : public Link {
public:
LinkL07(NetworkL07Model *model, const char* name, xbt_dict_t props,
- double bw_initial, tmgr_trace_t bw_trace,
- double lat_initial, tmgr_trace_t lat_trace,
- e_surf_link_sharing_policy_t policy);
+ double bandwidth, double latency, e_surf_link_sharing_policy_t policy);
~LinkL07(){ };
bool isUsed() override;
void apply_event(tmgr_trace_iterator_t event, double value) override;
xbt_assert(trace, "Trace %s undefined", trace_name);
Link *link = Link::byName(elm);
xbt_assert(link, "Link %s undefined", elm);
- link->set_state_trace(trace);
+ link->setStateTrace(trace);
}
xbt_dict_foreach(trace_connect_list_link_bw, cursor, trace_name, elm) {
xbt_assert(trace, "Trace %s undefined", trace_name);
Link *link = Link::byName(elm);
xbt_assert(link, "Link %s undefined", elm);
- link->set_bandwidth_trace(trace);
+ link->setBandwidthTrace(trace);
}
xbt_dict_foreach(trace_connect_list_link_lat, cursor, trace_name, elm) {
xbt_assert(trace, "Trace %s undefined", trace_name);
Link *link = Link::byName(elm);
xbt_assert(link, "Link %s undefined", elm);
- link->set_latency_trace(trace);
+ link->setLatencyTrace(trace);
}
/* Free my data */