25#include "ns3/applications-module.h"
26#include "ns3/core-module.h"
28#include "ns3/error-model.h"
29#include "ns3/event-id.h"
30#include "ns3/flow-monitor-helper.h"
31#include "ns3/internet-module.h"
32#include "ns3/ipv4-global-routing-helper.h"
33#include "ns3/network-module.h"
34#include "ns3/point-to-point-module.h"
35#include "ns3/tcp-header.h"
36#include "ns3/traffic-control-module.h"
37#include "ns3/udp-header.h"
51static std::map<uint32_t, Ptr<OutputStreamWrapper>>
cWndStream;
52static std::map<uint32_t, Ptr<OutputStreamWrapper>>
54static std::map<uint32_t, Ptr<OutputStreamWrapper>>
rttStream;
55static std::map<uint32_t, Ptr<OutputStreamWrapper>>
rtoStream;
71 const std::size_t n1 = context.find_first_of(
'/', 1);
72 const std::size_t n2 = context.find_first_of(
'/', n1 + 1);
73 return std::stoul(context.substr(n1 + 1, n2 - n1 - 1));
90 *
cWndStream[nodeId]->GetStream() <<
"0.0 " << oldval << std::endl;
117 *
ssThreshStream[nodeId]->GetStream() <<
"0.0 " << oldval << std::endl;
233 "/$ns3::TcpL4Protocol/SocketList/0/CongestionWindow",
249 "/$ns3::TcpL4Protocol/SocketList/0/SlowStartThreshold",
264 Config::Connect(
"/NodeList/" + std::to_string(nodeId) +
"/$ns3::TcpL4Protocol/SocketList/0/RTT",
279 Config::Connect(
"/NodeList/" + std::to_string(nodeId) +
"/$ns3::TcpL4Protocol/SocketList/0/RTO",
295 "/$ns3::TcpL4Protocol/SocketList/0/NextTxSequence",
311 "/$ns3::TcpL4Protocol/SocketList/0/BytesInFlight",
327 "/$ns3::TcpL4Protocol/SocketList/1/RxBuffer/NextRxSequence",
332main(
int argc,
char* argv[])
334 std::string transport_prot =
"TcpWestwoodPlus";
335 double error_p = 0.0;
336 std::string bandwidth =
"2Mbps";
337 std::string delay =
"0.01ms";
338 std::string access_bandwidth =
"10Mbps";
339 std::string access_delay =
"45ms";
341 std::string prefix_file_name =
"TcpVariantsComparison";
342 uint64_t data_mbytes = 0;
344 uint16_t num_flows = 1;
345 double duration = 100.0;
347 bool flow_monitor =
false;
350 std::string queue_disc_type =
"ns3::PfifoFastQueueDisc";
351 std::string recovery =
"ns3::TcpClassicRecovery";
354 cmd.AddValue(
"transport_prot",
355 "Transport protocol to use: TcpNewReno, TcpLinuxReno, "
356 "TcpHybla, TcpHighSpeed, TcpHtcp, TcpVegas, TcpScalable, TcpVeno, "
357 "TcpBic, TcpYeah, TcpIllinois, TcpWestwoodPlus, TcpLedbat, "
358 "TcpLp, TcpDctcp, TcpCubic, TcpBbr",
360 cmd.AddValue(
"error_p",
"Packet error rate", error_p);
361 cmd.AddValue(
"bandwidth",
"Bottleneck bandwidth", bandwidth);
362 cmd.AddValue(
"delay",
"Bottleneck delay", delay);
363 cmd.AddValue(
"access_bandwidth",
"Access link bandwidth", access_bandwidth);
364 cmd.AddValue(
"access_delay",
"Access link delay", access_delay);
365 cmd.AddValue(
"tracing",
"Flag to enable/disable tracing",
tracing);
366 cmd.AddValue(
"prefix_name",
"Prefix of output trace file", prefix_file_name);
367 cmd.AddValue(
"data",
"Number of Megabytes of data to transmit", data_mbytes);
368 cmd.AddValue(
"mtu",
"Size of IP packets to send in bytes", mtu_bytes);
369 cmd.AddValue(
"num_flows",
"Number of flows", num_flows);
370 cmd.AddValue(
"duration",
"Time to allow flows to run in seconds", duration);
371 cmd.AddValue(
"run",
"Run index (for setting repeatable seeds)", run);
372 cmd.AddValue(
"flow_monitor",
"Enable flow monitor", flow_monitor);
373 cmd.AddValue(
"pcap_tracing",
"Enable or disable PCAP tracing", pcap);
374 cmd.AddValue(
"queue_disc_type",
375 "Queue disc type for gateway (e.g. ns3::CoDelQueueDisc)",
377 cmd.AddValue(
"sack",
"Enable or disable SACK option", sack);
378 cmd.AddValue(
"recovery",
"Recovery algorithm type to use (e.g., ns3::TcpPrrRecovery", recovery);
379 cmd.Parse(argc, argv);
381 transport_prot = std::string(
"ns3::") + transport_prot;
400 uint32_t tcp_adu_size = mtu_bytes - 20 - (ip_header + tcp_header);
404 double start_time = 0.1;
405 double stop_time = start_time + duration;
417 "TypeId " << transport_prot <<
" not found");
425 sources.
Create(num_flows);
453 address.SetBase(
"10.0.0.0",
"255.255.255.0");
463 DataRate access_b(access_bandwidth);
465 Time access_d(access_delay);
466 Time bottle_d(delay);
468 uint32_t size =
static_cast<uint32_t>((std::min(access_b, bottle_b).GetBitRate() / 8) *
469 ((access_d + bottle_d) * 2).GetSeconds());
476 for (
uint32_t i = 0; i < num_flows; i++)
485 if (queue_disc_type ==
"ns3::PfifoFastQueueDisc")
489 else if (queue_disc_type ==
"ns3::CoDelQueueDisc")
495 NS_FATAL_ERROR(
"Queue not recognized. Allowed values are ns3::CoDelQueueDisc or "
496 "ns3::PfifoFastQueueDisc");
506 uint16_t
port = 50000;
515 ftp.SetAttribute(
"Remote", remoteAddress);
517 ftp.SetAttribute(
"MaxBytes",
UintegerValue(data_mbytes * 1000000));
534 ascii.open(prefix_file_name +
"-ascii");
536 stack.EnableAsciiIpv4All(ascii_wrap);
538 for (uint16_t index = 0; index < num_flows; index++)
540 std::string flowString;
543 flowString =
"-flow" + std::to_string(index);
553 prefix_file_name + flowString +
"-cwnd.data",
557 prefix_file_name + flowString +
"-ssth.data",
561 prefix_file_name + flowString +
"-rtt.data",
565 prefix_file_name + flowString +
"-rto.data",
569 prefix_file_name + flowString +
"-next-tx.data",
573 prefix_file_name + flowString +
"-inflight.data",
577 prefix_file_name + flowString +
"-next-rx.data",
578 num_flows + index + 1);
a polymophic address class
holds a vector of ns3::Application pointers.
void Start(Time start) const
Start all of the Applications in this container at the start time given as a parameter.
void Stop(Time stop) const
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter.
Manage ASCII trace files for device models.
Ptr< OutputStreamWrapper > CreateFileStream(std::string filename, std::ios::openmode filemode=std::ios::out)
Create and initialize an output stream object we'll use to write the traced bits.
A helper to make it easier to instantiate an ns3::BulkSendApplication on a set of nodes.
Parse command-line arguments.
Class for representing data rates.
Helper to enable IP flow monitoring on a set of Nodes.
Ptr< FlowMonitor > InstallAll()
Enable flow monitoring on all nodes.
void SerializeToXmlFile(std::string fileName, bool enableHistograms, bool enableProbes)
Same as SerializeToXmlStream, but writes to a file instead.
aggregate IP/TCP/UDP functionality to existing Nodes.
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
static Ipv4Address GetAny()
static void PopulateRoutingTables()
Build a routing database and initialize the routing tables of the nodes in the simulation.
holds a vector of std::pair of Ptr<Ipv4> and interface index.
void Add(const Ipv4InterfaceContainer &other)
Concatenate the entries in the other container with ours.
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
holds a vector of ns3::NetDevice pointers
keep track of a set of node pointers.
uint32_t GetN() const
Get the number of Ptr<Node> stored in this container.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
A class encapsulating an output stream.
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes.
void EnablePcapAll(std::string prefix, bool promiscuous=false)
Enable pcap output on each device (which is of the appropriate type) in the set of all nodes created ...
Build a set of PointToPointNetDevice objects.
void SetDeviceAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each NetDevice created by the helper.
void SetChannelAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each Channel created by the helper.
NetDeviceContainer Install(NodeContainer c)
AttributeValue implementation for Pointer.
Smart pointer class similar to boost::intrusive_ptr.
Class for representing queue sizes.
Determine which packets are errored corresponding to an underlying distribution, rate,...
void SetRate(double rate)
void SetUnit(ErrorUnit error_unit)
void SetRandomVariable(Ptr< RandomVariableStream >)
static void SetRun(uint64_t run)
Set the run number of simulation.
static void SetSeed(uint32_t seed)
Set the seed.
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
static Time Now()
Return the current simulation virtual time.
static void Run()
Run the simulation.
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Hold variables of type string.
static TypeId GetTypeId()
Get the type ID.
Simulation virtual time values and global simulation resolution.
double GetSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
Build a set of QueueDisc objects.
QueueDiscContainer Install(NetDeviceContainer c)
uint16_t SetRootQueueDisc(const std::string &type, Args &&... args)
Helper function used to set a root queue disc of the given type and with the given attributes.
a unique identifier for an interface.
static TypeId LookupByName(std::string name)
Get a TypeId by name.
static bool LookupByNameFailSafe(std::string name, TypeId *tid)
Get a TypeId by name.
Hold an unsigned integer type.
void SetDefault(std::string name, const AttributeValue &value)
void Connect(std::string path, const CallbackBase &cb)
#define NS_ABORT_MSG_UNLESS(cond, msg)
Abnormal program termination if a condition is false, with a message.
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Ptr< T > CreateObject(Args &&... args)
Create an object by type, with varying number of constructor parameters.
Time Seconds(double value)
Construct a Time in the indicated unit.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Callback< R, Args... > MakeCallback(R(T::*memPtr)(Args...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
static void RttTracer(std::string context, Time oldval, Time newval)
RTT tracer.
static std::map< uint32_t, bool > firstCwnd
First congestion window.
static std::map< uint32_t, uint32_t > cWndValue
congestion window value.
static void TraceInFlight(std::string &in_flight_file_name, uint32_t nodeId)
In flight trace connection.
static void NextRxTracer(std::string context, SequenceNumber32 old, SequenceNumber32 nextRx)
Next RX tracer.
static std::map< uint32_t, Ptr< OutputStreamWrapper > > nextTxStream
Next TX output stream.
static std::map< uint32_t, Ptr< OutputStreamWrapper > > inFlightStream
In flight output stream.
static std::map< uint32_t, bool > firstSshThr
First SlowStart threshold.
static std::map< uint32_t, bool > firstRto
First RTO.
static std::map< uint32_t, Ptr< OutputStreamWrapper > > nextRxStream
Next RX output stream.
static uint32_t GetNodeIdFromContext(std::string context)
Get the Node Id From Context.
static std::map< uint32_t, Ptr< OutputStreamWrapper > > rtoStream
RTO output stream.
static void InFlightTracer(std::string context, uint32_t old, uint32_t inFlight)
In-flight tracer.
static void NextTxTracer(std::string context, SequenceNumber32 old, SequenceNumber32 nextTx)
Next TX tracer.
static std::map< uint32_t, uint32_t > ssThreshValue
SlowStart threshold value.
static void TraceRtt(std::string rtt_tr_file_name, uint32_t nodeId)
RTT trace connection.
static void TraceSsThresh(std::string ssthresh_tr_file_name, uint32_t nodeId)
Slow start threshold trace connection.
static std::map< uint32_t, bool > firstRtt
First RTT.
static void TraceNextTx(std::string &next_tx_seq_file_name, uint32_t nodeId)
Next TX trace connection.
static void CwndTracer(std::string context, uint32_t oldval, uint32_t newval)
Congestion window tracer.
static void SsThreshTracer(std::string context, uint32_t oldval, uint32_t newval)
Slow start threshold tracer.
static std::map< uint32_t, Ptr< OutputStreamWrapper > > ssThreshStream
SlowStart threshold output stream.
static std::map< uint32_t, Ptr< OutputStreamWrapper > > rttStream
RTT output stream.
static void TraceCwnd(std::string cwnd_tr_file_name, uint32_t nodeId)
Congestion window trace connection.
static void RtoTracer(std::string context, Time oldval, Time newval)
RTO tracer.
static void TraceNextRx(std::string &next_rx_seq_file_name, uint32_t nodeId)
Next RX trace connection.
static std::map< uint32_t, Ptr< OutputStreamWrapper > > cWndStream
Congstion window output stream.
static void TraceRto(std::string rto_tr_file_name, uint32_t nodeId)
RTO trace connection.
bool tracing
Flag to enable/disable generation of tracing files.