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
51using namespace ns3;
52
53NS_LOG_COMPONENT_DEFINE ("EpcTestS1uUplink");
54
68{
69public:
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
95protected:
96 virtual void DoDispose (void);
97
98private:
99 virtual void StartApplication (void);
100 virtual void StopApplication (void);
101
108 void Send (void);
109
113
117 uint16_t m_peerPort;
119
120 uint16_t m_rnti;
121 uint8_t m_bid;
122
123};
124
125
126
127TypeId
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)),
142 .AddAttribute ("RemoteAddress",
143 "The destination Ipv4Address of the outbound packets",
145 MakeIpv4AddressAccessor (&EpsBearerTagUdpClient::m_peerAddress),
146 MakeIpv4AddressChecker ())
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
185void
187{
188 m_peerAddress = ip;
190}
191
192void
194{
196 Application::DoDispose ();
197}
198
199void
201{
203
204 if (!m_socket)
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
216void
218{
220 Simulator::Cancel (m_sendEvent);
221}
222
223void
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
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
278 uint16_t rnti;
279 uint8_t bid;
280
283};
284
285UeUlTestData::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{
313public:
320 EpcS1uUlTestCase (std::string name, std::vector<EnbUlTestData> v);
321 virtual ~EpcS1uUlTestCase ();
322
323private:
324 virtual void DoRun (void);
325 std::vector<EnbUlTestData> m_enbUlTestData;
326};
327
328
329EpcS1uUlTestCase::EpcS1uUlTestCase (std::string name, std::vector<EnbUlTestData> v)
330 : TestCase (name),
331 m_enbUlTestData (v)
332{}
333
335{}
336
337void
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
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, "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
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{
515public:
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}
void Run(ObjectFactory &factory, uint32_t pop, uint32_t total, uint32_t runs, Ptr< RandomVariableStream > eventStream, bool calRev)
Perform the runs for a single scheduler type.
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:183
void MarkPermanent(void)
Changes the state of this entry to Permanent.
Definition: arp-cache.cc:441
void SetMacAddress(Address macAddress)
Definition: arp-cache.cc:497
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:351
AttributeValue implementation for Boolean.
Definition: boolean.h:37
build a set of CsmaNetDevice objects
Definition: csma-helper.h:48
NetDeviceContainer Install(Ptr< Node > node) const
This method creates an ns3::CsmaChannel with the attributes configured by CsmaHelper::SetChannelAttri...
Definition: csma-helper.cc:208
Class for representing data rates.
Definition: data-rate.h:89
AttributeValue implementation for DataRate.
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.
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.
void AddUe(Ptr< NetDevice > ueLteDevice, uint64_t imsi) override
Notify the EPC of the existence of a new UE which might attach at a later time.
uint8_t ActivateEpsBearer(Ptr< NetDevice > ueLteDevice, uint64_t imsi, Ptr< EpcTft > tft, EpsBearer bearer) override
Activate an EPS bearer, setting up the corresponding S1-U tunnel.
Ptr< Node > GetPgwNode() const override
Get the PGW node.
Ipv4Address GetUeDefaultGatewayAddress() override
Ipv4InterfaceContainer AssignUeIpv4Address(NetDeviceContainer ueDevices) override
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(const NodeContainer &nc)
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:73
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:104
AttributeValue implementation for Time.
Definition: nstime.h:1309
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
#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 AttributeAccessor > MakeTimeAccessor(T1 a1)
Definition: nstime.h:1310
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Definition: uinteger.h:45
Callback< R, Args... > MakeNullCallback(void)
Definition: callback.h:697
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:206
#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:282
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:1245
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1253
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:90