typedef struct s_smx_simcall* smx_simcall_t;
-typedef enum { // FIXME: move this to s4u::Link; make it an enum class
- SURF_LINK_SPLITDUPLEX = 2,
- SURF_LINK_SHARED = 1,
- SURF_LINK_FATPIPE = 0
-} e_surf_link_sharing_policy_t;
-
/** @ingroup m_datatypes_management_details
* @brief Type for any simgrid size
*/
#define SURF_ROUTING_CLUSTER_DRAGONFLY_HPP_
#include <simgrid/kernel/routing/ClusterZone.hpp>
+#include <simgrid/s4u/Link.hpp>
namespace simgrid {
namespace kernel {
void rankId_to_coords(int rankId, unsigned int (*coords)[4]);
private:
- e_surf_link_sharing_policy_t sharing_policy_;
+ simgrid::s4u::Link::SharingPolicy sharing_policy_;
double bw_ = 0;
double lat_ = 0;
kernel::resource::LinkImpl* const pimpl_;
public:
+ enum class SharingPolicy { SPLITDUPLEX = 2, SHARED = 1, FATPIPE = 0 };
+
/** @brief Retrieve a link from its name */
static Link* by_name(const char* name);
lua_pop(L, 1);
if (policy && not strcmp(policy, "FULLDUPLEX")) {
XBT_WARN("Please update your platform to use SPLITDUPLEX instead of FULLDUPLEX");
- link.policy = SURF_LINK_SPLITDUPLEX;
+ link.policy = simgrid::s4u::Link::SharingPolicy::SPLITDUPLEX;
} else if (policy && not strcmp(policy, "SPLITDUPLEX")) {
- link.policy = SURF_LINK_SPLITDUPLEX;
+ link.policy = simgrid::s4u::Link::SharingPolicy::SPLITDUPLEX;
} else if (policy && not strcmp(policy, "FATPIPE")) {
- link.policy = SURF_LINK_FATPIPE;
+ link.policy = simgrid::s4u::Link::SharingPolicy::FATPIPE;
} else {
- link.policy = SURF_LINK_SHARED;
+ link.policy = simgrid::s4u::Link::SharingPolicy::SHARED;
}
sg_platf_new_link(&link);
lua_pop(L, 1);
if (policy && not strcmp(policy, "FULLDUPLEX")) {
XBT_WARN("Please update your platform to use SPLITDUPLEX instead of FULLDUPLEX");
- link.policy = SURF_LINK_SPLITDUPLEX;
+ link.policy = simgrid::s4u::Link::SharingPolicy::SPLITDUPLEX;
} else if (policy && not strcmp(policy, "SPLITDUPLEX")) {
- link.policy = SURF_LINK_SPLITDUPLEX;
+ link.policy = simgrid::s4u::Link::SharingPolicy::SPLITDUPLEX;
} else if (policy && not strcmp(policy, "FATPIPE")) {
- link.policy = SURF_LINK_FATPIPE;
+ link.policy = simgrid::s4u::Link::SharingPolicy::FATPIPE;
} else {
- link.policy = SURF_LINK_SHARED;
+ link.policy = simgrid::s4u::Link::SharingPolicy::SHARED;
}
sg_platf_new_link(&link);
resource::LinkImpl* linkUp;
resource::LinkImpl* linkDown;
- if (link.policy == SURF_LINK_SPLITDUPLEX) {
+ if (link.policy == simgrid::s4u::Link::SharingPolicy::SPLITDUPLEX) {
linkUp = resource::LinkImpl::byName(link_id + "_UP");
linkDown = resource::LinkImpl::byName(link_id + "_DOWN");
} else {
}
this->sharing_policy_ = cluster->sharing_policy;
- if (cluster->sharing_policy == SURF_LINK_SPLITDUPLEX)
+ if (cluster->sharing_policy == s4u::Link::SharingPolicy::SPLITDUPLEX)
this->num_links_per_link_ = 2;
this->bw_ = cluster->bw;
this->lat_ = cluster->lat;
sg_platf_new_link(&linkTemplate);
XBT_DEBUG("Generating link %s", id.c_str());
resource::LinkImpl* link;
- if (this->sharing_policy_ == SURF_LINK_SPLITDUPLEX) {
+ if (this->sharing_policy_ == s4u::Link::SharingPolicy::SPLITDUPLEX) {
*linkup = resource::LinkImpl::byName(linkTemplate.id + "_UP"); // check link?
*linkdown = resource::LinkImpl::byName(linkTemplate.id + "_DOWN"); // check link ?
} else {
this->createLink(id, 1, &linkup, &linkdown);
this->routers_[i]->my_nodes_[j] = linkup;
- if (this->sharing_policy_ == SURF_LINK_SPLITDUPLEX)
+ if (this->sharing_policy_ == s4u::Link::SharingPolicy::SPLITDUPLEX)
this->routers_[i]->my_nodes_[j + 1] = linkdown;
uniqueId++;
if (cluster->limiter_link) {
linkTemplate.bandwidth = cluster->limiter_link;
linkTemplate.latency = 0;
- linkTemplate.policy = SURF_LINK_SHARED;
+ linkTemplate.policy = s4u::Link::SharingPolicy::SHARED;
linkTemplate.id = "limiter_"+std::to_string(id);
sg_platf_new_link(&linkTemplate);
this->limiter_link_ = resource::LinkImpl::byName(linkTemplate.id);
if (cluster->loopback_bw || cluster->loopback_lat) {
linkTemplate.bandwidth = cluster->loopback_bw;
linkTemplate.latency = cluster->loopback_lat;
- linkTemplate.policy = SURF_LINK_FATPIPE;
+ linkTemplate.policy = s4u::Link::SharingPolicy::FATPIPE;
linkTemplate.id = "loopback_"+ std::to_string(id);
sg_platf_new_link(&linkTemplate);
this->loopback = resource::LinkImpl::byName(linkTemplate.id);
"link_from_" + std::to_string(downNode->id) + "_" + std::to_string(upNode->id) + "_" + std::to_string(uniqueId);
sg_platf_new_link(&linkTemplate);
- if (cluster->sharing_policy == SURF_LINK_SPLITDUPLEX) {
+ if (cluster->sharing_policy == s4u::Link::SharingPolicy::SPLITDUPLEX) {
std::string tmpID = std::string(linkTemplate.id) + "_UP";
this->up_link_ = resource::LinkImpl::byName(tmpID); // check link?
tmpID = std::string(linkTemplate.id) + "_DOWN";
sg_platf_new_link(&link);
resource::LinkImpl* linkUp;
resource::LinkImpl* linkDown;
- if (link.policy == SURF_LINK_SPLITDUPLEX) {
+ if (link.policy == s4u::Link::SharingPolicy::SPLITDUPLEX) {
std::string tmp_link = link_id + "_UP";
linkUp = resource::LinkImpl::byName(tmp_link);
tmp_link = link_id + "_DOWN";
std::string link_up = "link_" + netpoint->get_name() + "_UP";
std::string link_down = "link_" + netpoint->get_name() + "_DOWN";
- resource::LinkImpl* linkUp = surf_network_model->createLink(link_up, bw_out, 0, SURF_LINK_SHARED);
- resource::LinkImpl* linkDown = surf_network_model->createLink(link_down, bw_in, 0, SURF_LINK_SHARED);
+ resource::LinkImpl* linkUp = surf_network_model->createLink(link_up, bw_out, 0, s4u::Link::SharingPolicy::SHARED);
+ resource::LinkImpl* linkDown = surf_network_model->createLink(link_down, bw_in, 0, s4u::Link::SharingPolicy::SHARED);
private_links_.insert({netpoint->id(), {linkUp, linkDown}});
}
}
set_maxmin_system(make_new_lmm_system(select));
- loopback_ = NetworkCm02Model::createLink("__loopback__", 498000000, 0.000015, SURF_LINK_FATPIPE);
+ loopback_ = NetworkCm02Model::createLink("__loopback__", 498000000, 0.000015, s4u::Link::SharingPolicy::FATPIPE);
}
LinkImpl* NetworkCm02Model::createLink(const std::string& name, double bandwidth, double latency,
- e_surf_link_sharing_policy_t policy)
+ s4u::Link::SharingPolicy policy)
{
return new NetworkCm02Link(this, name, bandwidth, latency, policy, get_maxmin_system());
}
* Resource *
************/
NetworkCm02Link::NetworkCm02Link(NetworkCm02Model* model, const std::string& name, double bandwidth, double latency,
- e_surf_link_sharing_policy_t policy, kernel::lmm::System* system)
+ s4u::Link::SharingPolicy policy, kernel::lmm::System* system)
: LinkImpl(model, name, system->constraint_new(this, sg_bandwidth_factor * bandwidth))
{
bandwidth_.scale = 1.0;
latency_.scale = 1.0;
latency_.peak = latency;
- if (policy == SURF_LINK_FATPIPE)
+ if (policy == s4u::Link::SharingPolicy::FATPIPE)
get_constraint()->unshare();
simgrid::s4u::Link::onCreation(this->piface_);
explicit NetworkCm02Model(lmm::System* (*make_new_sys)(bool) = &lmm::make_new_maxmin_system);
virtual ~NetworkCm02Model() = default;
LinkImpl* createLink(const std::string& name, double bandwidth, double latency,
- e_surf_link_sharing_policy_t policy) override;
+ s4u::Link::SharingPolicy policy) override;
void update_actions_state_lazy(double now, double delta) override;
void update_actions_state_full(double now, double delta) override;
Action* communicate(s4u::Host* src, s4u::Host* dst, double size, double rate) override;
class NetworkCm02Link : public LinkImpl {
public:
NetworkCm02Link(NetworkCm02Model* model, const std::string& name, double bandwidth, double latency,
- e_surf_link_sharing_policy_t policy, lmm::System* system);
+ s4u::Link::SharingPolicy policy, lmm::System* system);
virtual ~NetworkCm02Link() = default;
void apply_event(tmgr_trace_event_t event, double value) override;
void setBandwidth(double value) override;
namespace kernel {
namespace resource {
LinkImpl* NetworkConstantModel::createLink(const std::string& name, double bw, double lat,
- e_surf_link_sharing_policy_t policy)
+ s4u::Link::SharingPolicy policy)
{
xbt_die("Refusing to create the link %s: there is no link in the Constant network model. "
double next_occuring_event(double now) override;
void update_actions_state(double now, double delta) override;
- LinkImpl* createLink(const std::string& name, double bw, double lat, e_surf_link_sharing_policy_t policy) override;
- };
-
- /**********
- * Action *
- **********/
- class NetworkConstantAction : public NetworkAction {
- public:
- NetworkConstantAction(NetworkConstantModel *model_, double size, double latency);
- ~NetworkConstantAction();
- double initialLatency_;
- void update_remains_lazy(double now) override;
- };
-
- }
+ LinkImpl* createLink(const std::string& name, double bw, double lat, s4u::Link::SharingPolicy policy) override;
+};
+
+/**********
+ * Action *
+ **********/
+class NetworkConstantAction : public NetworkAction {
+public:
+ NetworkConstantAction(NetworkConstantModel* model_, double size, double latency);
+ ~NetworkConstantAction();
+ double initialLatency_;
+ void update_remains_lazy(double now) override;
+};
}
+} // namespace kernel
} // namespace simgrid
#endif /* NETWORK_CONSTANT_HPP_ */
* @param policy The sharing policy of the Link
*/
virtual LinkImpl* createLink(const std::string& name, double bandwidth, double latency,
- e_surf_link_sharing_policy_t policy) = 0;
+ s4u::Link::SharingPolicy policy) = 0;
/**
* @brief Create a communication between two hosts.
}
LinkImpl* NetworkNS3Model::createLink(const std::string& name, double bandwidth, double latency,
- e_surf_link_sharing_policy_t policy)
+ s4u::Link::SharingPolicy policy)
{
return new LinkNS3(this, name, bandwidth, latency);
}
NetworkNS3Model();
~NetworkNS3Model();
LinkImpl* createLink(const std::string& name, double bandwidth, double latency,
- e_surf_link_sharing_policy_t policy) override;
+ s4u::Link::SharingPolicy policy) override;
kernel::resource::Action* communicate(s4u::Host* src, s4u::Host* dst, double size, double rate) override;
double next_occuring_event(double now) override;
bool next_occuring_event_is_idempotent() override { return false; }
: NetworkModel(Model::UpdateAlgo::Full), hostModel_(hmodel)
{
set_maxmin_system(sys);
- loopback_ = NetworkL07Model::createLink("__loopback__", 498000000, 0.000015, SURF_LINK_FATPIPE);
+ loopback_ = NetworkL07Model::createLink("__loopback__", 498000000, 0.000015, s4u::Link::SharingPolicy::FATPIPE);
}
NetworkL07Model::~NetworkL07Model()
}
kernel::resource::LinkImpl* NetworkL07Model::createLink(const std::string& name, double bandwidth, double latency,
- e_surf_link_sharing_policy_t policy)
+ s4u::Link::SharingPolicy policy)
{
return new LinkL07(this, name, bandwidth, latency, policy);
}
CpuL07::~CpuL07()=default;
LinkL07::LinkL07(NetworkL07Model* model, const std::string& name, double bandwidth, double latency,
- e_surf_link_sharing_policy_t policy)
+ s4u::Link::SharingPolicy policy)
: LinkImpl(model, name, model->get_maxmin_system()->constraint_new(this, bandwidth))
{
bandwidth_.peak = bandwidth;
latency_.peak = latency;
- if (policy == SURF_LINK_FATPIPE)
+ if (policy == s4u::Link::SharingPolicy::FATPIPE)
get_constraint()->unshare();
s4u::Link::onCreation(this->piface_);
NetworkL07Model(HostL07Model* hmodel, kernel::lmm::System* sys);
~NetworkL07Model();
kernel::resource::LinkImpl* createLink(const std::string& name, double bandwidth, double latency,
- e_surf_link_sharing_policy_t policy) override;
+ s4u::Link::SharingPolicy policy) override;
kernel::resource::Action* communicate(s4u::Host* src, s4u::Host* dst, double size, double rate) override;
class LinkL07 : public kernel::resource::LinkImpl {
public:
LinkL07(NetworkL07Model* model, const std::string& name, double bandwidth, double latency,
- e_surf_link_sharing_policy_t policy);
+ s4u::Link::SharingPolicy policy);
~LinkL07() override;
bool is_used() override;
void apply_event(tmgr_trace_event_t event, double value) override;
{
std::vector<std::string> names;
- if (link->policy == SURF_LINK_SPLITDUPLEX) {
+ if (link->policy == simgrid::s4u::Link::SharingPolicy::SPLITDUPLEX) {
names.push_back(link->id+ "_UP");
names.push_back(link->id+ "_DOWN");
} else {
link.id = tmp_link;
link.bandwidth = cluster->loopback_bw;
link.latency = cluster->loopback_lat;
- link.policy = SURF_LINK_FATPIPE;
+ link.policy = simgrid::s4u::Link::SharingPolicy::FATPIPE;
sg_platf_new_link(&link);
linkUp = simgrid::kernel::resource::LinkImpl::byName(tmp_link);
linkDown = simgrid::kernel::resource::LinkImpl::byName(tmp_link);
link.id = tmp_link;
link.bandwidth = cluster->limiter_link;
link.latency = 0;
- link.policy = SURF_LINK_SHARED;
+ link.policy = simgrid::s4u::Link::SharingPolicy::SHARED;
sg_platf_new_link(&link);
linkDown = simgrid::kernel::resource::LinkImpl::byName(tmp_link);
linkUp = linkDown;
sg_platf_new_host(&host);
simgrid::kernel::routing::LinkCreationArgs link;
- link.policy = SURF_LINK_SPLITDUPLEX;
+ link.policy = simgrid::s4u::Link::SharingPolicy::SPLITDUPLEX;
link.latency = cabinet->lat;
link.bandwidth = cabinet->bw;
link.id = "link_" + hostname;
#define SG_PLATF_H
#include "simgrid/host.h"
+#include "simgrid/s4u/Link.hpp"
#include "src/surf/xml/platf.hpp"
#include "src/surf/xml/simgrid_dtd.h"
+
#include <map>
#include <string>
#include <vector>
double latency = 0;
tmgr_trace_t latency_trace = nullptr;
tmgr_trace_t state_trace = nullptr;
- e_surf_link_sharing_policy_t policy = SURF_LINK_FATPIPE;
+ simgrid::s4u::Link::SharingPolicy policy = simgrid::s4u::Link::SharingPolicy::FATPIPE;
std::map<std::string, std::string>* properties = nullptr;
};
std::string topo_parameters;
std::map<std::string, std::string>* properties;
std::string router_id;
- e_surf_link_sharing_policy_t sharing_policy;
- e_surf_link_sharing_policy_t bb_sharing_policy;
+ simgrid::s4u::Link::SharingPolicy sharing_policy;
+ simgrid::s4u::Link::SharingPolicy bb_sharing_policy;
};
class CabinetCreationArgs {
switch (AX_surfxml_cluster_sharing___policy) {
case A_surfxml_cluster_sharing___policy_SHARED:
- cluster.sharing_policy = SURF_LINK_SHARED;
+ cluster.sharing_policy = simgrid::s4u::Link::SharingPolicy::SHARED;
break;
case A_surfxml_cluster_sharing___policy_FULLDUPLEX:
XBT_WARN("FULLDUPLEX is now deprecated. Please update your platform file to use SPLITDUPLEX instead.");
- cluster.sharing_policy = SURF_LINK_SPLITDUPLEX;
+ cluster.sharing_policy = simgrid::s4u::Link::SharingPolicy::SPLITDUPLEX;
break;
case A_surfxml_cluster_sharing___policy_SPLITDUPLEX:
- cluster.sharing_policy = SURF_LINK_SPLITDUPLEX;
+ cluster.sharing_policy = simgrid::s4u::Link::SharingPolicy::SPLITDUPLEX;
break;
case A_surfxml_cluster_sharing___policy_FATPIPE:
- cluster.sharing_policy = SURF_LINK_FATPIPE;
+ cluster.sharing_policy = simgrid::s4u::Link::SharingPolicy::FATPIPE;
break;
default:
surf_parse_error(std::string("Invalid cluster sharing policy for cluster ") + cluster.id);
}
switch (AX_surfxml_cluster_bb___sharing___policy) {
case A_surfxml_cluster_bb___sharing___policy_FATPIPE:
- cluster.bb_sharing_policy = SURF_LINK_FATPIPE;
+ cluster.bb_sharing_policy = simgrid::s4u::Link::SharingPolicy::FATPIPE;
break;
case A_surfxml_cluster_bb___sharing___policy_SHARED:
- cluster.bb_sharing_policy = SURF_LINK_SHARED;
+ cluster.bb_sharing_policy = simgrid::s4u::Link::SharingPolicy::SHARED;
break;
default:
surf_parse_error(std::string("Invalid bb sharing policy in cluster ") + cluster.id);
switch (A_surfxml_link_sharing___policy) {
case A_surfxml_link_sharing___policy_SHARED:
- link.policy = SURF_LINK_SHARED;
+ link.policy = simgrid::s4u::Link::SharingPolicy::SHARED;
break;
case A_surfxml_link_sharing___policy_FATPIPE:
- link.policy = SURF_LINK_FATPIPE;
- break;
+ link.policy = simgrid::s4u::Link::SharingPolicy::FATPIPE;
+ break;
case A_surfxml_link_sharing___policy_FULLDUPLEX:
XBT_WARN("FULLDUPLEX is now deprecated. Please update your platform file to use SPLITDUPLEX instead.");
- link.policy = SURF_LINK_SPLITDUPLEX;
+ link.policy = simgrid::s4u::Link::SharingPolicy::SPLITDUPLEX;
break;
case A_surfxml_link_sharing___policy_SPLITDUPLEX:
- link.policy = SURF_LINK_SPLITDUPLEX;
+ link.policy = simgrid::s4u::Link::SharingPolicy::SPLITDUPLEX;
break;
default:
surf_parse_error(std::string("Invalid sharing policy in link ") + link.id);
link.id = std::string(A_surfxml_backbone_id);
link.bandwidth = surf_parse_get_bandwidth(A_surfxml_backbone_bandwidth, "bandwidth of backbone", link.id.c_str());
link.latency = surf_parse_get_time(A_surfxml_backbone_latency, "latency of backbone", link.id.c_str());
- link.policy = SURF_LINK_SHARED;
+ link.policy = simgrid::s4u::Link::SharingPolicy::SHARED;
sg_platf_new_link(&link);
routing_cluster_add_backbone(simgrid::kernel::resource::LinkImpl::byName(A_surfxml_backbone_id));