TypeId WimaxPhy::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::WimaxPhy").SetParent<Object> ()
.AddAttribute ("Channel",
"Wimax channel",
PointerValue (),
MakePointerAccessor (&WimaxPhy::GetChannel, &WimaxPhy::Attach),
MakePointerChecker<WimaxChannel> ())
.AddAttribute ("FrameDuration",
"The frame duration in seconds.",
TimeValue (Seconds (0.01)),
MakeTimeAccessor (&WimaxPhy::SetFrameDuration, &WimaxPhy::GetFrameDurationSec),
MakeTimeChecker ())
.AddAttribute ("Frequency",
"The central frequency in KHz.",
UintegerValue (5000000),
MakeUintegerAccessor (&WimaxPhy::SetFrequency, &WimaxPhy::GetFrequency),
MakeUintegerChecker<uint32_t> (1000000, 11000000))
.AddAttribute ("Bandwidth",
"The channel bandwidth in Hz.",
UintegerValue (10000000),
MakeUintegerAccessor (&WimaxPhy::SetChannelBandwidth, &WimaxPhy::GetChannelBandwidth),
MakeUintegerChecker<uint32_t> (5000000, 30000000))
;
return tid;
}
TypeId Ping6::GetTypeId ()
{
static TypeId tid = TypeId ("ns3::Ping6")
.SetParent<Application>()
.AddConstructor<Ping6>()
.AddAttribute ("MaxPackets",
"The maximum number of packets the application will send",
UintegerValue (100),
MakeUintegerAccessor (&Ping6::m_count),
MakeUintegerChecker<uint32_t>())
.AddAttribute ("Interval",
"The time to wait between packets",
TimeValue (Seconds (1.0)),
MakeTimeAccessor (&Ping6::m_interval),
MakeTimeChecker ())
.AddAttribute ("RemoteIpv6",
"The Ipv6Address of the outbound packets",
Ipv6AddressValue (),
MakeIpv6AddressAccessor (&Ping6::m_peerAddress),
MakeIpv6AddressChecker ())
.AddAttribute ("LocalIpv6",
"Local Ipv6Address of the sender",
Ipv6AddressValue (),
MakeIpv6AddressAccessor (&Ping6::m_localAddress),
MakeIpv6AddressChecker ())
.AddAttribute ("PacketSize",
"Size of packets generated",
UintegerValue (100),
MakeUintegerAccessor (&Ping6::m_size),
MakeUintegerChecker<uint32_t>())
;
return tid;
}
int
main(int argc, char* argv[])
{
// setting default parameters for PointToPoint links and channels
Config::SetDefault("ns3::PointToPointNetDevice::DataRate", StringValue("1Mbps"));
Config::SetDefault("ns3::PointToPointChannel::Delay", StringValue("10ms"));
Config::SetDefault("ns3::DropTailQueue::MaxPackets", StringValue("20"));
// Read optional command-line parameters (e.g., enable visualizer with ./waf --run=<> --visualize
CommandLine cmd;
cmd.Parse(argc, argv);
// Creating nodes
NodeContainer nodes;
nodes.Create(3);
// Connecting nodes using two links
PointToPointHelper p2p;
p2p.Install(nodes.Get(0), nodes.Get(1));
p2p.Install(nodes.Get(1), nodes.Get(2));
// Install NDN stack on all nodes
ndn::StackHelper ndnHelper;
ndnHelper.SetDefaultRoutes(true);
ndnHelper.SetOldContentStore(
"ns3::ndn::cs::Freshness::Lru"); // don't set up max size here, will use default value = 100
ndnHelper.InstallAll();
// set up max sizes, after NDN stack is installed
Config::Set("/NodeList/0/$ns3::ndn::ContentStore/MaxSize",
UintegerValue(
1)); // number after nodeList is global ID of the node (= node->GetId ())
Config::Set("/NodeList/1/$ns3::ndn::ContentStore/MaxSize", UintegerValue(2));
Config::Set("/NodeList/2/$ns3::ndn::ContentStore/MaxSize", UintegerValue(200));
// Installing applications
// Consumer
ndn::AppHelper consumerHelper("ns3::ndn::ConsumerCbr");
// Consumer will request /prefix/0, /prefix/1, ...
consumerHelper.SetPrefix("/prefix");
consumerHelper.SetAttribute("Frequency", StringValue("10")); // 10 interests a second
consumerHelper.Install(nodes.Get(0)); // first node
// Producer
ndn::AppHelper producerHelper("ns3::ndn::Producer");
// Producer will reply to all requests starting with /prefix
producerHelper.SetPrefix("/prefix");
producerHelper.SetAttribute("PayloadSize", StringValue("1024"));
producerHelper.Install(nodes.Get(2)); // last node
Simulator::Stop(Seconds(20.0));
Simulator::Run();
Simulator::Destroy();
return 0;
}
int
main(int argc, char* argv[])
{
// setting default parameters for PointToPoint links and channels
Config::SetDefault("ns3::PointToPointNetDevice::DataRate", StringValue("1Mbps"));
Config::SetDefault("ns3::PointToPointChannel::Delay", StringValue("10ms"));
Config::SetDefault("ns3::QueueBase::MaxPackets", UintegerValue(20));
// Read optional command-line parameters (e.g., enable visualizer with ./waf --run=<> --visualize
CommandLine cmd;
cmd.Parse(argc, argv);
// Creating nodes
NodeContainer nodes;
nodes.Create(3);
// Connecting nodes using two links
PointToPointHelper p2p;
p2p.Install(nodes.Get(0), nodes.Get(1));
p2p.Install(nodes.Get(1), nodes.Get(2));
// Install NDN stack on all nodes
ndn::StackHelper ndnHelper;
ndnHelper.SetDefaultRoutes(true);
ndnHelper.InstallAll();
// Installing applications
// Consumer
ndn::AppHelper consumerHelper("ns3::ndn::ConsumerCbr");
// Consumer will request /prefix/0, /prefix/1, ...
consumerHelper.SetPrefix("/prefix");
consumerHelper.SetAttribute("Frequency", StringValue("10")); // 10 interests a second
consumerHelper.Install(nodes.Get(0)); // first node
// Producer
ndn::AppHelper producerHelper("ns3::ndn::Producer");
// Producer will reply to all requests starting with /prefix
producerHelper.SetPrefix("/prefix");
producerHelper.SetAttribute("PayloadSize", StringValue("1024"));
producerHelper.SetAttribute("Signature", UintegerValue(100));
producerHelper.SetAttribute("KeyLocator", StringValue("/unique/key/locator"));
producerHelper.Install(nodes.Get(2)); // last node
PcapWriter trace("ndn-simple-trace.pcap");
Config::ConnectWithoutContext("/NodeList/*/DeviceList/*/$ns3::PointToPointNetDevice/MacTx",
MakeCallback(&PcapWriter::TracePacket, &trace));
Simulator::Stop(Seconds(20.0));
Simulator::Run();
Simulator::Destroy();
return 0;
}
void
HwmpReactiveRegressionTest::InstallApplications ()
{
UdpEchoServerHelper echoServer (9);
ApplicationContainer serverApps = echoServer.Install (m_nodes->Get (0));
serverApps.Start (Seconds (0.0));
serverApps.Stop (m_time);
UdpEchoClientHelper echoClient (m_interfaces.GetAddress (0), 9);
echoClient.SetAttribute ("MaxPackets", UintegerValue (300));
echoClient.SetAttribute ("Interval", TimeValue (Seconds (0.5)));
echoClient.SetAttribute ("PacketSize", UintegerValue (20));
ApplicationContainer clientApps = echoClient.Install (m_nodes->Get (5));
clientApps.Start (Seconds (2.0));
clientApps.Stop (m_time);
}
int
main(int argc, char* argv[])
{
// Setting default parameters for PointToPoint links and channels
Config::SetDefault("ns3::PointToPointNetDevice::DataRate", StringValue("1Mbps"));
Config::SetDefault("ns3::PointToPointChannel::Delay", StringValue("10ms"));
Config::SetDefault("ns3::QueueBase::MaxPackets", UintegerValue(10));
// Read optional command-line parameters (e.g., enable visualizer with ./waf --run=<> --visualize
CommandLine cmd;
cmd.Parse(argc, argv);
// Creating 3x3 topology
PointToPointHelper p2p;
PointToPointGridHelper grid(3, 3, p2p);
grid.BoundingBox(100, 100, 200, 200);
// Install NDN stack on all nodes
ndn::StackHelper ndnHelper;
ndnHelper.InstallAll();
// Set BestRoute strategy
ndn::StrategyChoiceHelper::InstallAll("/", "/localhost/nfd/strategy/best-route");
// Installing global routing interface on all nodes
ndn::GlobalRoutingHelper ndnGlobalRoutingHelper;
ndnGlobalRoutingHelper.InstallAll();
// Getting containers for the consumer/producer
Ptr<Node> producer = grid.GetNode(2, 2);
NodeContainer consumerNodes;
consumerNodes.Add(grid.GetNode(0, 0));
// Install NDN applications
std::string prefix = "/prefix";
ndn::AppHelper consumerHelper("ns3::ndn::ConsumerCbr");
consumerHelper.SetPrefix(prefix);
consumerHelper.SetAttribute("Frequency", StringValue("100")); // 100 interests a second
consumerHelper.Install(consumerNodes);
ndn::AppHelper producerHelper("ns3::ndn::Producer");
producerHelper.SetPrefix(prefix);
producerHelper.SetAttribute("PayloadSize", StringValue("1024"));
producerHelper.Install(producer);
// Add /prefix origins to ndn::GlobalRouter
ndnGlobalRoutingHelper.AddOrigins(prefix, producer);
// Calculate and install FIBs
ndn::GlobalRoutingHelper::CalculateRoutes();
Simulator::Stop(Seconds(20.0));
Simulator::Run();
Simulator::Destroy();
return 0;
}
void
OnOffHelper::SetConstantRate (DataRate dataRate, uint32_t packetSize)
{
m_factory.Set ("OnTime", StringValue ("ns3::ConstantRandomVariable[Constant=1000]"));
m_factory.Set ("OffTime", StringValue ("ns3::ConstantRandomVariable[Constant=0]"));
m_factory.Set ("DataRate", DataRateValue (dataRate));
m_factory.Set ("PacketSize", UintegerValue (packetSize));
}
TypeId
A2A4RsrqHandoverAlgorithm::GetTypeId ()
{
static TypeId tid = TypeId ("ns3::A2A4RsrqHandoverAlgorithm")
.SetParent<LteHandoverAlgorithm> ()
.AddConstructor<A2A4RsrqHandoverAlgorithm> ()
.AddAttribute ("ServingCellThreshold",
"If the RSRQ of the serving cell is worse than this threshold, "
"neighbour cells are consider for handover",
UintegerValue (30),
MakeUintegerAccessor (&A2A4RsrqHandoverAlgorithm::m_servingCellThreshold),
MakeUintegerChecker<uint8_t> (0, 34)) // RSRQ range is [0..34] as per Section 9.1.7 of 3GPP TS 36.133
.AddAttribute ("NeighbourCellOffset",
"Minimum offset between serving and best neighbour cell to trigger the Handover",
UintegerValue (1),
MakeUintegerAccessor (&A2A4RsrqHandoverAlgorithm::m_neighbourCellOffset),
MakeUintegerChecker<uint8_t> ())
;
return tid;
}
TypeId NdiscCache::GetTypeId ()
{
static TypeId tid = TypeId ("ns3::NdiscCache")
.SetParent<Object> ()
.AddAttribute ("UnresolvedQueueSize",
"Size of the queue for packets pending an NA reply.",
UintegerValue (DEFAULT_UNRES_QLEN),
MakeUintegerAccessor (&NdiscCache::m_unresQlen),
MakeUintegerChecker<uint32_t> ())
;
return tid;
}
TypeId
IpL4Protocol::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::IpL4Protocol")
.SetParent<Object> ()
.AddAttribute ("ProtocolNumber", "The Ip protocol number.",
UintegerValue (0),
MakeUintegerAccessor (&IpL4Protocol::GetProtocolNumber),
MakeUintegerChecker<int> ())
;
return tid;
}
TypeId
Channel::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::Channel")
.SetParent<Object> ()
.AddAttribute ("Id", "The id (unique integer) of this Channel.",
TypeId::ATTR_GET,
UintegerValue (0),
MakeUintegerAccessor (&Channel::m_id),
MakeUintegerChecker<uint32_t> ());
return tid;
}
int
main(int argc, char* argv[])
{
// setting default parameters for PointToPoint links and channels
Config::SetDefault("ns3::PointToPointNetDevice::DataRate", StringValue("1Mbps"));
Config::SetDefault("ns3::PointToPointChannel::Delay", StringValue("10ms"));
Config::SetDefault("ns3::QueueBase::MaxPackets", UintegerValue(20));
// Read optional command-line parameters (e.g., enable visualizer with ./waf --run=<> --visualize
CommandLine cmd;
cmd.Parse(argc, argv);
// Creating nodes
NodeContainer nodes;
nodes.Create(3);
// Connecting nodes using two links
PointToPointHelper p2p;
p2p.Install(nodes.Get(0), nodes.Get(1));
p2p.Install(nodes.Get(1), nodes.Get(2));
// Install NDN stack on all nodes
ndn::StackHelper ndnHelper;
ndnHelper.SetDefaultRoutes(true);
ndnHelper.InstallAll();
// Choosing forwarding strategy
ndn::StrategyChoiceHelper::InstallAll("/prefix", "/localhost/nfd/strategy/multicast");
// Installing applications
// Consumer
ndn::AppHelper consumerHelper("ns3::ndn::ConsumerCbr");
// Consumer will request /prefix/0, /prefix/1, ...
consumerHelper.SetPrefix("/prefix");
consumerHelper.SetAttribute("Frequency", StringValue("10")); // 10 interests a second
consumerHelper.Install(nodes.Get(0)); // first node
// Producer
ndn::AppHelper producerHelper("ns3::ndn::Producer");
// Producer will reply to all requests starting with /prefix
producerHelper.SetPrefix("/prefix");
producerHelper.SetAttribute("PayloadSize", StringValue("1024"));
producerHelper.Install(nodes.Get(2)); // last node
Simulator::Stop(Seconds(20.0));
Simulator::Run();
Simulator::Destroy();
return 0;
}
TypeId
LteAnr::GetTypeId ()
{
static TypeId tid = TypeId ("ns3::LteAnr")
.SetParent<Object> ()
.AddAttribute ("Threshold",
"Minimum RSRQ range value required for detecting a neighbour cell",
UintegerValue (0),
MakeUintegerAccessor (&LteAnr::m_threshold),
MakeUintegerChecker<uint8_t> (0, 34)) // RSRQ range is [0..34] as per Section 9.1.7 of 3GPP TS 36.133
;
return tid;
}
void Ping6::StartApplication ()
{
NS_LOG_FUNCTION_NOARGS ();
if (!m_socket)
{
TypeId tid = TypeId::LookupByName ("ns3::Ipv6RawSocketFactory");
m_socket = Socket::CreateSocket (GetNode (), tid);
NS_ASSERT (m_socket);
m_socket->Bind (Inet6SocketAddress (m_localAddress, 0));
m_socket->Connect (Inet6SocketAddress (m_peerAddress, 0));
m_socket->SetAttribute ("Protocol", UintegerValue (Ipv6Header::IPV6_ICMPV6));
m_socket->SetRecvCallback (MakeCallback (&Ping6::HandleRead, this));
}
ScheduleTransmit (Seconds (0.));
}
TypeId
TcpNewReno::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::TcpNewReno")
.SetParent<TcpSocketBase> ()
.AddConstructor<TcpNewReno> ()
.AddAttribute ("ReTxThreshold", "Threshold for fast retransmit",
UintegerValue (3),
MakeUintegerAccessor (&TcpNewReno::m_retxThresh),
MakeUintegerChecker<uint32_t> ())
.AddAttribute ("LimitedTransmit", "Enable limited transmit",
BooleanValue (false),
MakeBooleanAccessor (&TcpNewReno::m_limitedTx),
MakeBooleanChecker ())
.AddTraceSource ("CongestionWindow",
"The TCP connection's congestion window",
MakeTraceSourceAccessor (&TcpNewReno::m_cWnd))
;
return tid;
}
TypeId
WimaxMacQueue::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::WimaxMacQueue")
.SetParent<Object> ()
.AddAttribute (
"MaxSize",
"Maximum size",
UintegerValue (1024),
MakeUintegerAccessor (&WimaxMacQueue::GetMaxSize,
&WimaxMacQueue::SetMaxSize),
MakeUintegerChecker<uint32_t> ())
.AddTraceSource ("Enqueue",
"Enqueue trace",
MakeTraceSourceAccessor (&WimaxMacQueue::m_traceEnqueue))
.AddTraceSource ("Dequeue",
"Dequeue trace",
MakeTraceSourceAccessor (&WimaxMacQueue::m_traceDequeue))
.AddTraceSource ("Drop",
"Drop trace",
MakeTraceSourceAccessor (&WimaxMacQueue::m_traceDrop))
;
return tid;
}
TypeId
FdNetDevice::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::FdNetDevice")
.SetParent<NetDevice> ()
.AddConstructor<FdNetDevice> ()
.AddAttribute ("Address",
"The MAC address of this device.",
Mac48AddressValue (Mac48Address ("ff:ff:ff:ff:ff:ff")),
MakeMac48AddressAccessor (&FdNetDevice::m_address),
MakeMac48AddressChecker ())
.AddAttribute ("Start",
"The simulation time at which to spin up the device thread.",
TimeValue (Seconds (0.)),
MakeTimeAccessor (&FdNetDevice::m_tStart),
MakeTimeChecker ())
.AddAttribute ("Stop",
"The simulation time at which to tear down the device thread.",
TimeValue (Seconds (0.)),
MakeTimeAccessor (&FdNetDevice::m_tStop),
MakeTimeChecker ())
.AddAttribute ("EncapsulationMode",
"The link-layer encapsulation type to use.",
EnumValue (DIX),
MakeEnumAccessor (&FdNetDevice::m_encapMode),
MakeEnumChecker (DIX, "Dix",
LLC, "Llc",
DIXPI, "DixPi"))
.AddAttribute ("RxQueueSize", "Maximum size of the read queue. "
"This value limits number of packets that have been read "
"from the network into a memory buffer but have not yet "
"been processed by the simulator.",
UintegerValue (1000),
MakeUintegerAccessor (&FdNetDevice::m_maxPendingReads),
MakeUintegerChecker<uint32_t> ())
//
// Trace sources at the "top" of the net device, where packets transition
// to/from higher layers. These points do not really correspond to the
// MAC layer of the underlying operating system, but exist to provide
// a consitent tracing environment. These trace hooks should really be
// interpreted as the points at which a packet leaves the ns-3 environment
// destined for the underlying operating system or vice-versa.
//
.AddTraceSource ("MacTx",
"Trace source indicating a packet has arrived for transmission by this device",
MakeTraceSourceAccessor (&FdNetDevice::m_macTxTrace))
.AddTraceSource ("MacTxDrop",
"Trace source indicating a packet has been dropped by the device before transmission",
MakeTraceSourceAccessor (&FdNetDevice::m_macTxDropTrace))
.AddTraceSource ("MacPromiscRx",
"A packet has been received by this device, has been passed up from the physical layer "
"and is being forwarded up the local protocol stack. This is a promiscuous trace,",
MakeTraceSourceAccessor (&FdNetDevice::m_macPromiscRxTrace))
.AddTraceSource ("MacRx",
"A packet has been received by this device, has been passed up from the physical layer "
"and is being forwarded up the local protocol stack. This is a non-promiscuous trace,",
MakeTraceSourceAccessor (&FdNetDevice::m_macRxTrace))
//
// Trace sources designed to simulate a packet sniffer facility (tcpdump).
//
.AddTraceSource ("Sniffer",
"Trace source simulating a non-promiscuous packet sniffer attached to the device",
MakeTraceSourceAccessor (&FdNetDevice::m_snifferTrace))
.AddTraceSource ("PromiscSniffer",
"Trace source simulating a promiscuous packet sniffer attached to the device",
MakeTraceSourceAccessor (&FdNetDevice::m_promiscSnifferTrace))
;
return tid;
}
int
main(int argc, char* argv[])
{
// setting default parameters for PointToPoint links and channels
Config::SetDefault("ns3::PointToPointNetDevice::DataRate", StringValue("10Mbps"));
Config::SetDefault("ns3::PointToPointChannel::Delay", StringValue("10ms"));
Config::SetDefault("ns3::DropTailQueue::MaxPackets", StringValue("20"));
// Read optional command-line parameters (e.g., enable visualizer with ./waf --run=<> --visualize
CommandLine cmd;
cmd.Parse(argc, argv);
// Creating nodes
NodeContainer nodes;
nodes.Create(3); // 3 nodes, connected: 0 <---> 1 <---> 2
// Connecting nodes using two links
PointToPointHelper p2p;
p2p.Install(nodes.Get(0), nodes.Get(1));
p2p.Install(nodes.Get(1), nodes.Get(2));
// Install NDN stack on all nodes
ndn::StackHelper ndnHelper;
ndnHelper.SetDefaultRoutes(true);
ndnHelper.setCsSize(0);
ndnHelper.SetOldContentStore("ns3::ndn::cs::Lru", "MaxSize", "100");
ndnHelper.InstallAll();
// Choosing forwarding strategy
ndn::StrategyChoiceHelper::InstallAll("/myprefix", "/localhost/nfd/strategy/best-route");
ns3::ndn::AppHelper consumerHelper("ns3::ndn::FileConsumerCbr::MultimediaConsumer");
consumerHelper.SetAttribute("AllowUpscale", BooleanValue(true));
consumerHelper.SetAttribute("AllowDownscale", BooleanValue(false));
consumerHelper.SetAttribute("ScreenWidth", UintegerValue(1920));
consumerHelper.SetAttribute("ScreenHeight", UintegerValue(1080));
consumerHelper.SetAttribute("StartRepresentationId", StringValue("auto"));
consumerHelper.SetAttribute("MaxBufferedSeconds", UintegerValue(30));
consumerHelper.SetAttribute("StartUpDelay", StringValue("0.1"));
consumerHelper.SetAttribute("AdaptationLogic", StringValue("dash::player::RateAndBufferBasedAdaptationLogic"));
consumerHelper.SetAttribute("MpdFileToRequest", StringValue(std::string("/myprefix/AVC/BBB-2s.mpd" )));
//consumerHelper.SetPrefix (std::string("/Server_" + boost::lexical_cast<std::string>(i%server.size ()) + "/layer0"));
ApplicationContainer app1 = consumerHelper.Install (nodes.Get(2));
// Producer responsible for hosting the MPD file
ndn::AppHelper mpdProducerHelper("ns3::ndn::FileServer");
// Producer will reply to all requests starting with /myprefix/AVC/ and hosts the mpd file there
mpdProducerHelper.SetPrefix("/myprefix");
mpdProducerHelper.SetAttribute("ContentDirectory", StringValue("/home/someuser/multimediaData"));
mpdProducerHelper.Install(nodes.Get(0)); // install to some node from nodelist
// Producer responsible for hosting the virtual segments
ndn::AppHelper fakeSegmentProducerHelper("ns3::ndn::FakeFileServer");
// Producer will reply to all requests starting with /myprefix/AVC/BBB/ and hosts the virtual segment files there
fakeSegmentProducerHelper.SetPrefix("/myprefix/AVC/BBB");
fakeSegmentProducerHelper.SetAttribute("MetaDataFile", StringValue("dash_dataset_avc_bbb.csv"));
fakeSegmentProducerHelper.Install(nodes.Get(0)); // install to some node from nodelist
ndn::GlobalRoutingHelper ndnGlobalRoutingHelper;
ndnGlobalRoutingHelper.InstallAll();
ndnGlobalRoutingHelper.AddOrigins("/myprefix", nodes.Get(0));
ndn::GlobalRoutingHelper::CalculateRoutes();
Simulator::Stop(Seconds(1000.0));
Simulator::Run();
Simulator::Destroy();
NS_LOG_UNCOND("Simulation Finished.");
return 0;
}
void
LenaPssFfMacSchedulerTestCase2::DoRun (void)
{
if (!m_errorModelEnabled)
{
Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (false));
Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false));
}
Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (true));
Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper> ();
lteHelper->SetEpcHelper (epcHelper);
Ptr<Node> pgw = epcHelper->GetPgwNode ();
// Create a single RemoteHost
NodeContainer remoteHostContainer;
remoteHostContainer.Create (1);
Ptr<Node> remoteHost = remoteHostContainer.Get (0);
InternetStackHelper internet;
internet.Install (remoteHostContainer);
// Create the Internet
PointToPointHelper p2ph;
p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("100Gb/s")));
p2ph.SetDeviceAttribute ("Mtu", UintegerValue (1500));
p2ph.SetChannelAttribute ("Delay", TimeValue (Seconds (0.001)));
NetDeviceContainer internetDevices = p2ph.Install (pgw, remoteHost);
Ipv4AddressHelper ipv4h;
ipv4h.SetBase ("1.0.0.0", "255.0.0.0");
Ipv4InterfaceContainer internetIpIfaces = ipv4h.Assign (internetDevices);
// interface 0 is localhost, 1 is the p2p device
Ipv4Address remoteHostAddr = internetIpIfaces.GetAddress (1);
Ipv4StaticRoutingHelper ipv4RoutingHelper;
Ptr<Ipv4StaticRouting> remoteHostStaticRouting = ipv4RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv4> ());
remoteHostStaticRouting->AddNetworkRouteTo (Ipv4Address ("7.0.0.0"), Ipv4Mask ("255.0.0.0"), 1);
// LogComponentDisableAll (LOG_LEVEL_ALL);
//LogComponentEnable ("LenaTestPssFfMacCheduler", LOG_LEVEL_ALL);
lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel"));
// Create Nodes: eNodeB and UE
NodeContainer enbNodes;
NodeContainer ueNodes;
enbNodes.Create (1);
ueNodes.Create (m_nUser);
// Install Mobility Model
MobilityHelper mobility;
mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
mobility.Install (enbNodes);
mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
mobility.Install (ueNodes);
// Create Devices and install them in the Nodes (eNB and UE)
NetDeviceContainer enbDevs;
NetDeviceContainer ueDevs;
lteHelper->SetSchedulerType ("ns3::PssFfMacScheduler");
enbDevs = lteHelper->InstallEnbDevice (enbNodes);
ueDevs = lteHelper->InstallUeDevice (ueNodes);
Ptr<LteEnbNetDevice> lteEnbDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();
Ptr<LteEnbPhy> enbPhy = lteEnbDev->GetPhy ();
enbPhy->SetAttribute ("TxPower", DoubleValue (30.0));
enbPhy->SetAttribute ("NoiseFigure", DoubleValue (5.0));
// Set UEs' position and power
for (int i = 0; i < m_nUser; i++)
{
Ptr<ConstantPositionMobilityModel> mm = ueNodes.Get (i)->GetObject<ConstantPositionMobilityModel> ();
mm->SetPosition (Vector (m_dist.at (i), 0.0, 0.0));
Ptr<LteUeNetDevice> lteUeDev = ueDevs.Get (i)->GetObject<LteUeNetDevice> ();
Ptr<LteUePhy> uePhy = lteUeDev->GetPhy ();
uePhy->SetAttribute ("TxPower", DoubleValue (23.0));
uePhy->SetAttribute ("NoiseFigure", DoubleValue (9.0));
}
// Install the IP stack on the UEs
internet.Install (ueNodes);
Ipv4InterfaceContainer ueIpIface;
ueIpIface = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueDevs));
// Assign IP address to UEs
for (uint32_t u = 0; u < ueNodes.GetN (); ++u)
{
Ptr<Node> ueNode = ueNodes.Get (u);
// Set the default gateway for the UE
Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting (ueNode->GetObject<Ipv4> ());
ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress (), 1);
}
// Attach a UE to a eNB
lteHelper->Attach (ueDevs, enbDevs.Get (0));
// Activate an EPS bearer on all UEs
for (uint32_t u = 0; u < ueNodes.GetN (); ++u)
{
Ptr<NetDevice> ueDevice = ueDevs.Get (u);
GbrQosInformation qos;
qos.gbrDl = (m_packetSize.at (u) + 32) * (1000 / m_interval) * 8; // bit/s, considering IP, UDP, RLC, PDCP header size
qos.gbrUl = (m_packetSize.at (u) + 32) * (1000 / m_interval) * 8;
qos.mbrDl = qos.gbrDl;
qos.mbrUl = qos.gbrUl;
enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
EpsBearer bearer (q, qos);
lteHelper->ActivateDedicatedEpsBearer (ueDevice, bearer, EpcTft::Default ());
}
// Install downlind and uplink applications
uint16_t dlPort = 1234;
uint16_t ulPort = 2000;
PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dlPort));
PacketSinkHelper ulPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), ulPort));
ApplicationContainer clientApps;
ApplicationContainer serverApps;
for (uint32_t u = 0; u < ueNodes.GetN (); ++u)
{
++ulPort;
serverApps.Add (dlPacketSinkHelper.Install (ueNodes.Get (u))); // receive packets from remotehost
serverApps.Add (ulPacketSinkHelper.Install (remoteHost)); // receive packets from UEs
UdpClientHelper dlClient (ueIpIface.GetAddress (u), dlPort); // uplink packets generator
dlClient.SetAttribute ("Interval", TimeValue (MilliSeconds (m_interval)));
dlClient.SetAttribute ("MaxPackets", UintegerValue (1000000));
dlClient.SetAttribute ("PacketSize", UintegerValue (m_packetSize.at (u)));
UdpClientHelper ulClient (remoteHostAddr, ulPort); // downlink packets generator
ulClient.SetAttribute ("Interval", TimeValue (MilliSeconds (m_interval)));
ulClient.SetAttribute ("MaxPackets", UintegerValue (1000000));
ulClient.SetAttribute ("PacketSize", UintegerValue (m_packetSize.at (u)));
clientApps.Add (dlClient.Install (remoteHost));
clientApps.Add (ulClient.Install (ueNodes.Get (u)));
}
serverApps.Start (Seconds (0.030));
clientApps.Start (Seconds (0.030));
double statsStartTime = 0.04; // need to allow for RRC connection establishment + SRS
double statsDuration = 0.5;
double tolerance = 0.1;
Simulator::Stop (Seconds (statsStartTime + statsDuration - 0.0001));
lteHelper->EnableRlcTraces ();
Ptr<RadioBearerStatsCalculator> rlcStats = lteHelper->GetRlcStats ();
rlcStats->SetAttribute ("StartTime", TimeValue (Seconds (statsStartTime)));
rlcStats->SetAttribute ("EpochDuration", TimeValue (Seconds (statsDuration)));
Simulator::Run ();
/**
* Check that the downlink assignation is done in a "token bank fair queue" manner
*/
NS_LOG_INFO ("DL - Test with " << m_nUser << " user(s)");
std::vector <uint64_t> dlDataRxed;
for (int i = 0; i < m_nUser; i++)
{
// get the imsi
uint64_t imsi = ueDevs.Get (i)->GetObject<LteUeNetDevice> ()->GetImsi ();
// get the lcId
uint8_t lcId = 4;
dlDataRxed.push_back (rlcStats->GetDlRxData (imsi, lcId));
NS_LOG_INFO ("\tUser " << i << " dist " << m_dist.at (i) << " imsi " << imsi << " bytes rxed " << (double)dlDataRxed.at (i) << " thr " << (double)dlDataRxed.at (i) / statsDuration << " ref " << m_estThrPssDl.at (i));
}
for (int i = 0; i < m_nUser; i++)
{
NS_TEST_ASSERT_MSG_EQ_TOL ((double)dlDataRxed.at (i) / statsDuration, m_estThrPssDl.at (i), m_estThrPssDl.at (i) * tolerance, " Unfair Throughput!");
}
Simulator::Destroy ();
}
void
EpcS1uDlTestCase::DoRun ()
{
Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper> ();
Ptr<Node> pgw = epcHelper->GetPgwNode ();
// allow jumbo packets
Config::SetDefault ("ns3::CsmaNetDevice::Mtu", UintegerValue (30000));
Config::SetDefault ("ns3::PointToPointNetDevice::Mtu", UintegerValue (30000));
epcHelper->SetAttribute ("S1uLinkMtu", UintegerValue (30000));
// Create a single RemoteHost
NodeContainer remoteHostContainer;
remoteHostContainer.Create (1);
Ptr<Node> remoteHost = remoteHostContainer.Get (0);
InternetStackHelper internet;
internet.Install (remoteHostContainer);
// Create the internet
PointToPointHelper p2ph;
p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("100Gb/s")));
NetDeviceContainer internetDevices = p2ph.Install (pgw, remoteHost);
Ipv4AddressHelper ipv4h;
ipv4h.SetBase ("1.0.0.0", "255.0.0.0");
ipv4h.Assign (internetDevices);
// setup default gateway for the remote hosts
Ipv4StaticRoutingHelper ipv4RoutingHelper;
Ptr<Ipv4StaticRouting> remoteHostStaticRouting = ipv4RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv4> ());
// hardcoded UE addresses for now
remoteHostStaticRouting->AddNetworkRouteTo (Ipv4Address ("7.0.0.0"), Ipv4Mask ("255.255.255.0"), 1);
NodeContainer enbs;
uint16_t cellIdCounter = 0;
for (std::vector<EnbDlTestData>::iterator enbit = m_enbDlTestData.begin ();
enbit < m_enbDlTestData.end ();
++enbit)
{
Ptr<Node> enb = CreateObject<Node> ();
enbs.Add (enb);
// we test EPC without LTE, hence we use:
// 1) a CSMA network to simulate the cell
// 2) a raw socket opened on the CSMA device to simulate the LTE socket
uint16_t cellId = ++cellIdCounter;
NodeContainer ues;
ues.Create (enbit->ues.size ());
NodeContainer cell;
cell.Add (ues);
cell.Add (enb);
CsmaHelper csmaCell;
NetDeviceContainer cellDevices = csmaCell.Install (cell);
// the eNB's CSMA NetDevice acting as an LTE NetDevice.
Ptr<NetDevice> enbDevice = cellDevices.Get (cellDevices.GetN () - 1);
// Note that the EpcEnbApplication won't care of the actual NetDevice type
epcHelper->AddEnb (enb, enbDevice, cellId);
// Plug test RRC entity
Ptr<EpcEnbApplication> enbApp = enb->GetApplication (0)->GetObject<EpcEnbApplication> ();
NS_ASSERT_MSG (enbApp != 0, "cannot retrieve EpcEnbApplication");
Ptr<EpcTestRrc> rrc = CreateObject<EpcTestRrc> ();
rrc->SetS1SapProvider (enbApp->GetS1SapProvider ());
enbApp->SetS1SapUser (rrc->GetS1SapUser ());
// we install the IP stack on UEs only
InternetStackHelper internet;
internet.Install (ues);
// assign IP address to UEs, and install applications
for (uint32_t u = 0; u < ues.GetN (); ++u)
{
Ptr<NetDevice> ueLteDevice = cellDevices.Get (u);
Ipv4InterfaceContainer ueIpIface = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueLteDevice));
Ptr<Node> ue = ues.Get (u);
// disable IP Forwarding on the UE. This is because we use
// CSMA broadcast MAC addresses for this test. The problem
// won't happen with a LteUeNetDevice.
ue->GetObject<Ipv4> ()->SetAttribute ("IpForward", BooleanValue (false));
uint16_t port = 1234;
PacketSinkHelper packetSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), port));
ApplicationContainer apps = packetSinkHelper.Install (ue);
apps.Start (Seconds (1.0));
apps.Stop (Seconds (10.0));
enbit->ues[u].serverApp = apps.Get (0)->GetObject<PacketSink> ();
Time interPacketInterval = Seconds (0.01);
UdpEchoClientHelper client (ueIpIface.GetAddress (0), port);
client.SetAttribute ("MaxPackets", UintegerValue (enbit->ues[u].numPkts));
client.SetAttribute ("Interval", TimeValue (interPacketInterval));
client.SetAttribute ("PacketSize", UintegerValue (enbit->ues[u].pktSize));
apps = client.Install (remoteHost);
apps.Start (Seconds (2.0));
apps.Stop (Seconds (10.0));
enbit->ues[u].clientApp = apps.Get (0);
uint64_t imsi = u+1;
epcHelper->AddUe (ueLteDevice, imsi);
epcHelper->ActivateEpsBearer (ueLteDevice, imsi, EpcTft::Default (), EpsBearer (EpsBearer::NGBR_VIDEO_TCP_DEFAULT));
enbApp->GetS1SapProvider ()->InitialUeMessage (imsi, (uint16_t) imsi);
}
}
Simulator::Run ();
for (std::vector<EnbDlTestData>::iterator enbit = m_enbDlTestData.begin ();
enbit < m_enbDlTestData.end ();
++enbit)
{
for (std::vector<UeDlTestData>::iterator ueit = enbit->ues.begin ();
ueit < enbit->ues.end ();
++ueit)
{
NS_TEST_ASSERT_MSG_EQ (ueit->serverApp->GetTotalRx (), (ueit->numPkts) * (ueit->pktSize), "wrong total received bytes");
}
}
Simulator::Destroy ();
}
TypeId RedQueue::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::RedQueue")
.SetParent<Queue> ()
.AddConstructor<RedQueue> ()
.AddAttribute ("Mode",
"Determines unit for QueueLimit",
EnumValue (QUEUE_MODE_PACKETS),
MakeEnumAccessor (&RedQueue::SetMode),
MakeEnumChecker (QUEUE_MODE_BYTES, "QUEUE_MODE_BYTES",
QUEUE_MODE_PACKETS, "QUEUE_MODE_PACKETS"))
.AddAttribute ("MeanPktSize",
"Average of packet size",
UintegerValue (500),
MakeUintegerAccessor (&RedQueue::m_meanPktSize),
MakeUintegerChecker<uint32_t> ())
.AddAttribute ("IdlePktSize",
"Average packet size used during idle times. Used when m_cautions = 3",
UintegerValue (0),
MakeUintegerAccessor (&RedQueue::m_idlePktSize),
MakeUintegerChecker<uint32_t> ())
.AddAttribute ("Wait",
"True for waiting between dropped packets",
BooleanValue (true),
MakeBooleanAccessor (&RedQueue::m_isWait),
MakeBooleanChecker ())
.AddAttribute ("Gentle",
"True to increases dropping probability slowly when average queue exceeds maxthresh",
BooleanValue (true),
MakeBooleanAccessor (&RedQueue::m_isGentle),
MakeBooleanChecker ())
.AddAttribute ("MinTh",
"Minimum average length threshold in packets/bytes",
DoubleValue (5),
MakeDoubleAccessor (&RedQueue::m_minTh),
MakeDoubleChecker<double> ())
.AddAttribute ("MaxTh",
"Maximum average length threshold in packets/bytes",
DoubleValue (15),
MakeDoubleAccessor (&RedQueue::m_maxTh),
MakeDoubleChecker<double> ())
.AddAttribute ("QueueLimit",
"Queue limit in bytes/packets",
UintegerValue (25),
MakeUintegerAccessor (&RedQueue::m_queueLimit),
MakeUintegerChecker<uint32_t> ())
.AddAttribute ("QW",
"Queue weight related to the exponential weighted moving average (EWMA)",
DoubleValue (0.002),
MakeDoubleAccessor (&RedQueue::m_qW),
MakeDoubleChecker <double> ())
.AddAttribute ("LInterm",
"The maximum probability of dropping a packet",
DoubleValue (50),
MakeDoubleAccessor (&RedQueue::m_lInterm),
MakeDoubleChecker <double> ())
.AddAttribute ("Ns1Compat",
"NS-1 compatibility",
BooleanValue (false),
MakeBooleanAccessor (&RedQueue::m_isNs1Compat),
MakeBooleanChecker ())
.AddAttribute ("LinkBandwidth",
"The RED link bandwidth",
DataRateValue (DataRate ("1.5Mbps")),
MakeDataRateAccessor (&RedQueue::m_linkBandwidth),
MakeDataRateChecker ())
.AddAttribute ("LinkDelay",
"The RED link delay",
TimeValue (MilliSeconds (20)),
MakeTimeAccessor (&RedQueue::m_linkDelay),
MakeTimeChecker ())
;
return tid;
}
int
main(int argc, char* argv[])
{
// setting default parameters for PointToPoint links and channels
Config::SetDefault("ns3::PointToPointNetDevice::DataRate", StringValue("10Mbps"));
Config::SetDefault("ns3::PointToPointChannel::Delay", StringValue("10ms"));
Config::SetDefault("ns3::DropTailQueue::MaxPackets", StringValue("20"));
// Read optional command-line parameters (e.g., enable visualizer with ./waf --run=<> --visualize
CommandLine cmd;
cmd.Parse(argc, argv);
// Creating nodes
NodeContainer nodes;
nodes.Create(3); // 3 nodes, connected: 0 <---> 1 <---> 2
// Connecting nodes using two links
PointToPointHelper p2p;
p2p.Install(nodes.Get(0), nodes.Get(1));
p2p.Install(nodes.Get(1), nodes.Get(2));
// Install NDN stack on all nodes
ndn::StackHelper ndnHelper;
ndnHelper.SetDefaultRoutes(true);
ndnHelper.setCsSize(0);
ndnHelper.SetOldContentStore("ns3::ndn::cs::Lru", "MaxSize", "100");
ndnHelper.InstallAll();
// Choosing forwarding strategy
ndn::StrategyChoiceHelper::InstallAll("/myprefix", "/localhost/nfd/strategy/best-route");
ns3::ndn::AppHelper consumerHelper("ns3::ndn::FileConsumerCbr::MultimediaConsumer");
consumerHelper.SetAttribute("AllowUpscale", BooleanValue(true));
consumerHelper.SetAttribute("AllowDownscale", BooleanValue(false));
consumerHelper.SetAttribute("ScreenWidth", UintegerValue(1920));
consumerHelper.SetAttribute("ScreenHeight", UintegerValue(1080));
consumerHelper.SetAttribute("StartRepresentationId", StringValue("auto"));
consumerHelper.SetAttribute("MaxBufferedSeconds", UintegerValue(30));
consumerHelper.SetAttribute("StartUpDelay", StringValue("0.1"));
consumerHelper.SetAttribute("AdaptationLogic", StringValue("dash::player::RateAndBufferBasedAdaptationLogic"));
consumerHelper.SetAttribute("MpdFileToRequest", StringValue(std::string("/myprefix/FakeVid1/vid1.mpd" )));
//consumerHelper.SetPrefix (std::string("/Server_" + boost::lexical_cast<std::string>(i%server.size ()) + "/layer0"));
ApplicationContainer app1 = consumerHelper.Install (nodes.Get(2));
ndn::AppHelper fakeDASHProducerHelper("ns3::ndn::FakeMultimediaServer");
// This fake multimedia producer will reply to all requests starting with /myprefix/FakeVid1
fakeDASHProducerHelper.SetPrefix("/myprefix/FakeVid1");
fakeDASHProducerHelper.SetAttribute("MetaDataFile", StringValue("representations/netflix_vid1.csv"));
// We just give the MPD file a name that makes it unique
fakeDASHProducerHelper.SetAttribute("MPDFileName", StringValue("vid1.mpd"));
fakeDASHProducerHelper.Install(nodes.Get(0));
// We can install more then one fake multimedia producer on one node:
// This fake multimedia producer will reply to all requests starting with /myprefix/FakeVid2
fakeDASHProducerHelper.SetPrefix("/myprefix/FakeVid2");
fakeDASHProducerHelper.SetAttribute("MetaDataFile", StringValue("representations/netflix_vid2.csv"));
// We just give the MPD file a name that makes it unique
fakeDASHProducerHelper.SetAttribute("MPDFileName", StringValue("vid2.mpd"));
// This fake multimedia producer will reply to all requests starting with /myprefix/FakeVid3
fakeDASHProducerHelper.SetPrefix("/myprefix/FakeVid3");
fakeDASHProducerHelper.SetAttribute("MetaDataFile", StringValue("representations/netflix_vid3.csv"));
// We just give the MPD file a name that makes it unique
fakeDASHProducerHelper.SetAttribute("MPDFileName", StringValue("vid3.mpd"));
ndn::GlobalRoutingHelper ndnGlobalRoutingHelper;
ndnGlobalRoutingHelper.InstallAll();
ndnGlobalRoutingHelper.AddOrigins("/myprefix", nodes.Get(0));
ndn::GlobalRoutingHelper::CalculateRoutes();
Simulator::Stop(Seconds(60.0));
Simulator::Run();
Simulator::Destroy();
NS_LOG_UNCOND("Simulation Finished.");
return 0;
}
int
main(int argc, char* argv[])
{
// Read optional command-line parameters (e.g., enable visualizer with ./waf --run=<> --visualize
CommandLine cmd;
cmd.Parse(argc, argv);
NS_LOG_UNCOND("NUMBER OF NODES = "<<ns3::N_NODES<<" , nConsumers = "<<ns3::N_TotalClients<<" , nProducers = "<<ns3::N_PRODUCERS);
double l = 0;
double s = ns3::N_GEANT_ROUTERS-1;
Ptr<UniformRandomVariable> uniVar;
uniVar=CreateObject<UniformRandomVariable> ();
uniVar->SetAttribute ("Min", DoubleValue (l));
uniVar->SetAttribute ("Max", DoubleValue (s));
// setting default parameters for PointToPoint links and channels
//this is for 56 clients to be attached
Config::SetDefault("ns3::PointToPointNetDevice::DataRate", StringValue(ns3::CONS_LINK_DATA_RATE));
Config::SetDefault("ns3::PointToPointChannel::Delay", StringValue(ns3::CONS_LINK_DELAY));
Config::SetDefault("ns3::DropTailQueue::MaxPackets", StringValue("20"));
/////////////////////////////////////////////////////////////////////////
//***IDs 0-55 are consumers, the next "N_PRODUCERS" IDs are producers, //
//***and the IDs after them are Geant routers //
/////////////////////////////////////////////////////////////////////////
NodeContainer nodes;
nodes.Create(ns3::N_TotalClients + ns3::N_PRODUCERS);
PointToPointHelper p2p;
//let's first read the Geant topology
AnnotatedTopologyReader topologyReader("", 1);
topologyReader.SetFileName("/home/ali/ndnSIM/ns-3/src/ndnSIM/examples/topologies/Geant2012.txt");
topologyReader.Read();
// topologyReader.ApplySettings();
topologyReader.SaveGraphviz("src/ndnSIM/examples/topologies/GeantGraph.dot");
RandomizeConsumers (uniVar, "/home/ali/ndnSIM/ns-3/src/ndnSIM/examples/topologies/Geant2012.txt",
topologyReader ,nodes, p2p);
RandomizeProducers(uniVar, "/home/ali/GitHub/Datasets/test/fifty/producers/server_dataset/large_scale/", nodes, p2p);
MyResultApp resApp;
resApp.InstallEndpointApp(nodes);
resApp.InstallRouterApp(topologyReader);
// Install NDN stack on all nodes
ndn::StackHelper ndnHelper;
ndnHelper.disableRibManager();
//ndnHelper.disableFaceManager();
//set cache store size
ndnHelper.setCsSize(ns3::CACHE_SIZE);
ndnHelper.InstallAll();
ndn::GlobalRoutingHelper ndnGlobalRoutingHelper;
ndnGlobalRoutingHelper.Install(nodes);
for (size_t i = 0; i < ns3::N_PRODUCERS; i++) {
ifstream inFile ((SERVERS_DATASETS_PATH + "server_dataset_"+std::to_string(i)).c_str());
if(inFile.is_open()){
std::string line;
while (getline(inFile, line)){
ndnGlobalRoutingHelper.AddOrigins (line, nodes.Get (i+ns3::N_TotalClients));
}
}
else{
NS_LOG_UNCOND("ERROR!!! UNABLE TO OPEN FILE "<<inFile);
}
}
ndn::GlobalRoutingHelper::CalculateRoutes();
// Choosing forwarding strategy for all
ndn::StrategyChoiceHelper::InstallAll("/", "/localhost/nfd/strategy/best-route");
// Installing applications
////////////////////////////////////////////////////////////////
//from 5 file logs, i assign to five consumer each ONE file//
///////////////////////////////////////////////////////////////
NS_LOG_UNCOND("now we've 56 clients attached to some of routers (randomly chosen) and "<<ns3::N_PRODUCERS<<" producers");
ndn::AppHelper consumerHelper("ns3::ndn::ConsumerZipfMandelbrot");
consumerHelper.SetAttribute("Frequency", StringValue(ns3::CONSUMER_FREQ));
consumerHelper.SetAttribute("NumberOfContents", UintegerValue(CONTENT_UNIVERSE));
// consumerHelper.SetAttribute("MaxSeq",IntegerValue(MAX_SEQ_NUMBER));
consumerHelper.SetAttribute("Randomize", StringValue(RANDOMIZE_ATTRIBUTE));
consumerHelper.SetAttribute("q", DoubleValue(Q));
consumerHelper.SetAttribute("s", DoubleValue(S));
// std:: string consumerPath= "/home/ali/GitHub/Datasets/test/fifty/producers/server_dataset/5F-5C-3P/content_universe_165";
for(size_t consIndex=0; consIndex<ns3::N_TotalClients;consIndex++){
consumerHelper.SetPrefix("/");
consumerHelper.Install(nodes.Get(consIndex))
.Start (Seconds(CONS_START + uniVar->GetValue(0.0, 0.01)));
}//for
// Schedule simulation time and run the simulation
Simulator::Stop(Seconds(ns3::SIMULATION_TIME));
ndn::L3RateTracer::InstallAll("rate-trace.txt", Seconds(1.0));
L2RateTracer::InstallAll("drop-trace.txt", Seconds(0.5));
//ndn::CsTracer::InstallAll("cs-trace.txt", Seconds(1));
ndn::AppDelayTracer::InstallAll("app-delays-trace.txt");
Simulator::Run();
uint64_t m_totalForwardedInterest=0;
uint64_t m_totalInterestOverhead=0;
uint64_t m_totalForwardedData=0;
uint64_t m_totalDataOverhead=0;
uint64_t m_totalUnsatisfiedInterests=0;
uint64_t m_totalSatisfiedInterests=0;
uint64_t m_totalRetrievedDataAtClients=0;
ofstream spUnsatisfiedInterestsFile;
spUnsatisfiedInterestsFile.open("/home/ali/Documents/BFRresults/unsatisfied_Interests/spUnsatisfiedInterestsFile_"+std::to_string(ns3::S)+"_FP = "+std::to_string(ns3::FPP));
ofstream SPDataOverheadFile;
SPDataOverheadFile.open("/home/ali/Documents/BFRresults/overhead_files/SPDataOverheadFile_"+std::to_string(ns3::S));
ofstream SPInterestOverheadFile;
SPInterestOverheadFile.open("/home/ali/Documents//BFRresults/overhead_files/SPInterestOverheadFile_"+std::to_string(ns3::S)+"_FP = "+std::to_string(ns3::FPP));
SPDataOverheadFile<<"nodeID"<<" "<<"lastDataFwd"<<" "
<<"nDataFwd"<<" "<<"dataOverhead"<<"\n";
SPInterestOverheadFile<<"nodeID"<<" "<<"lastInterestFwd"<<" "
<<"nInterestFwd"<<" "<<"interestOverhead"<<"\n";
spUnsatisfiedInterestsFile<<"consumerID"<<" "<<"NumberOfUnsatisfiedInterests"<<" "<<"NumberOfSatisfiedInterests"<<"\n";
//let's extract results from nodes' apps
Ptr<MyResultApp> nodeApp;
for (NodeList::Iterator node = NodeList::Begin(); node != NodeList::End(); node++) {
nodeApp = CreateObject<ns3::MyResultApp> ();
if ((*node)->GetId()>=ns3::N_TotalClients && (*node)->GetId()<=ns3::N_TotalClients+ns3::N_PRODUCERS-1){
nodeApp = (*node)->GetApplication(1)->GetObject<ns3::MyResultApp>();
}
else{
nodeApp = (*node)->GetApplication(0)->GetObject<ns3::MyResultApp>();
}
spUnsatisfiedInterestsFile<<(*node)->GetId()<<" "<<nodeApp->m_myNumberOfUnsatisfiedInterests<<" "<<nodeApp->m_myNumberOfSatisfiedInterests<<"\n";
if((*node)->GetId()<ns3::N_TotalClients){
m_totalUnsatisfiedInterests+= nodeApp->m_myNumberOfUnsatisfiedInterests;
m_totalSatisfiedInterests+= nodeApp->m_myNumberOfSatisfiedInterests;
m_totalRetrievedDataAtClients+= nodeApp->m_myNumberOfRetrievedData;
}
if((*node)->GetId()>=ns3::N_TotalClients){
SPDataOverheadFile<<nodeApp->GetNode()->GetId()<<" "<<nodeApp->m_myLastDataForwardTime
<<" "<<nodeApp->m_nMyForwardedData<<" "
<<nodeApp->m_myTotalDataOverhead<<"\n";
m_totalForwardedData += nodeApp->m_nMyForwardedData;
m_totalDataOverhead += nodeApp->m_myTotalDataOverhead;
}
if((*node)->GetId()<=ns3::N_TotalClients-1 || (*node)->GetId()>=ns3::N_TotalClients+ns3::N_PRODUCERS){
SPInterestOverheadFile<<nodeApp->GetNode()->GetId()<<" "<<nodeApp->m_myLastInterestForwardTime
<<" "<<nodeApp->m_nMyForwardedInterest<<" "
<<nodeApp->m_myTotalInterestOverhead<<"\n";
m_totalForwardedInterest += nodeApp->m_nMyForwardedInterest;
m_totalInterestOverhead += nodeApp->m_myTotalInterestOverhead;
}
}//for
//let's write the totals also in interest file:
SPInterestOverheadFile<<"nTotalForwardedInterest = "<<m_totalForwardedInterest<<"\n";
SPInterestOverheadFile<<"totalInterestOverhead = "<<m_totalInterestOverhead<<"\n";
SPInterestOverheadFile<<"nTotalForwardedData = "<<m_totalForwardedData<<"\n";
SPInterestOverheadFile<<"totalDataOverhead = "<<m_totalDataOverhead<<"\n";
SPInterestOverheadFile<<"Normalized overhead over interest count = "
<<double(m_totalInterestOverhead+m_totalDataOverhead)/(double)m_totalForwardedInterest<<"\n";
SPInterestOverheadFile<<"Normalized overhead over data count = "
<<double(m_totalInterestOverhead+m_totalDataOverhead)/(double)m_totalForwardedData;
spUnsatisfiedInterestsFile<<"total number of unsatisfied Interests at all the consumers = "<<m_totalUnsatisfiedInterests<<"\n";
spUnsatisfiedInterestsFile<<"total number of satisfied Interests at all the consumers = "<<m_totalSatisfiedInterests<<"\n";
spUnsatisfiedInterestsFile<<"Unsatisfaction due to link failure or false positive (METHOD a) = "<<(double)m_totalUnsatisfiedInterests/(m_totalSatisfiedInterests+m_totalUnsatisfiedInterests)<<"\n";
spUnsatisfiedInterestsFile<<"total number of retrieved data at consumers = "<<m_totalRetrievedDataAtClients;
SPInterestOverheadFile.close();
SPDataOverheadFile.close();
spUnsatisfiedInterestsFile.close();
Simulator::Destroy();
//std::string hitDistanceCompleteFile = "/home/ali/ndnSIM/ns-3/HitDistanceFile"
//CreateHitDistanceDataset (hitDistanceCompleteFile);
return 0;
}//ns3::main
TypeId
FileConsumerCbr::GetTypeId(void)
{
static TypeId tid =
TypeId("ns3::ndn::FileConsumerCbr")
.SetGroupName("Ndn")
.SetParent<FileConsumer>()
.AddConstructor<FileConsumerCbr>()
.AddAttribute("WindowSize", "The amount of interests that are issued per second (0 = automatically determine maximum)", UintegerValue(0),
MakeUintegerAccessor(&FileConsumerCbr::m_windowSize),
MakeUintegerChecker<uint32_t>())
.AddAttribute("StartWindowSize", "The amount of interests that are allowed to be issued at the beginning of the download without knowing the actual file size (0 = none)", UintegerValue(0),
MakeUintegerAccessor(&FileConsumerCbr::m_fileStartWindow),
MakeUintegerChecker<uint32_t>())
;
return tid;
}
void Ping6::Send ()
{
NS_LOG_FUNCTION_NOARGS ();
NS_ASSERT (m_sendEvent.IsExpired ());
Ptr<Packet> p = 0;
uint8_t* data = new uint8_t[m_size];
Ipv6Address src;
Ptr<Ipv6> ipv6 = GetNode ()->GetObject<Ipv6> ();
if (m_ifIndex > 0)
{
/* hack to have ifIndex in Ipv6RawSocketImpl
* maybe add a SetIfIndex in Ipv6RawSocketImpl directly
*/
Ipv6InterfaceAddress dstIa (m_peerAddress);
for (uint32_t i = 0; i < GetNode ()->GetObject<Ipv6> ()->GetNAddresses (m_ifIndex); i++)
{
src = GetNode ()->GetObject<Ipv6> ()->GetAddress (m_ifIndex, i).GetAddress ();
Ipv6InterfaceAddress srcIa (src);
if ( srcIa.GetScope() == dstIa.GetScope() )
{
break;
}
}
}
else
{
src = m_localAddress;
}
NS_ASSERT_MSG (m_size >= 4, "ICMPv6 echo request payload size must be >= 4");
data[0] = 0xDE;
data[1] = 0xAD;
data[2] = 0xBE;
data[3] = 0xEF;
p = Create<Packet> (data, 4);
p->AddAtEnd (Create<Packet> (m_size - 4));
Icmpv6Echo req (1);
req.SetId (0xBEEF);
req.SetSeq (m_seq);
m_seq++;
/* we do not calculate pseudo header checksum here, because we are not sure about
* source IPv6 address. Checksum is calculated in Ipv6RawSocketImpl.
*/
p->AddHeader (req);
m_socket->Bind (Inet6SocketAddress (src, 0));
/* use Loose Routing (routing type 0) */
if (m_routers.size ())
{
Ipv6ExtensionLooseRoutingHeader routingHeader;
routingHeader.SetNextHeader (Ipv6Header::IPV6_ICMPV6);
routingHeader.SetLength (m_routers.size () * 16 + 8);
routingHeader.SetTypeRouting (0);
routingHeader.SetSegmentsLeft (m_routers.size ());
routingHeader.SetRoutersAddress (m_routers);
p->AddHeader (routingHeader);
m_socket->SetAttribute ("Protocol", UintegerValue (Ipv6Header::IPV6_EXT_ROUTING));
}
m_socket->Send (p, 0);
++m_sent;
NS_LOG_INFO ("Sent " << p->GetSize () << " bytes to " << m_peerAddress);
if (m_sent < m_count)
{
ScheduleTransmit (m_interval);
}
delete[] data;
}
