/** @brief Make a host within that NetZone */
s4u::Host* create_host(const std::string& name, const std::vector<double>& speed_per_pstate, int core_count);
/** @brief Make a link within that NetZone */
- virtual s4u::Link* create_link(const std::string& name, const std::vector<double>& bandwidths, double latency,
+ virtual s4u::Link* create_link(const std::string& name, const std::vector<double>& bandwidths,
s4u::Link::SharingPolicy policy);
/** @brief Creates a new route in this NetZone */
virtual void add_bypass_route(NetPoint* src, NetPoint* dst, NetPoint* gw_src, NetPoint* gw_dst,
void seal() override;
void get_local_route(NetPoint* src, NetPoint* dst, RouteCreationArgs* into, double* latency) override;
- s4u::Link* create_link(const std::string& name, const std::vector<double>& bandwidths, double latency,
+ s4u::Link* create_link(const std::string& name, const std::vector<double>& bandwidths,
s4u::Link::SharingPolicy policy) override;
NetPoint* get_access_point() {return access_point_;}
void turn_on();
bool is_on() const;
void turn_off();
-
+ void seal();
/** Setup the profile with states events (ON or OFF). The profile must contain boolean values. */
void set_state_profile(kernel::profile::Profile* profile);
/** Setup the profile with bandwidth events (peak speed changes due to external load).
return count;
}
-s4u::Link* NetZoneImpl::create_link(const std::string& name, const std::vector<double>& bandwidths, double latency,
+s4u::Link* NetZoneImpl::create_link(const std::string& name, const std::vector<double>& bandwidths,
s4u::Link::SharingPolicy policy)
{
- static double last_warned_latency = sg_surf_precision;
- if (latency != 0.0 && latency < last_warned_latency) {
- XBT_WARN("Latency for link %s is smaller than surf/precision (%g < %g)."
- " For more accuracy, consider setting \"--cfg=surf/precision:%g\".",
- name.c_str(), latency, sg_surf_precision, latency);
- last_warned_latency = latency;
- }
-
- auto* l = surf_network_model->create_link(name, bandwidths, latency, policy);
+ auto* l = surf_network_model->create_link(name, bandwidths, policy);
return l->get_iface();
}
std::string link_up = "link_" + netpoint->get_name() + "_UP";
std::string link_down = "link_" + netpoint->get_name() + "_DOWN";
resource::LinkImpl* linkUp =
- network_model_->create_link(link_up, std::vector<double>(1, bw_out), 0, s4u::Link::SharingPolicy::SHARED);
+ network_model_->create_link(link_up, std::vector<double>(1, bw_out), s4u::Link::SharingPolicy::SHARED);
+ linkUp->seal();
resource::LinkImpl* linkDown =
- network_model_->create_link(link_down, std::vector<double>(1, bw_in), 0, s4u::Link::SharingPolicy::SHARED);
+ network_model_->create_link(link_down, std::vector<double>(1, bw_in), s4u::Link::SharingPolicy::SHARED);
+ linkDown->seal();
private_links_.insert({netpoint->id(), {linkUp, linkDown}});
}
}
}
}
-s4u::Link* WifiZone::create_link(const std::string& name, const std::vector<double>& bandwidths, double latency,
+s4u::Link* WifiZone::create_link(const std::string& name, const std::vector<double>& bandwidths,
s4u::Link::SharingPolicy policy)
{
xbt_assert(wifi_link_ == nullptr,
xbt_assert(policy == s4u::Link::SharingPolicy::WIFI, "Link %s in WIFI zone %s must follow the WIFI sharing policy.",
name.c_str(), get_cname());
- auto s4u_link = NetZoneImpl::create_link(name, bandwidths, latency, policy);
+ auto s4u_link = NetZoneImpl::create_link(name, bandwidths, policy);
wifi_link_ = s4u_link->get_impl();
return s4u_link;
}
{
simgrid::kernel::actor::simcall([this]() { this->pimpl_->turn_off(); });
}
+void Link::seal()
+{
+ simgrid::kernel::actor::simcall([this]() { this->pimpl_->seal(); });
+}
bool Link::is_on() const
{
set_maxmin_system(new lmm::System(select));
loopback_ = NetworkCm02Model::create_link("__loopback__",
std::vector<double>{simgrid::config::get_value<double>("network/loopback-bw")},
- simgrid::config::get_value<double>("network/loopback-lat"),
- s4u::Link::SharingPolicy::FATPIPE);
+ s4u::Link::SharingPolicy::FATPIPE)->set_latency(simgrid::config::get_value<double>("network/loopback-lat"));
+ loopback_->seal();
}
-LinkImpl* NetworkCm02Model::create_link(const std::string& name, const std::vector<double>& bandwidths, double latency,
+LinkImpl* NetworkCm02Model::create_link(const std::string& name, const std::vector<double>& bandwidths,
s4u::Link::SharingPolicy policy)
{
if (policy == s4u::Link::SharingPolicy::WIFI)
return new NetworkWifiLink(this, name, bandwidths, get_maxmin_system());
xbt_assert(bandwidths.size() == 1, "Non-WIFI links must use only 1 bandwidth.");
- return new NetworkCm02Link(this, name, bandwidths[0], latency, policy, get_maxmin_system());
+ return new NetworkCm02Link(this, name, bandwidths[0], policy, get_maxmin_system());
}
void NetworkCm02Model::update_actions_state_lazy(double now, double /*delta*/)
/************
* Resource *
************/
-NetworkCm02Link::NetworkCm02Link(NetworkCm02Model* model, const std::string& name, double bandwidth, double latency,
+NetworkCm02Link::NetworkCm02Link(NetworkCm02Model* model, const std::string& name, double bandwidth,
s4u::Link::SharingPolicy policy, kernel::lmm::System* system)
: LinkImpl(model, name, system->constraint_new(this, sg_bandwidth_factor * bandwidth))
{
bandwidth_.scale = 1.0;
bandwidth_.peak = bandwidth;
- latency_.scale = 1.0;
- latency_.peak = latency;
-
if (policy == s4u::Link::SharingPolicy::FATPIPE)
get_constraint()->unshare();
-
- simgrid::s4u::Link::on_creation(*get_iface());
}
void NetworkCm02Link::apply_event(kernel::profile::Event* triggered, double value)
}
}
-void NetworkCm02Link::set_latency(double value)
+LinkImpl* NetworkCm02Link::set_latency(double value)
{
+ latency_check(value);
+
double delta = value - latency_.peak;
const kernel::lmm::Variable* var;
const kernel::lmm::Element* elem = nullptr;
const kernel::lmm::Element* nextelem = nullptr;
int numelem = 0;
+ latency_.scale = 1.0;
latency_.peak = value;
while ((var = get_constraint()->get_variable_safe(&elem, &nextelem, &numelem))) {
if (not action->is_suspended())
get_model()->get_maxmin_system()->update_variable_penalty(action->get_variable(), action->sharing_penalty_);
}
+ return this;
}
/**********
public:
NetworkCm02Model();
~NetworkCm02Model() override = default;
- LinkImpl* create_link(const std::string& name, const std::vector<double>& bandwidths, double latency,
+ LinkImpl* create_link(const std::string& name, const std::vector<double>& bandwidths,
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;
class NetworkCm02Link : public LinkImpl {
public:
- NetworkCm02Link(NetworkCm02Model* model, const std::string& name, double bandwidth, double latency,
+ NetworkCm02Link(NetworkCm02Model* model, const std::string& name, double bandwidth,
s4u::Link::SharingPolicy policy, lmm::System* system);
~NetworkCm02Link() override = default;
void apply_event(kernel::profile::Event* event, double value) override;
void set_bandwidth(double value) override;
- void set_latency(double value) override;
+ LinkImpl* set_latency(double value) override;
};
/**********
}
LinkImpl* NetworkConstantModel::create_link(const std::string& name, const std::vector<double>& /*bandwidth*/,
- double /*latency*/, s4u::Link::SharingPolicy)
+ s4u::Link::SharingPolicy)
{
xbt_die("Refusing to create the link %s: there is no link in the Constant network model. "
"Please remove any link from your platform (and switch to routing='None')",
double next_occurring_event(double now) override;
void update_actions_state(double now, double delta) override;
- LinkImpl* create_link(const std::string& name, const std::vector<double>& bws, double lat,
+ LinkImpl* create_link(const std::string& name, const std::vector<double>& bws,
s4u::Link::SharingPolicy policy) override;
};
return get_constraint()->get_sharing_policy();
}
+void LinkImpl::latency_check(double latency)
+{
+ static double last_warned_latency = sg_surf_precision;
+ if (latency != 0.0 && latency < last_warned_latency) {
+ XBT_WARN("Latency for link %s is smaller than surf/precision (%g < %g)."
+ " For more accuracy, consider setting \"--cfg=surf/precision:%g\".",
+ get_cname(), latency, sg_surf_precision, latency);
+ last_warned_latency = latency;
+ }
+}
+
void LinkImpl::turn_on()
{
if (not is_on()) {
}
}
}
-
+void LinkImpl::seal()
+{
+ simgrid::s4u::Link::on_creation(*get_iface());
+}
void LinkImpl::on_bandwidth_change() const
{
s4u::Link::on_bandwidth_change(this->piface_);
*
* @param name The name of the Link
* @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
*/
- virtual LinkImpl* create_link(const std::string& name, const std::vector<double>& bandwidths, double latency,
+ virtual LinkImpl* create_link(const std::string& name, const std::vector<double>& bandwidths,
s4u::Link::SharingPolicy policy) = 0;
/**
public:
void destroy(); // Must be called instead of the destructor
+ void latency_check(double latency);
+
/** @brief Public interface */
const s4u::Link* get_iface() const { return &piface_; }
s4u::Link* get_iface() { return &piface_; }
double get_latency() const;
/** @brief Update the latency in seconds of current Link */
- virtual void set_latency(double value) = 0;
+ virtual LinkImpl* set_latency(double value) = 0;
/** @brief The sharing policy */
virtual s4u::Link::SharingPolicy get_sharing_policy() const;
void turn_on() override;
void turn_off() override;
+ void seal();
+
void on_bandwidth_change() const;
virtual void
void apply_event(profile::Event* event, double value) override;
void set_bandwidth(double) override { THROW_UNIMPLEMENTED; }
- void set_latency(double) override { THROW_UNIMPLEMENTED; }
+ LinkImpl* set_latency(double) override { THROW_UNIMPLEMENTED; }
void set_bandwidth_profile(profile::Profile* profile) override;
void set_latency_profile(profile::Profile* profile) override;
s4u::Link::SharingPolicy get_sharing_policy() const override { return sharing_policy_; }
{
for (auto bandwidth : bandwidths)
bandwidths_.push_back({bandwidth, 1.0, nullptr});
-
- simgrid::s4u::Link::on_creation(*get_iface());
}
void NetworkWifiLink::set_host_rate(const s4u::Host* host, int rate_level)
s4u::Link::SharingPolicy get_sharing_policy() const override;
void apply_event(kernel::profile::Event*, double) override { THROW_UNIMPLEMENTED; }
void set_bandwidth(double) override { THROW_UNIMPLEMENTED; }
- void set_latency(double) override { THROW_UNIMPLEMENTED; }
+ LinkImpl* set_latency(double) override { THROW_UNIMPLEMENTED; }
void refresh_decay_bandwidths();
bool toggle_decay_model();
int get_host_count() const;
set_maxmin_system(sys);
loopback_ = NetworkL07Model::create_link("__loopback__",
std::vector<double>{simgrid::config::get_value<double>("network/loopback-bw")},
- simgrid::config::get_value<double>("network/loopback-lat"),
- s4u::Link::SharingPolicy::FATPIPE);
+ s4u::Link::SharingPolicy::FATPIPE)->set_latency(simgrid::config::get_value<double>("network/loopback-lat"));
+ loopback_->seal();
}
NetworkL07Model::~NetworkL07Model()
}
kernel::resource::LinkImpl* NetworkL07Model::create_link(const std::string& name, const std::vector<double>& bandwidths,
- double latency, s4u::Link::SharingPolicy policy)
+ s4u::Link::SharingPolicy policy)
{
xbt_assert(bandwidths.size() == 1, "Non WIFI link must have only 1 bandwidth.");
- return new LinkL07(this, name, bandwidths[0], latency, policy);
+ return new LinkL07(this, name, bandwidths[0], policy);
}
/************
CpuL07::~CpuL07()=default;
-LinkL07::LinkL07(NetworkL07Model* model, const std::string& name, double bandwidth, double latency,
- s4u::Link::SharingPolicy policy)
+LinkL07::LinkL07(NetworkL07Model* model, const std::string& name, double bandwidth, s4u::Link::SharingPolicy policy)
: LinkImpl(model, name, model->get_maxmin_system()->constraint_new(this, bandwidth))
{
bandwidth_.peak = bandwidth;
- latency_.peak = latency;
if (policy == s4u::Link::SharingPolicy::FATPIPE)
get_constraint()->unshare();
-
- s4u::Link::on_creation(*get_iface());
}
kernel::resource::CpuAction* CpuL07::execution_start(double size)
get_model()->get_maxmin_system()->update_constraint_bound(get_constraint(), bandwidth_.peak * bandwidth_.scale);
}
-void LinkL07::set_latency(double value)
+kernel::resource::LinkImpl* LinkL07::set_latency(double value)
{
+ latency_check(value);
const kernel::lmm::Variable* var;
L07Action *action;
const kernel::lmm::Element* elem = nullptr;
action = static_cast<L07Action*>(var->get_id());
action->updateBound();
}
+ return this;
}
LinkL07::~LinkL07() = default;
NetworkL07Model& operator=(const NetworkL07Model&) = delete;
~NetworkL07Model() override;
kernel::resource::LinkImpl* create_link(const std::string& name, const std::vector<double>& bandwidths,
- double latency, s4u::Link::SharingPolicy 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,
- s4u::Link::SharingPolicy policy);
+ LinkL07(NetworkL07Model* model, const std::string& name, double bandwidth, s4u::Link::SharingPolicy policy);
LinkL07(const LinkL07&) = delete;
LinkL07& operator=(const LinkL07&) = delete;
~LinkL07() override;
bool is_used() const override;
void apply_event(kernel::profile::Event* event, double value) override;
void set_bandwidth(double value) override;
- void set_latency(double value) override;
+ LinkImpl* set_latency(double value) override;
};
/**********
static void sg_platf_new_link(const simgrid::kernel::routing::LinkCreationArgs* args, const std::string& link_name)
{
- simgrid::s4u::Link* link = routing_get_current()->create_link(link_name, args->bandwidths, args->latency, args->policy);
+ simgrid::s4u::Link* link = routing_get_current()->create_link(link_name, args->bandwidths, args->policy);
+ if (args->policy != simgrid::s4u::Link::SharingPolicy::WIFI)
+ link->get_impl()->set_latency(args->latency);
if (args->properties)
link->set_properties(*args->properties);
l->set_bandwidth_profile(args->bandwidth_trace);
if (args->state_trace)
l->set_state_profile(args->state_trace);
+
+ link->seal();
}
void sg_platf_new_link(const simgrid::kernel::routing::LinkCreationArgs* link)