/* 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 <string>
#include <unordered_set>
#include "xbt/config.hpp"
+#include "xbt/string.hpp"
+#include "xbt/utility.hpp"
#include "ns3/core-module.h"
#include "ns3/node.h"
#include "src/instr/instr_private.hpp" // TRACE_is_enabled(). FIXME: remove by subscribing tracing to the surf signals
#include "src/kernel/routing/NetPoint.hpp"
+#include "simgrid/plugins/energy.h"
#include "simgrid/s4u/Engine.hpp"
#include "simgrid/s4u/NetZone.hpp"
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(ns3, surf, "Logging specific to the SURF network NS3 module");
-std::vector<char*> IPV4addr;
+std::vector<std::string> IPV4addr;
/*****************
* Crude globals *
NetPointNs3::NetPointNs3()
{
- ns3::Ptr<ns3::Node> node = ns3::CreateObject<ns3::Node>(0);
- stack.Install(node);
- nodes.Add(node);
+ ns3Node_ = ns3::CreateObject<ns3::Node>(0);
+ stack.Install(ns3Node_);
+ nodes.Add(ns3Node_);
node_num = number_of_nodes++;
}
static void routeCreation_cb(bool symmetrical, simgrid::kernel::routing::NetPoint* src,
simgrid::kernel::routing::NetPoint* dst, simgrid::kernel::routing::NetPoint* gw_src,
simgrid::kernel::routing::NetPoint* gw_dst,
- std::vector<simgrid::surf::LinkImpl*>* link_list)
+ std::vector<simgrid::surf::LinkImpl*>& link_list)
{
- if (link_list->size() == 1) {
- simgrid::surf::LinkNS3* link = static_cast<simgrid::surf::LinkNS3*>(link_list->at(0));
+ if (link_list.size() == 1) {
+ simgrid::surf::LinkNS3* link = static_cast<simgrid::surf::LinkNS3*>(link_list[0]);
XBT_DEBUG("Route from '%s' to '%s' with link '%s' %s", src->getCname(), dst->getCname(), link->getCname(),
(symmetrical ? "(symmetrical)" : "(not symmetrical)"));
"of length 1.\n"
"WARNING: Remove long routes to avoid this harmless message; subsequent long routes will be silently "
"ignored.",
- src->getCname(), dst->getCname(), link_list->size());
+ src->getCname(), dst->getCname(), link_list.size());
warned_about_long_routes = true;
}
}
all_existing_models->push_back(surf_network_model);
}
-static simgrid::config::Flag<std::string> ns3_tcp_model("ns3/TcpModel",
- "The ns3 tcp model can be : NewReno or Reno or Tahoe", "NewReno");
+static simgrid::config::Flag<std::string>
+ ns3_tcp_model("ns3/TcpModel", "The ns3 tcp model can be : NewReno or Reno or Tahoe", "default");
namespace simgrid {
namespace surf {
NetworkNS3Model::NetworkNS3Model() : NetworkModel() {
+ xbt_assert(not sg_link_energy_is_inited(),
+ "LinkEnergy plugin and NS3 network models are not compatible. Are you looking for Ecofen, maybe?");
+
NetPointNs3::EXTENSION_ID = simgrid::kernel::routing::NetPoint::extension_create<NetPointNs3>();
ns3_initialize(ns3_tcp_model.get().c_str());
XBT_VERB("SimGrid's %s is known as node %d within NS3", pt->getCname(), pt->extension<NetPointNs3>()->node_num);
});
simgrid::surf::on_cluster.connect(&clusterCreation_cb);
+
simgrid::s4u::onPlatformCreated.connect(&postparse_cb);
simgrid::s4u::NetZone::onRouteCreation.connect(&routeCreation_cb);
-
- LogComponentEnable("PacketSink", ns3::LOG_LEVEL_INFO);
- LogComponentEnable("UdpEchoClientApplication", ns3::LOG_LEVEL_INFO);
- LogComponentEnable("UdpEchoServerApplication", ns3::LOG_LEVEL_INFO);
}
NetworkNS3Model::~NetworkNS3Model() {
- for (auto const& addr : IPV4addr)
- free(addr);
IPV4addr.clear();
}
std::vector<LinkImpl*> route = std::vector<LinkImpl*>();
- action->src_->routeTo(action->dst_, &route, nullptr);
+ action->src_->routeTo(action->dst_, route, nullptr);
for (auto const& link : route)
TRACE_surf_link_set_utilization(link->getCname(), action->getCategory(), (data_delta_sent) / delta, now - delta,
delta);
if(sgFlow->finished_){
socket_to_destroy.push_back(ns3Socket);
- XBT_DEBUG("Destroy socket %p of action %p", ns3Socket, action);
+ XBT_DEBUG("Destroy socket %p of action %p", ns3Socket.c_str(), action);
action->finish(Action::State::done);
+ } else {
+ XBT_DEBUG("Socket %p sent %u bytes out of %u (%u remaining)", ns3Socket.c_str(), sgFlow->sentBytes_,
+ sgFlow->totalBytes_, sgFlow->remaining_);
}
}
socket_to_destroy.pop_back();
SgFlow* flow = flowFromSock.at(ns3Socket);
if (XBT_LOG_ISENABLED(ns3, xbt_log_priority_debug)) {
- XBT_DEBUG ("Removing socket %p of action %p", ns3Socket, flow->action_);
+ XBT_DEBUG("Removing socket %p of action %p", ns3Socket.c_str(), flow->action_);
}
delete flow;
flowFromSock.erase(ns3Socket);
refcount_--;
if (not refcount_) {
if (action_hook.is_linked())
- stateSet_->erase(stateSet_->iterator_to(*this));
+ simgrid::xbt::intrusive_erase(*stateSet_, *this);
XBT_DEBUG ("Removing action %p", this);
delete this;
return 1;
unsigned int node1 = src->pimpl_netpoint->extension<NetPointNs3>()->node_num;
unsigned int node2 = dst->pimpl_netpoint->extension<NetPointNs3>()->node_num;
- ns3::Ptr<ns3::Node> src_node = nodes.Get(node1);
- ns3::Ptr<ns3::Node> dst_node = nodes.Get(node2);
+ ns3::Ptr<ns3::Node> src_node = src->pimpl_netpoint->extension<NetPointNs3>()->ns3Node_;
+ ns3::Ptr<ns3::Node> dst_node = dst->pimpl_netpoint->extension<NetPointNs3>()->ns3Node_;
xbt_assert(node2 < IPV4addr.size(), "Element %s is unknown to NS3. Is it connected to any one-hop link?",
dst->pimpl_netpoint->getCname());
- char* addr = IPV4addr.at(node2);
- xbt_assert(addr != nullptr, "Element %s is unknown to NS3. Is it connected to any one-hop link?",
+ std::string& addr = IPV4addr[node2];
+ xbt_assert(not addr.empty(), "Element %s is unknown to NS3. Is it connected to any one-hop link?",
dst->pimpl_netpoint->getCname());
- XBT_DEBUG("ns3_create_flow %u Bytes from %u to %u with Interface %s", TotalBytes, node1, node2, addr);
+ XBT_DEBUG("ns3_create_flow %u Bytes from %u to %u with Interface %s", TotalBytes, node1, node2, addr.c_str());
ns3::PacketSinkHelper sink("ns3::TcpSocketFactory", ns3::InetSocketAddress (ns3::Ipv4Address::GetAny(), port_number));
sink.Install (dst_node);
sock->Bind(ns3::InetSocketAddress(port_number));
- ns3::Simulator::ScheduleNow(&StartFlow, sock, addr, port_number);
+ ns3::Simulator::ScheduleNow(&StartFlow, sock, addr.c_str(), port_number);
port_number++;
xbt_assert(port_number <= 65000, "Too many connections! Port number is saturated.");
return;
}
- xbt_die("The ns3/TcpModel must be : NewReno or Reno or Tahoe");
+ xbt_die("The ns3/TcpModel must be: NewReno or Reno or Tahoe");
}
void ns3_add_cluster(const char* id, double bw, double lat) {
xbt_assert(Nodes.GetN() <= 65000, "Cluster with NS3 is limited to 65000 nodes");
ns3::CsmaHelper csma;
- csma.SetDeviceAttribute("DataRate", ns3::DataRateValue(ns3::DataRate(bw*8)));// NS3 takes bps, but we provide Bps
+ csma.SetChannelAttribute("DataRate", ns3::DataRateValue(ns3::DataRate(bw * 8))); // NS3 takes bps, but we provide Bps
csma.SetChannelAttribute("Delay", ns3::TimeValue(ns3::Seconds(lat)));
ns3::NetDeviceContainer devices = csma.Install(Nodes);
XBT_DEBUG("Create CSMA");
- char * adr = bprintf("%d.%d.0.0",number_of_networks,number_of_links);
- XBT_DEBUG("Assign IP Addresses %s to CSMA.",adr);
+ std::string addr = simgrid::xbt::string_printf("%d.%d.0.0", number_of_networks, number_of_links);
+ XBT_DEBUG("Assign IP Addresses %s to CSMA.", addr.c_str());
ns3::Ipv4AddressHelper ipv4;
- ipv4.SetBase (adr, "255.255.0.0");
- free(adr);
+ ipv4.SetBase(addr.c_str(), "255.255.0.0");
interfaces.Add(ipv4.Assign (devices));
if(number_of_links == 255){
XBT_DEBUG("Number of nodes in Cluster_nodes: %u", Cluster_nodes.GetN());
}
-static char* transformIpv4Address (ns3::Ipv4Address from){
+static std::string transformIpv4Address(ns3::Ipv4Address from)
+{
std::stringstream sstream;
sstream << from ;
- std::string s = sstream.str();
- return bprintf("%s",s.c_str());
+ return sstream.str();
}
void ns3_add_link(NetPointNs3* src, NetPointNs3* dst, double bw, double lat) {
int srcNum = src->node_num;
int dstNum = dst->node_num;
- ns3::Ptr<ns3::Node> a = nodes.Get(srcNum);
- ns3::Ptr<ns3::Node> b = nodes.Get(dstNum);
+ ns3::Ptr<ns3::Node> a = src->ns3Node_;
+ ns3::Ptr<ns3::Node> b = dst->ns3Node_;
XBT_DEBUG("\tAdd PTP from %d to %d bw:'%f Bps' lat:'%fs'", srcNum, dstNum, bw, lat);
- pointToPoint.SetDeviceAttribute("DataRate", ns3::DataRateValue(ns3::DataRate(bw*8)));// NS3 takes bps, but we provide Bps
+ pointToPoint.SetDeviceAttribute("DataRate",
+ ns3::DataRateValue(ns3::DataRate(bw * 8))); // NS3 takes bps, but we provide Bps
pointToPoint.SetChannelAttribute("Delay", ns3::TimeValue(ns3::Seconds(lat)));
- char *filename = bprintf("link-%d-%d.tr", srcNum, dstNum);
- ns3::AsciiTraceHelper ascii;
- pointToPoint.EnableAsciiAll (ascii.CreateFileStream (filename));
- pointToPoint.EnablePcapAll ("tcp-bulk-send", false);
- xbt_free(filename);
-
ns3::NetDeviceContainer netA;
netA.Add(pointToPoint.Install (a, b));
- char * adr = bprintf("%d.%d.0.0",number_of_networks,number_of_links);
- address.SetBase (adr, "255.255.0.0");
- XBT_DEBUG("\tInterface stack '%s'",adr);
- free(adr);
+ std::string addr = simgrid::xbt::string_printf("%d.%d.0.0", number_of_networks, number_of_links);
+ address.SetBase(addr.c_str(), "255.255.0.0");
+ XBT_DEBUG("\tInterface stack '%s'", addr.c_str());
interfaces.Add(address.Assign (netA));
if (IPV4addr.size() <= (unsigned)srcNum)
- IPV4addr.resize(srcNum + 1, nullptr);
- IPV4addr.at(srcNum) = transformIpv4Address(interfaces.GetAddress(interfaces.GetN() - 2));
+ IPV4addr.resize(srcNum + 1);
+ IPV4addr[srcNum] = transformIpv4Address(interfaces.GetAddress(interfaces.GetN() - 2));
if (IPV4addr.size() <= (unsigned)dstNum)
- IPV4addr.resize(dstNum + 1, nullptr);
- IPV4addr.at(dstNum) = transformIpv4Address(interfaces.GetAddress(interfaces.GetN() - 1));
+ IPV4addr.resize(dstNum + 1);
+ IPV4addr[dstNum] = transformIpv4Address(interfaces.GetAddress(interfaces.GetN() - 1));
if (number_of_links == 255){
xbt_assert(number_of_networks < 255, "Number of links and networks exceed 255*255");
