A Discrete-Event Network Simulator
API
epc-test-s1u-uplink.cc
Go to the documentation of this file.
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2007,2008,2009 INRIA, UDCAST
4  * Copyright (c) 2011 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation;
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18  *
19  * The original version of UdpClient is by Amine Ismail
20  * <amine.ismail@sophia.inria.fr> <amine.ismail@udcast.com>
21  * The rest of the code (including modifying UdpClient into
22  * EpsBearerTagUdpClient) is by Nicola Baldo <nbaldo@cttc.es>
23  */
24 
25 
26 
27 #include "ns3/simulator.h"
28 #include "ns3/log.h"
29 #include "ns3/test.h"
30 #include "ns3/point-to-point-epc-helper.h"
31 #include "ns3/epc-enb-application.h"
32 #include "ns3/packet-sink-helper.h"
33 #include "ns3/point-to-point-helper.h"
34 #include "ns3/csma-helper.h"
35 #include "ns3/internet-stack-helper.h"
36 #include "ns3/ipv4-address-helper.h"
37 #include "ns3/inet-socket-address.h"
38 #include "ns3/packet-sink.h"
39 #include <ns3/ipv4-static-routing-helper.h>
40 #include <ns3/ipv4-static-routing.h>
41 #include <ns3/ipv4-interface.h>
42 #include <ns3/mac48-address.h>
43 #include "ns3/seq-ts-header.h"
44 #include "ns3/eps-bearer-tag.h"
45 #include "ns3/arp-cache.h"
46 #include "ns3/boolean.h"
47 #include "ns3/uinteger.h"
48 #include "ns3/config.h"
49 #include "lte-test-entities.h"
50 
51 using namespace ns3;
52 
53 NS_LOG_COMPONENT_DEFINE ("EpcTestS1uUplink");
54 
68 {
69 public:
74  static TypeId
75  GetTypeId (void);
76 
84  EpsBearerTagUdpClient (uint16_t rnti, uint8_t bid);
85 
86  virtual ~EpsBearerTagUdpClient ();
87 
93  void SetRemote (Ipv4Address ip, uint16_t port);
94 
95 protected:
96  virtual void DoDispose (void);
97 
98 private:
99  virtual void StartApplication (void);
100  virtual void StopApplication (void);
101 
108  void Send (void);
109 
110  uint32_t m_count;
112  uint32_t m_size;
113 
114  uint32_t m_sent;
117  uint16_t m_peerPort;
119 
120  uint16_t m_rnti;
121  uint8_t m_bid;
122 
123 };
124 
125 
126 
127 TypeId
129 {
130  static TypeId tid = TypeId ("ns3::EpsBearerTagUdpClient")
132  .AddConstructor<EpsBearerTagUdpClient> ()
133  .AddAttribute ("MaxPackets",
134  "The maximum number of packets the application will send",
135  UintegerValue (100),
137  MakeUintegerChecker<uint32_t> ())
138  .AddAttribute ("Interval",
139  "The time to wait between packets", TimeValue (Seconds (1.0)),
141  MakeTimeChecker ())
142  .AddAttribute ("RemoteAddress",
143  "The destination Ipv4Address of the outbound packets",
144  Ipv4AddressValue (),
147  .AddAttribute ("RemotePort", "The destination port of the outbound packets",
148  UintegerValue (100),
150  MakeUintegerChecker<uint16_t> ())
151  .AddAttribute ("PacketSize",
152  "Size of packets generated. The minimum packet size is 12 bytes which is the size of the header carrying the sequence number and the time stamp.",
153  UintegerValue (1024),
155  MakeUintegerChecker<uint32_t> ())
156  ;
157  return tid;
158 }
159 
161  : m_rnti (0),
162  m_bid (0)
163 {
165  m_sent = 0;
166  m_socket = 0;
167  m_sendEvent = EventId ();
168 }
169 
171  : m_rnti (rnti),
172  m_bid (bid)
173 {
175  m_sent = 0;
176  m_socket = 0;
177  m_sendEvent = EventId ();
178 }
179 
181 {
183 }
184 
185 void
187 {
188  m_peerAddress = ip;
189  m_peerPort = port;
190 }
191 
192 void
194 {
196  Application::DoDispose ();
197 }
198 
199 void
201 {
203 
204  if (m_socket == 0)
205  {
206  TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");
207  m_socket = Socket::CreateSocket (GetNode (), tid);
208  m_socket->Bind ();
210  }
211 
213  m_sendEvent = Simulator::Schedule (Seconds (0.0), &EpsBearerTagUdpClient::Send, this);
214 }
215 
216 void
218 {
220  Simulator::Cancel (m_sendEvent);
221 }
222 
223 void
225 {
228  SeqTsHeader seqTs;
229  seqTs.SetSeq (m_sent);
230  Ptr<Packet> p = Create<Packet> (m_size - (8 + 4)); // 8+4 : the size of the seqTs header
231  p->AddHeader (seqTs);
232 
233  EpsBearerTag tag (m_rnti, m_bid);
234  p->AddPacketTag (tag);
235 
236  if ((m_socket->Send (p)) >= 0)
237  {
238  ++m_sent;
239  NS_LOG_INFO ("TraceDelay TX " << m_size << " bytes to "
240  << m_peerAddress << " Uid: " << p->GetUid ()
241  << " Time: " << (Simulator::Now ()).As (Time::S));
242 
243  }
244  else
245  {
246  NS_LOG_INFO ("Error while sending " << m_size << " bytes to "
247  << m_peerAddress);
248  }
249 
250  if (m_sent < m_count)
251  {
252  m_sendEvent = Simulator::Schedule (m_interval, &EpsBearerTagUdpClient::Send, this);
253  }
254 }
255 
256 
257 
265 {
274  UeUlTestData (uint32_t n, uint32_t s, uint16_t r, uint8_t l);
275 
276  uint32_t numPkts;
277  uint32_t pktSize;
278  uint16_t rnti;
279  uint8_t bid;
280 
283 };
284 
285 UeUlTestData::UeUlTestData (uint32_t n, uint32_t s, uint16_t r, uint8_t l)
286  : numPkts (n),
287  pktSize (s),
288  rnti (r),
289  bid (l)
290 {}
291 
300 {
301  std::vector<UeUlTestData> ues;
302 };
303 
304 
312 {
313 public:
320  EpcS1uUlTestCase (std::string name, std::vector<EnbUlTestData> v);
321  virtual ~EpcS1uUlTestCase ();
322 
323 private:
324  virtual void DoRun (void);
325  std::vector<EnbUlTestData> m_enbUlTestData;
326 };
327 
328 
329 EpcS1uUlTestCase::EpcS1uUlTestCase (std::string name, std::vector<EnbUlTestData> v)
330  : TestCase (name),
331  m_enbUlTestData (v)
332 {}
333 
335 {}
336 
337 void
339 {
340  Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper> ();
341  Ptr<Node> pgw = epcHelper->GetPgwNode ();
342 
343  // allow jumbo packets
344  Config::SetDefault ("ns3::CsmaNetDevice::Mtu", UintegerValue (30000));
345  Config::SetDefault ("ns3::PointToPointNetDevice::Mtu", UintegerValue (30000));
346  epcHelper->SetAttribute ("S1uLinkMtu", UintegerValue (30000));
347 
348  // Create a single RemoteHost
349  NodeContainer remoteHostContainer;
350  remoteHostContainer.Create (1);
351  Ptr<Node> remoteHost = remoteHostContainer.Get (0);
352  InternetStackHelper internet;
353  internet.Install (remoteHostContainer);
354 
355  // Create the internet
356  PointToPointHelper p2ph;
357  p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("100Gb/s")));
358  NetDeviceContainer internetDevices = p2ph.Install (pgw, remoteHost);
359  Ipv4AddressHelper ipv4h;
360  ipv4h.SetBase ("1.0.0.0", "255.0.0.0");
361  Ipv4InterfaceContainer internetNodesIpIfaceContainer = ipv4h.Assign (internetDevices);
362 
363  // setup default gateway for the remote hosts
364  Ipv4StaticRoutingHelper ipv4RoutingHelper;
365  Ptr<Ipv4StaticRouting> remoteHostStaticRouting = ipv4RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv4> ());
366 
367  // hardcoded UE addresses for now
368  remoteHostStaticRouting->AddNetworkRouteTo (Ipv4Address ("7.0.0.0"), Ipv4Mask ("255.255.255.0"), 1);
369 
370 
371 
372  uint16_t udpSinkPort = 1234;
373 
374  NodeContainer enbs;
375  uint16_t cellIdCounter = 0;
376  uint64_t imsiCounter = 0;
377 
378  for (std::vector<EnbUlTestData>::iterator enbit = m_enbUlTestData.begin ();
379  enbit < m_enbUlTestData.end ();
380  ++enbit)
381  {
382  Ptr<Node> enb = CreateObject<Node> ();
383  enbs.Add (enb);
384 
385  // we test EPC without LTE, hence we use:
386  // 1) a CSMA network to simulate the cell
387  // 2) a raw socket opened on the CSMA device to simulate the LTE socket
388 
389  uint16_t cellId = ++cellIdCounter;
390 
391  NodeContainer ues;
392  ues.Create (enbit->ues.size ());
393 
394  NodeContainer cell;
395  cell.Add (ues);
396  cell.Add (enb);
397 
398  CsmaHelper csmaCell;
399  NetDeviceContainer cellDevices = csmaCell.Install (cell);
400 
401  // the eNB's CSMA NetDevice acting as an LTE NetDevice.
402  Ptr<NetDevice> enbDevice = cellDevices.Get (cellDevices.GetN () - 1);
403 
404  // Note that the EpcEnbApplication won't care of the actual NetDevice type
405  std::vector<uint16_t> cellIds;
406  cellIds.push_back (cellId);
407  epcHelper->AddEnb (enb, enbDevice, cellIds);
408 
409  // Plug test RRC entity
411  NS_ASSERT_MSG (enbApp != 0, "cannot retrieve EpcEnbApplication");
412  Ptr<EpcTestRrc> rrc = CreateObject<EpcTestRrc> ();
413  enb->AggregateObject (rrc);
414  rrc->SetS1SapProvider (enbApp->GetS1SapProvider ());
415  enbApp->SetS1SapUser (rrc->GetS1SapUser ());
416 
417  // we install the IP stack on UEs only
418  InternetStackHelper internet;
419  internet.Install (ues);
420 
421  // assign IP address to UEs, and install applications
422  for (uint32_t u = 0; u < ues.GetN (); ++u)
423  {
424  Ptr<NetDevice> ueLteDevice = cellDevices.Get (u);
425  Ipv4InterfaceContainer ueIpIface = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueLteDevice));
426 
427  Ptr<Node> ue = ues.Get (u);
428 
429  // disable IP Forwarding on the UE. This is because we use
430  // CSMA broadcast MAC addresses for this test. The problem
431  // won't happen with a LteUeNetDevice.
432  Ptr<Ipv4> ueIpv4 = ue->GetObject<Ipv4> ();
433  ueIpv4->SetAttribute ("IpForward", BooleanValue (false));
434 
435  // tell the UE to route all packets to the GW
436  Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting (ueIpv4);
437  Ipv4Address gwAddr = epcHelper->GetUeDefaultGatewayAddress ();
438  NS_LOG_INFO ("GW address: " << gwAddr);
439  ueStaticRouting->SetDefaultRoute (gwAddr, 1);
440 
441  // since the UEs in this test use CSMA with IP enabled, and
442  // the eNB uses CSMA but without IP, we fool the UE's ARP
443  // cache into thinking that the IP address of the GW can be
444  // reached by sending a CSMA packet to the broadcast
445  // address, so the eNB will get it.
446  int32_t ueLteIpv4IfIndex = ueIpv4->GetInterfaceForDevice (ueLteDevice);
447  Ptr<Ipv4L3Protocol> ueIpv4L3Protocol = ue->GetObject<Ipv4L3Protocol> ();
448  Ptr<Ipv4Interface> ueLteIpv4Iface = ueIpv4L3Protocol->GetInterface (ueLteIpv4IfIndex);
449  Ptr<ArpCache> ueArpCache = ueLteIpv4Iface->GetArpCache ();
450  ueArpCache->SetAliveTimeout (Seconds (1000));
451  ArpCache::Entry* arpCacheEntry = ueArpCache->Add (gwAddr);
452  arpCacheEntry->SetMacAddress (Mac48Address::GetBroadcast ());
453  arpCacheEntry->MarkPermanent ();
454 
455 
456  PacketSinkHelper packetSinkHelper ("ns3::UdpSocketFactory",
457  InetSocketAddress (Ipv4Address::GetAny (), udpSinkPort));
458  ApplicationContainer sinkApp = packetSinkHelper.Install (remoteHost);
459  sinkApp.Start (Seconds (1.0));
460  sinkApp.Stop (Seconds (10.0));
461  enbit->ues[u].serverApp = sinkApp.Get (0)->GetObject<PacketSink> ();
462 
463  Time interPacketInterval = Seconds (0.01);
464  Ptr<EpsBearerTagUdpClient> client = CreateObject<EpsBearerTagUdpClient> (enbit->ues[u].rnti, enbit->ues[u].bid);
465  client->SetAttribute ("RemoteAddress", Ipv4AddressValue (internetNodesIpIfaceContainer.GetAddress (1)));
466  client->SetAttribute ("RemotePort", UintegerValue (udpSinkPort));
467  client->SetAttribute ("MaxPackets", UintegerValue (enbit->ues[u].numPkts));
468  client->SetAttribute ("Interval", TimeValue (interPacketInterval));
469  client->SetAttribute ("PacketSize", UintegerValue (enbit->ues[u].pktSize));
470  ue->AddApplication (client);
471  ApplicationContainer clientApp;
472  clientApp.Add (client);
473  clientApp.Start (Seconds (2.0));
474  clientApp.Stop (Seconds (10.0));
475  enbit->ues[u].clientApp = client;
476 
477  uint64_t imsi = ++imsiCounter;
478  epcHelper->AddUe (ueLteDevice, imsi);
479  epcHelper->ActivateEpsBearer (ueLteDevice, imsi, EpcTft::Default (), EpsBearer (EpsBearer::NGBR_VIDEO_TCP_DEFAULT));
480  Simulator::Schedule (MilliSeconds (10),
481  &EpcEnbS1SapProvider::InitialUeMessage,
482  enbApp->GetS1SapProvider (), imsi, enbit->ues[u].rnti);
483  // need this since all sinks are installed in the same node
484  ++udpSinkPort;
485  }
486 
487  }
488 
489  Simulator::Run ();
490 
491  for (std::vector<EnbUlTestData>::iterator enbit = m_enbUlTestData.begin ();
492  enbit < m_enbUlTestData.end ();
493  ++enbit)
494  {
495  for (std::vector<UeUlTestData>::iterator ueit = enbit->ues.begin ();
496  ueit < enbit->ues.end ();
497  ++ueit)
498  {
499  NS_TEST_ASSERT_MSG_EQ (ueit->serverApp->GetTotalRx (), (ueit->numPkts) * (ueit->pktSize), "wrong total received bytes");
500  }
501  }
502 
503  Simulator::Destroy ();
504 }
505 
506 
507 
508 
509 
514 {
515 public:
517 
519 
521  : TestSuite ("epc-s1u-uplink", SYSTEM)
522 {
523  std::vector<EnbUlTestData> v1;
524  EnbUlTestData e1;
525  UeUlTestData f1 (1, 100, 1, 1);
526  e1.ues.push_back (f1);
527  v1.push_back (e1);
528  AddTestCase (new EpcS1uUlTestCase ("1 eNB, 1UE", v1), TestCase::QUICK);
529 
530 
531  std::vector<EnbUlTestData> v2;
532  EnbUlTestData e2;
533  UeUlTestData f2_1 (1, 100, 1, 1);
534  e2.ues.push_back (f2_1);
535  UeUlTestData f2_2 (2, 200, 2, 1);
536  e2.ues.push_back (f2_2);
537  v2.push_back (e2);
538  AddTestCase (new EpcS1uUlTestCase ("1 eNB, 2UEs", v2), TestCase::QUICK);
539 
540 
541  std::vector<EnbUlTestData> v3;
542  v3.push_back (e1);
543  v3.push_back (e2);
544  AddTestCase (new EpcS1uUlTestCase ("2 eNBs", v3), TestCase::QUICK);
545 
546 
547  EnbUlTestData e3;
548  UeUlTestData f3_1 (3, 50, 1, 1);
549  e3.ues.push_back (f3_1);
550  UeUlTestData f3_2 (5, 1472, 2, 1);
551  e3.ues.push_back (f3_2);
552  UeUlTestData f3_3 (1, 1, 3, 1);
553  e3.ues.push_back (f3_2);
554  std::vector<EnbUlTestData> v4;
555  v4.push_back (e3);
556  v4.push_back (e1);
557  v4.push_back (e2);
558  AddTestCase (new EpcS1uUlTestCase ("3 eNBs", v4), TestCase::QUICK);
559 
560  std::vector<EnbUlTestData> v5;
561  EnbUlTestData e5;
562  UeUlTestData f5 (10, 3000, 1, 1);
563  e5.ues.push_back (f5);
564  v5.push_back (e5);
565  AddTestCase (new EpcS1uUlTestCase ("1 eNB, 10 pkts 3000 bytes each", v5), TestCase::QUICK);
566 
567  std::vector<EnbUlTestData> v6;
568  EnbUlTestData e6;
569  UeUlTestData f6 (50, 3000, 1, 1);
570  e6.ues.push_back (f6);
571  v6.push_back (e6);
572  AddTestCase (new EpcS1uUlTestCase ("1 eNB, 50 pkts 3000 bytes each", v6), TestCase::QUICK);
573 
574  std::vector<EnbUlTestData> v7;
575  EnbUlTestData e7;
576  UeUlTestData f7 (10, 15000, 1, 1);
577  e7.ues.push_back (f7);
578  v7.push_back (e7);
579  AddTestCase (new EpcS1uUlTestCase ("1 eNB, 10 pkts 15000 bytes each", v7), TestCase::QUICK);
580 
581  std::vector<EnbUlTestData> v8;
582  EnbUlTestData e8;
583  UeUlTestData f8 (100, 15000, 1, 1);
584  e8.ues.push_back (f8);
585  v8.push_back (e8);
586  AddTestCase (new EpcS1uUlTestCase ("1 eNB, 100 pkts 15000 bytes each", v8), TestCase::QUICK);
587 
588 }
EpcS1uUlTestCase class.
EpcS1uUlTestCase(std::string name, std::vector< EnbUlTestData > v)
Constructor.
std::vector< EnbUlTestData > m_enbUlTestData
ENB UL test data.
virtual void DoRun(void)
Implementation to actually run this TestCase.
Test that the S1-U interface implementation works correctly.
uint16_t m_peerPort
the destination port of the outbound packets
void Send(void)
Send function.
void SetRemote(Ipv4Address ip, uint16_t port)
set the remote address and port
uint32_t m_count
maximum number of packets to send
uint32_t m_sent
number of packets sent
static TypeId GetTypeId(void)
Get the type ID.
virtual void StopApplication(void)
Application specific shutdown code.
void ScheduleTransmit(Time dt)
Schedule transmit function.
Ptr< Socket > m_socket
the socket
uint32_t m_size
the size of packets generated
uint8_t m_bid
the bearer identificator
virtual void StartApplication(void)
Application specific startup code.
EventId m_sendEvent
the send event
Ipv4Address m_peerAddress
the peer address of the outbound packets
virtual void DoDispose(void)
Destructor implementation.
Time m_interval
the time between packets
holds a vector of ns3::Application pointers.
Ptr< Application > Get(uint32_t i) const
Get the Ptr<Application> stored in this container at a given index.
void Start(Time start)
Arrange for all of the Applications in this container to Start() at the Time given as a parameter.
void Add(ApplicationContainer other)
Append the contents of another ApplicationContainer to the end of this container.
void Stop(Time stop)
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter.
The base class for all ns3 applications.
Definition: application.h:61
Ptr< Node > GetNode() const
Definition: application.cc:104
A record that that holds information about an ArpCache entry.
Definition: arp-cache.h:178
void MarkPermanent(void)
Changes the state of this entry to Permanent.
Definition: arp-cache.cc:414
void SetMacAddress(Address macAddress)
Definition: arp-cache.cc:460
void SetAliveTimeout(Time aliveTimeout)
Set the time the entry will be in ALIVE state (unless refreshed)
Definition: arp-cache.cc:136
ArpCache::Entry * Add(Ipv4Address to)
Add an Ipv4Address to this ARP cache.
Definition: arp-cache.cc:330
AttributeValue implementation for Boolean.
Definition: boolean.h:37
build a set of CsmaNetDevice objects
Definition: csma-helper.h:47
NetDeviceContainer Install(Ptr< Node > node) const
This method creates an ns3::CsmaChannel with the attributes configured by CsmaHelper::SetChannelAttri...
Definition: csma-helper.cc:225
Class for representing data rates.
Definition: data-rate.h:89
AttributeValue implementation for DataRate.
Definition: data-rate.h:298
This application is installed inside eNBs and provides the bridge functionality for user data plane p...
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:92
Tag used to define the RNTI and EPS bearer ID for packets interchanged between the EpcEnbApplication ...
An identifier for simulation events.
Definition: event-id.h:54
bool IsExpired(void) const
This method is syntactic sugar for the ns3::Simulator::IsExpired method.
Definition: event-id.cc:65
an Inet address class
aggregate IP/TCP/UDP functionality to existing Nodes.
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.
Ipv4InterfaceContainer Assign(const NetDeviceContainer &c)
Assign IP addresses to the net devices specified in the container based on the current network prefix...
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:41
AttributeValue implementation for Ipv4Address.
Definition: ipv4-address.h:341
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:77
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
Implement the IPv4 layer.
a class to represent an Ipv4 address mask
Definition: ipv4-address.h:256
Helper class that adds ns3::Ipv4StaticRouting objects.
Ptr< Ipv4StaticRouting > GetStaticRouting(Ptr< Ipv4 > ipv4) const
Try and find the static routing protocol as either the main routing protocol or in the list of routin...
holds a vector of ns3::NetDevice pointers
uint32_t GetN(void) const
Get the number of Ptr<NetDevice> stored in this container.
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
virtual Ipv4Address GetUeDefaultGatewayAddress()
virtual Ptr< Node > GetPgwNode() const
Get the PGW node.
virtual uint8_t ActivateEpsBearer(Ptr< NetDevice > ueLteDevice, uint64_t imsi, Ptr< EpcTft > tft, EpsBearer bearer)
Activate an EPS bearer, setting up the corresponding S1-U tunnel.
virtual void AddUe(Ptr< NetDevice > ueLteDevice, uint64_t imsi)
Notify the EPC of the existence of a new UE which might attach at a later time.
virtual Ipv4InterfaceContainer AssignUeIpv4Address(NetDeviceContainer ueDevices)
Assign IPv4 addresses to UE devices.
keep track of a set of node pointers.
uint32_t GetN(void) 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.
void Add(NodeContainer other)
Append the contents of another NodeContainer to the end of this container.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
Ptr< Application > GetApplication(uint32_t index) const
Retrieve the index-th Application associated to this node.
Definition: node.cc:170
uint32_t AddApplication(Ptr< Application > application)
Associate an Application to this Node.
Definition: node.cc:159
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:256
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:470
void AggregateObject(Ptr< Object > other)
Aggregate two Objects together.
Definition: object.cc:252
void AddHeader(const Header &header)
Add header to this packet.
Definition: packet.cc:256
uint64_t GetUid(void) const
Returns the packet's Uid.
Definition: packet.cc:390
void AddPacketTag(const Tag &tag) const
Add a packet tag.
Definition: packet.cc:956
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes.
ApplicationContainer Install(NodeContainer c) const
Install an ns3::PacketSinkApplication on each node of the input container configured with all the att...
Receive and consume traffic generated to an IP address and port.
Definition: packet-sink.h:72
virtual void AddEnb(Ptr< Node > enbNode, Ptr< NetDevice > lteEnbNetDevice, std::vector< uint16_t > cellIds)
Add an eNB to the EPC.
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.
NetDeviceContainer Install(NodeContainer c)
Packet header to carry sequence number and timestamp.
Definition: seq-ts-header.h:45
void SetSeq(uint32_t seq)
virtual int Send(Ptr< Packet > p, uint32_t flags)=0
Send data (or dummy data) to the remote host.
virtual int Connect(const Address &address)=0
Initiate a connection to a remote host.
void SetRecvCallback(Callback< void, Ptr< Socket > > receivedData)
Notify application when new data is available to be read.
Definition: socket.cc:128
virtual int Bind(const Address &address)=0
Allocate a local endpoint for this socket.
encapsulates test code
Definition: test.h:994
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:299
A suite of tests to run.
Definition: test.h:1188
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:103
AttributeValue implementation for Time.
Definition: nstime.h:1308
a unique identifier for an interface.
Definition: type-id.h:59
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:922
Hold an unsigned integer type.
Definition: uinteger.h:44
uint16_t port
Definition: dsdv-manet.cc:45
static void Send(Ptr< NetDevice > dev, int level, std::string emuMode)
Definition: fd-emu-send.cc:55
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:67
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:88
Ptr< const AttributeChecker > MakeIpv4AddressChecker(void)
Ptr< const AttributeAccessor > MakeIpv4AddressAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method.
Definition: ipv4-address.h:341
Ptr< const AttributeAccessor > MakeTimeAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method.
Definition: nstime.h:1309
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method.
Definition: uinteger.h:45
Callback< R, Ts... > MakeNullCallback(void)
Definition: callback.h:1688
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:849
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
#define NS_LOG_FUNCTION_NOARGS()
Output the name of the function.
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
Time Now(void)
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:287
#define NS_TEST_ASSERT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report and abort if not.
Definition: test.h:141
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1244
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1252
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Ptr< const AttributeChecker > MakeTimeChecker(const Time min, const Time max)
Helper to make a Time checker with bounded range.
Definition: time.cc:522
Custom structure containing information about data sent in the uplink of eNodeB.
std::vector< UeUlTestData > ues
the list of UEs
Custom test structure to hold information of data transmitted in the uplink per UE.
uint32_t numPkts
the number of packets sent
uint16_t rnti
the RNTI
uint32_t pktSize
the packet size
Ptr< PacketSink > serverApp
the server application
UeUlTestData(uint32_t n, uint32_t s, uint16_t r, uint8_t l)
Constructor.
uint8_t bid
the BID
Ptr< Application > clientApp
the client application
uint32_t pktSize
packet size used for the simulation (in bytes)
Definition: wifi-bianchi.cc:89