namespace simgrid {
namespace kernel {
namespace resource {
+
NetworkConstantModel::NetworkConstantModel() : NetworkModel(Model::UpdateAlgo::FULL)
{
all_existing_models.push_back(this);
}
-LinkImpl* NetworkConstantModel::create_link(const std::string& name, double, double, s4u::Link::SharingPolicy)
+LinkImpl* NetworkConstantModel::create_link(const std::string& name, double /*bandwidth*/, double /*latency*/,
+ s4u::Link::SharingPolicy)
{
xbt_die("Refusing to create the link %s: there is no link in the Constant network model. "
if ((action.get_remains_no_update() <= 0) ||
((action.get_max_duration() != NO_MAX_DURATION) && (action.get_max_duration() <= 0))) {
- action.finish(kernel::resource::Action::State::FINISHED);
+ action.finish(Action::State::FINISHED);
}
}
}
-kernel::resource::Action* NetworkConstantModel::communicate(s4u::Host* src, s4u::Host* dst, double size, double)
+Action* NetworkConstantModel::communicate(s4u::Host* src, s4u::Host* dst, double size, double)
{
NetworkConstantAction* action = new NetworkConstantAction(this, size, sg_latency_factor);
- simgrid::s4u::Link::on_communicate(*action, src, dst);
+ s4u::Link::on_communicate(*action, src, dst);
return action;
}
{
THROW_IMPOSSIBLE;
}
-}
+
+} // namespace resource
} // namespace kernel
-}
+} // namespace simgrid
class NetworkConstantModel : public NetworkModel {
public:
NetworkConstantModel();
- Action* communicate(simgrid::s4u::Host* src, simgrid::s4u::Host* dst, double size, double rate) override;
+ Action* communicate(s4u::Host* src, s4u::Host* dst, double size, double rate) override;
double next_occuring_event(double now) override;
void update_actions_state(double now, double delta) override;
{
/* Do not add this into all_existing_models: our ancestor already does so */
- std::string IB_factors_string = simgrid::config::get_value<std::string>("smpi/IB-penalty-factors");
+ std::string IB_factors_string = config::get_value<std::string>("smpi/IB-penalty-factors");
std::vector<std::string> radical_elements;
boost::split(radical_elements, IB_factors_string, boost::is_any_of(";"));
updateIBfactors_rec(from, updated);
XBT_DEBUG("IB - Finished updating %d", from->id);
}
-}
-}
+} // namespace resource
+} // namespace kernel
} // namespace simgrid
};
class XBT_PRIVATE NetworkIBModel : public NetworkSmpiModel {
-private:
+ double Bs;
+ double Be;
+ double ys;
void updateIBfactors_rec(IBNode* root, std::vector<bool>& updatedlist);
void computeIBfactors(IBNode* root);
std::unordered_map<std::string, IBNode*> active_nodes;
std::unordered_map<NetworkAction*, std::pair<IBNode*, IBNode*>> active_comms;
- double Bs;
- double Be;
- double ys;
};
-}
+} // namespace resource
} // namespace kernel
} // namespace simgrid
#endif
all_existing_models.push_back(this);
- NetPointNs3::EXTENSION_ID = simgrid::kernel::routing::NetPoint::extension_create<NetPointNs3>();
+ NetPointNs3::EXTENSION_ID = routing::NetPoint::extension_create<NetPointNs3>();
ns3_initialize(ns3_tcp_model.get().c_str());
- simgrid::kernel::routing::NetPoint::on_creation.connect([](simgrid::kernel::routing::NetPoint& pt) {
+ routing::NetPoint::on_creation.connect([](routing::NetPoint& pt) {
pt.extension_set<NetPointNs3>(new NetPointNs3());
XBT_VERB("SimGrid's %s is known as node %d within NS3", pt.get_cname(), pt.extension<NetPointNs3>()->node_num);
});
- simgrid::surf::on_cluster.connect(&clusterCreation_cb);
+ surf::on_cluster.connect(&clusterCreation_cb);
- simgrid::s4u::on_platform_created.connect(&postparse_cb);
- simgrid::s4u::NetZone::on_route_creation.connect(&routeCreation_cb);
+ s4u::on_platform_created.connect(&postparse_cb);
+ s4u::NetZone::on_route_creation.connect(&routeCreation_cb);
}
NetworkNS3Model::~NetworkNS3Model() {
return new LinkNS3(this, name, bandwidth, latency);
}
-kernel::resource::Action* NetworkNS3Model::communicate(s4u::Host* src, s4u::Host* dst, double size, double rate)
+Action* NetworkNS3Model::communicate(s4u::Host* src, s4u::Host* dst, double size, double rate)
{
return new NetworkNS3Action(this, size, src, dst);
}
* Action *
**********/
-NetworkNS3Action::NetworkNS3Action(kernel::resource::Model* model, double totalBytes, s4u::Host* src, s4u::Host* dst)
+NetworkNS3Action::NetworkNS3Action(Model* model, double totalBytes, s4u::Host* src, s4u::Host* dst)
: NetworkAction(model, totalBytes, false), src_(src), dst_(dst)
{
XBT_DEBUG("Communicate from %s to %s", src->get_cname(), dst->get_cname());
}
} // namespace resource
-}
-}
+} // namespace kernel
+} // namespace simgrid
void ns3_simulator(double maxSeconds)
{
~NetworkNS3Model();
LinkImpl* create_link(const std::string& name, double bandwidth, double latency,
s4u::Link::SharingPolicy policy) override;
- kernel::resource::Action* communicate(s4u::Host* src, s4u::Host* dst, double size, double rate) override;
+ 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; }
void update_actions_state(double now, double delta) override;
explicit LinkNS3(NetworkNS3Model* model, const std::string& name, double bandwidth, double latency);
~LinkNS3();
- void apply_event(simgrid::kernel::profile::Event* event, double value) override;
+ void apply_event(profile::Event* event, double value) override;
void set_bandwidth(double value) override { THROW_UNIMPLEMENTED; }
void set_latency(double value) override { THROW_UNIMPLEMENTED; }
void set_bandwidth_profile(profile::Profile* profile) override;
**********/
class XBT_PRIVATE NetworkNS3Action : public NetworkAction {
public:
- NetworkNS3Action(kernel::resource::Model* model, double cost, s4u::Host* src, s4u::Host* dst);
+ NetworkNS3Action(Model* model, double cost, s4u::Host* src, s4u::Host* dst);
void suspend() override;
void resume() override;
};
} // namespace resource
-}
-}
+} // namespace kernel
+} // namespace simgrid
#endif /* NETWORK_NS3_HPP_ */
/* Do not add this into all_existing_models: our ancestor already does so */
}
-NetworkSmpiModel::~NetworkSmpiModel() = default;
-
double NetworkSmpiModel::get_bandwidth_factor(double size)
{
if (smpi_bw_factor.empty())
- smpi_bw_factor = parse_factor(simgrid::config::get_value<std::string>("smpi/bw-factor"));
+ smpi_bw_factor = parse_factor(config::get_value<std::string>("smpi/bw-factor"));
double current = 1.0;
for (auto const& fact : smpi_bw_factor) {
double NetworkSmpiModel::get_latency_factor(double size)
{
if (smpi_lat_factor.empty())
- smpi_lat_factor = parse_factor(simgrid::config::get_value<std::string>("smpi/lat-factor"));
+ smpi_lat_factor = parse_factor(config::get_value<std::string>("smpi/lat-factor"));
double current = 1.0;
for (auto const& fact : smpi_lat_factor) {
{
return rate < 0 ? bound : std::min(bound, rate * get_bandwidth_factor(size));
}
-
-/************
- * Resource *
- ************/
-
-/**********
- * Action *
- **********/
-}
-}
+} // namespace resource
+} // namespace kernel
} // namespace simgrid
class XBT_PRIVATE NetworkSmpiModel : public NetworkCm02Model {
public:
NetworkSmpiModel();
- ~NetworkSmpiModel();
+ ~NetworkSmpiModel() = default;
double get_latency_factor(double size);
double get_bandwidth_factor(double size);