/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
+#include "simgrid/plugins/ns3.hpp"
+
#include <string>
#include <unordered_set>
#include "src/instr/instr_private.hpp" // TRACE_is_enabled(). FIXME: remove by subscribing tracing to the surf signals
#include "src/kernel/EngineImpl.hpp"
#include "src/surf/surf_interface.hpp"
-#include "src/surf/xml/platf_private.hpp"
-#include "surf/surf.hpp"
+#include "src/surf/xml/platf_private.hpp" // ClusterCreationArgs
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(res_ns3, res_network, "Network model based on ns-3");
wifiPhy.Set("Antennas", ns3::UintegerValue(nss_value));
wifiPhy.Set("MaxSupportedTxSpatialStreams", ns3::UintegerValue(nss_value));
wifiPhy.Set("MaxSupportedRxSpatialStreams", ns3::UintegerValue(nss_value));
+#if NS3_MINOR_VERSION > 33
+ wifiPhy.Set("ChannelWidth", ns3::UintegerValue(40));
+#endif
wifiMac.SetType("ns3::ApWifiMac", "Ssid", ns3::SsidValue(ssid));
mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
ns3::Simulator::Schedule(ns3::Seconds(start_time_value), &resumeWifiDevice, device);
}
+#if NS3_MINOR_VERSION < 33
+ // This fails with "The channel width does not uniquely identify an operating channel" on v3.34,
+ // so we specified the ChannelWidth of wifiPhy to 40, above, when creating wifiPhy with v3.34 and higher
ns3::Config::Set("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/ChannelWidth", ns3::UintegerValue(40));
+#endif
mobility.SetPositionAllocator(positionAllocS);
mobility.Install(nodes);
simgrid::kernel::routing::NetPoint* /*gw_dst*/,
std::vector<simgrid::kernel::resource::LinkImpl*> const& link_list)
{
- xbt_assert(src && dst, "NS-3: add_route, invalid src or destination");
+ /* ignoring routes from StarZone, not supported */
+ if (not src || not dst)
+ return;
+
if (link_list.size() == 1) {
auto const* link = static_cast<simgrid::kernel::resource::LinkNS3*>(link_list[0]);
void surf_network_model_init_NS3()
{
auto net_model = std::make_shared<simgrid::kernel::resource::NetworkNS3Model>("NS3 network model");
- simgrid::kernel::EngineImpl::get_instance()->add_model(net_model);
- simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_network_model(net_model);
+ auto* engine = simgrid::kernel::EngineImpl::get_instance();
+ engine->add_model(net_model);
+ engine->get_netzone_root()->set_network_model(net_model);
}
static simgrid::config::Flag<std::string>
ns3::GlobalRouteManager::InitializeRoutes();
});
routing::on_cluster_creation.connect(&clusterCreation_cb);
- s4u::NetZone::on_route_creation.connect(&routeCreation_cb);
+ routing::NetZoneImpl::on_route_creation.connect(&routeCreation_cb);
s4u::NetZone::on_seal.connect(&zoneCreation_cb);
}
LinkImpl* NetworkNS3Model::create_link(const std::string& name, const std::vector<double>& bandwidths)
{
xbt_assert(bandwidths.size() == 1, "ns-3 links must use only 1 bandwidth.");
- return (new LinkNS3(name, bandwidths[0]))->set_model(this);
+ auto* link = new LinkNS3(name, bandwidths[0]);
+ link->set_model(this);
+ return link;
}
LinkImpl* NetworkNS3Model::create_wifi_link(const std::string& name, const std::vector<double>& bandwidths)
{
- return create_link(name, bandwidths)->set_sharing_policy(s4u::Link::SharingPolicy::WIFI);
+ auto* link = create_link(name, bandwidths);
+ link->set_sharing_policy(s4u::Link::SharingPolicy::WIFI, {});
+ return link;
}
Action* NetworkNS3Model::communicate(s4u::Host* src, s4u::Host* dst, double size, double rate)
XBT_DEBUG("doing a ns3 simulation for a duration of %f", now);
ns3_simulator(now);
- time_to_next_flow_completion = ns3::Simulator::Now().GetSeconds() - surf_get_clock();
+ time_to_next_flow_completion = ns3::Simulator::Now().GetSeconds() - EngineImpl::get_clock();
// NS-3 stops as soon as a flow ends,
// but it does not process the other flows that may finish at the same (simulated) time.
// If another flow ends at the same time, time_to_next_flow_completion = 0
XBT_DEBUG("min : %f", now);
XBT_DEBUG("ns3 time : %f", ns3::Simulator::Now().GetSeconds());
- XBT_DEBUG("surf time : %f", surf_get_clock());
+ XBT_DEBUG("surf time : %f", EngineImpl::get_clock());
XBT_DEBUG("Next completion %f :", time_to_next_flow_completion);
return time_to_next_flow_completion;
THROW_UNIMPLEMENTED;
}
-LinkImpl* LinkNS3::set_bandwidth_profile(profile::Profile* profile)
+void LinkNS3::set_bandwidth_profile(profile::Profile* profile)
{
xbt_assert(profile == nullptr, "The ns-3 network model doesn't support bandwidth profiles");
- return this;
}
-LinkImpl* LinkNS3::set_latency_profile(profile::Profile* profile)
+void LinkNS3::set_latency_profile(profile::Profile* profile)
{
xbt_assert(profile == nullptr, "The ns-3 network model doesn't support latency profiles");
- return this;
}
-LinkImpl* LinkNS3::set_latency(double latency)
+void LinkNS3::set_latency(double latency)
{
latency_.peak = latency;
- return this;
}
-LinkImpl* LinkNS3::set_sharing_policy(s4u::Link::SharingPolicy policy)
+void LinkNS3::set_sharing_policy(s4u::Link::SharingPolicy policy, const s4u::NonLinearResourceCb& cb)
{
sharing_policy_ = policy;
- return this;
}
/**********
* Action *
// If there is no other started actions, we need to move NS-3 forward to be sync with SimGrid
if (model->get_started_action_set()->size() == 1) {
- while (double_positive(surf_get_clock() - ns3::Simulator::Now().GetSeconds(), sg_surf_precision)) {
+ while (double_positive(EngineImpl::get_clock() - ns3::Simulator::Now().GetSeconds(), sg_surf_precision)) {
XBT_DEBUG("Synchronizing NS-3 (time %f) with SimGrid (time %f)", ns3::Simulator::Now().GetSeconds(),
- surf_get_clock());
- ns3_simulator(surf_get_clock() - ns3::Simulator::Now().GetSeconds());
+ EngineImpl::get_clock());
+ ns3_simulator(EngineImpl::get_clock() - ns3::Simulator::Now().GetSeconds());
}
}
static uint16_t port_number = 1;
- ns3::Ptr<ns3::Node> src_node = src->get_netpoint()->extension<NetPointNs3>()->ns3_node_;
- ns3::Ptr<ns3::Node> dst_node = dst->get_netpoint()->extension<NetPointNs3>()->ns3_node_;
+ ns3::Ptr<ns3::Node> src_node = get_ns3node_from_sghost(src);
+ ns3::Ptr<ns3::Node> dst_node = get_ns3node_from_sghost(dst);
std::string& addr = dst->get_netpoint()->extension<NetPointNs3>()->ipv4_address_;
xbt_assert(not addr.empty(), "Element %s is unknown to ns-3. Is it connected to any one-hop link?",
port_number = 1 + (port_number % UINT16_MAX);
if (port_number == 1)
XBT_WARN("Too many connections! Port number is saturated. Trying to use the oldest ports.");
-
- s4u::Link::on_communicate(*this);
}
void NetworkNS3Action::suspend()
} // namespace resource
} // namespace kernel
+
+ns3::Ptr<ns3::Node> get_ns3node_from_sghost(simgrid::s4u::Host* host)
+{
+ xbt_assert(host->get_netpoint()->extension<NetPointNs3>() != nullptr, "Please only use this function on ns-3 nodes");
+ return host->get_netpoint()->extension<NetPointNs3>()->ns3_node_;
+}
} // namespace simgrid
void ns3_simulator(double maxSeconds)
if (maxSeconds > 0.0) // If there is a maximum amount of time to run
id = ns3::Simulator::Schedule(ns3::Seconds(maxSeconds), &ns3::Simulator::Stop);
- XBT_DEBUG("Start simulator for at most %fs (current time: %f)", maxSeconds, surf_get_clock());
+ XBT_DEBUG("Start simulator for at most %fs (current time: %f)", maxSeconds, simgrid::kernel::EngineImpl::get_clock());
ns3::Simulator::Run();
XBT_DEBUG("Simulator stopped at %fs", ns3::Simulator::Now().GetSeconds());
