A Discrete-Event Network Simulator
API
epc-test-s1u-uplink.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2007,2008,2009 INRIA, UDCAST
3 * Copyright (c) 2011 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation;
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 *
18 * The original version of UdpClient is by Amine Ismail
19 * <amine.ismail@sophia.inria.fr> <amine.ismail@udcast.com>
20 * The rest of the code (including modifying UdpClient into
21 * EpsBearerTagUdpClient) is by Nicola Baldo <nbaldo@cttc.es>
22 */
23
24#include "lte-test-entities.h"
25
26#include "ns3/arp-cache.h"
27#include "ns3/boolean.h"
28#include "ns3/config.h"
29#include "ns3/csma-helper.h"
30#include "ns3/epc-enb-application.h"
31#include "ns3/eps-bearer-tag.h"
32#include "ns3/inet-socket-address.h"
33#include "ns3/internet-stack-helper.h"
34#include "ns3/ipv4-address-helper.h"
35#include "ns3/log.h"
36#include "ns3/packet-sink-helper.h"
37#include "ns3/packet-sink.h"
38#include "ns3/point-to-point-epc-helper.h"
39#include "ns3/point-to-point-helper.h"
40#include "ns3/seq-ts-header.h"
41#include "ns3/simulator.h"
42#include "ns3/test.h"
43#include "ns3/uinteger.h"
44#include <ns3/ipv4-interface.h>
45#include <ns3/ipv4-static-routing-helper.h>
46#include <ns3/ipv4-static-routing.h>
47#include <ns3/mac48-address.h>
48
49using namespace ns3;
50
51NS_LOG_COMPONENT_DEFINE("EpcTestS1uUplink");
52
65{
66 public:
71 static TypeId GetTypeId();
72
80 EpsBearerTagUdpClient(uint16_t rnti, uint8_t bid);
81
82 ~EpsBearerTagUdpClient() override;
83
89 void SetRemote(Ipv4Address ip, uint16_t port);
90
91 protected:
92 void DoDispose() override;
93
94 private:
95 void StartApplication() override;
96 void StopApplication() override;
97
104 void Send();
105
109
113 uint16_t m_peerPort;
115
116 uint16_t m_rnti;
117 uint8_t m_bid;
118};
119
120TypeId
122{
123 static TypeId tid =
124 TypeId("ns3::EpsBearerTagUdpClient")
126 .AddConstructor<EpsBearerTagUdpClient>()
127 .AddAttribute(
128 "MaxPackets",
129 "The maximum number of packets the application will send (zero means infinite)",
130 UintegerValue(100),
132 MakeUintegerChecker<uint32_t>())
133 .AddAttribute("Interval",
134 "The time to wait between packets",
135 TimeValue(Seconds(1.0)),
138 .AddAttribute("RemoteAddress",
139 "The destination Ipv4Address of the outbound packets",
141 MakeIpv4AddressAccessor(&EpsBearerTagUdpClient::m_peerAddress),
142 MakeIpv4AddressChecker())
143 .AddAttribute("RemotePort",
144 "The destination port of the outbound packets",
145 UintegerValue(100),
147 MakeUintegerChecker<uint16_t>())
148 .AddAttribute("PacketSize",
149 "Size of packets generated. The minimum packet size is 12 bytes which is "
150 "the size of the header carrying the sequence number and the time stamp.",
151 UintegerValue(1024),
153 MakeUintegerChecker<uint32_t>());
154 return tid;
155}
156
158 : m_rnti(0),
159 m_bid(0)
160{
162 m_sent = 0;
163 m_socket = nullptr;
165}
166
168 : m_rnti(rnti),
169 m_bid(bid)
170{
172 m_sent = 0;
173 m_socket = nullptr;
175}
176
178{
180}
181
182void
184{
185 m_peerAddress = ip;
187}
188
189void
191{
193 Application::DoDispose();
194}
195
196void
198{
200
201 if (!m_socket)
202 {
203 TypeId tid = TypeId::LookupByName("ns3::UdpSocketFactory");
204 m_socket = Socket::CreateSocket(GetNode(), tid);
205 m_socket->Bind();
207 }
208
210 m_sendEvent = Simulator::Schedule(Seconds(0.0), &EpsBearerTagUdpClient::Send, this);
211}
212
213void
215{
217 Simulator::Cancel(m_sendEvent);
218}
219
220void
222{
225 SeqTsHeader seqTs;
226 seqTs.SetSeq(m_sent);
227 Ptr<Packet> p = Create<Packet>(m_size - (8 + 4)); // 8+4 : the size of the seqTs header
228 p->AddHeader(seqTs);
229
231 p->AddPacketTag(tag);
232
233 if ((m_socket->Send(p)) >= 0)
234 {
235 ++m_sent;
236 NS_LOG_INFO("TraceDelay TX " << m_size << " bytes to " << m_peerAddress << " Uid: "
237 << p->GetUid() << " Time: " << (Simulator::Now()).As(Time::S));
238 }
239 else
240 {
241 NS_LOG_INFO("Error while sending " << m_size << " bytes to " << m_peerAddress);
242 }
243
244 if (m_sent < m_count || m_count == 0)
245 {
246 m_sendEvent = Simulator::Schedule(m_interval, &EpsBearerTagUdpClient::Send, this);
247 }
248}
249
256{
265 UeUlTestData(uint32_t n, uint32_t s, uint16_t r, uint8_t l);
266
269 uint16_t rnti;
270 uint8_t bid;
271
274};
275
276UeUlTestData::UeUlTestData(uint32_t n, uint32_t s, uint16_t r, uint8_t l)
277 : numPkts(n),
278 pktSize(s),
279 rnti(r),
280 bid(l)
281{
282}
283
291{
292 std::vector<UeUlTestData> ues;
293};
294
301{
302 public:
309 EpcS1uUlTestCase(std::string name, std::vector<EnbUlTestData> v);
310 ~EpcS1uUlTestCase() override;
311
312 private:
313 void DoRun() override;
314 std::vector<EnbUlTestData> m_enbUlTestData;
315};
316
317EpcS1uUlTestCase::EpcS1uUlTestCase(std::string name, std::vector<EnbUlTestData> v)
318 : TestCase(name),
319 m_enbUlTestData(v)
320{
321}
322
324{
325}
326
327void
329{
330 Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper>();
331 Ptr<Node> pgw = epcHelper->GetPgwNode();
332
333 // allow jumbo packets
334 Config::SetDefault("ns3::CsmaNetDevice::Mtu", UintegerValue(30000));
335 Config::SetDefault("ns3::PointToPointNetDevice::Mtu", UintegerValue(30000));
336 epcHelper->SetAttribute("S1uLinkMtu", UintegerValue(30000));
337
338 // Create a single RemoteHost
339 NodeContainer remoteHostContainer;
340 remoteHostContainer.Create(1);
341 Ptr<Node> remoteHost = remoteHostContainer.Get(0);
342 InternetStackHelper internet;
343 internet.Install(remoteHostContainer);
344
345 // Create the internet
347 p2ph.SetDeviceAttribute("DataRate", DataRateValue(DataRate("100Gb/s")));
348 NetDeviceContainer internetDevices = p2ph.Install(pgw, remoteHost);
349 Ipv4AddressHelper ipv4h;
350 ipv4h.SetBase("1.0.0.0", "255.0.0.0");
351 Ipv4InterfaceContainer internetNodesIpIfaceContainer = ipv4h.Assign(internetDevices);
352
353 // setup default gateway for the remote hosts
354 Ipv4StaticRoutingHelper ipv4RoutingHelper;
355 Ptr<Ipv4StaticRouting> remoteHostStaticRouting =
356 ipv4RoutingHelper.GetStaticRouting(remoteHost->GetObject<Ipv4>());
357
358 // hardcoded UE addresses for now
359 remoteHostStaticRouting->AddNetworkRouteTo(Ipv4Address("7.0.0.0"),
360 Ipv4Mask("255.255.255.0"),
361 1);
362
363 uint16_t udpSinkPort = 1234;
364
365 NodeContainer enbs;
366 uint16_t cellIdCounter = 0;
367 uint64_t imsiCounter = 0;
368
369 for (std::vector<EnbUlTestData>::iterator enbit = m_enbUlTestData.begin();
370 enbit < m_enbUlTestData.end();
371 ++enbit)
372 {
373 Ptr<Node> enb = CreateObject<Node>();
374 enbs.Add(enb);
375
376 // we test EPC without LTE, hence we use:
377 // 1) a CSMA network to simulate the cell
378 // 2) a raw socket opened on the CSMA device to simulate the LTE socket
379
380 uint16_t cellId = ++cellIdCounter;
381
382 NodeContainer ues;
383 ues.Create(enbit->ues.size());
384
385 NodeContainer cell;
386 cell.Add(ues);
387 cell.Add(enb);
388
389 CsmaHelper csmaCell;
390 NetDeviceContainer cellDevices = csmaCell.Install(cell);
391
392 // the eNB's CSMA NetDevice acting as an LTE NetDevice.
393 Ptr<NetDevice> enbDevice = cellDevices.Get(cellDevices.GetN() - 1);
394
395 // Note that the EpcEnbApplication won't care of the actual NetDevice type
396 std::vector<uint16_t> cellIds;
397 cellIds.push_back(cellId);
398 epcHelper->AddEnb(enb, enbDevice, cellIds);
399
400 // Plug test RRC entity
402 NS_ASSERT_MSG(enbApp, "cannot retrieve EpcEnbApplication");
403 Ptr<EpcTestRrc> rrc = CreateObject<EpcTestRrc>();
404 enb->AggregateObject(rrc);
405 rrc->SetS1SapProvider(enbApp->GetS1SapProvider());
406 enbApp->SetS1SapUser(rrc->GetS1SapUser());
407
408 // we install the IP stack on UEs only
409 InternetStackHelper internet;
410 internet.Install(ues);
411
412 // assign IP address to UEs, and install applications
413 for (uint32_t u = 0; u < ues.GetN(); ++u)
414 {
415 Ptr<NetDevice> ueLteDevice = cellDevices.Get(u);
416 Ipv4InterfaceContainer ueIpIface =
417 epcHelper->AssignUeIpv4Address(NetDeviceContainer(ueLteDevice));
418
419 Ptr<Node> ue = ues.Get(u);
420
421 // disable IP Forwarding on the UE. This is because we use
422 // CSMA broadcast MAC addresses for this test. The problem
423 // won't happen with a LteUeNetDevice.
424 Ptr<Ipv4> ueIpv4 = ue->GetObject<Ipv4>();
425 ueIpv4->SetAttribute("IpForward", BooleanValue(false));
426
427 // tell the UE to route all packets to the GW
428 Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting(ueIpv4);
429 Ipv4Address gwAddr = epcHelper->GetUeDefaultGatewayAddress();
430 NS_LOG_INFO("GW address: " << gwAddr);
431 ueStaticRouting->SetDefaultRoute(gwAddr, 1);
432
433 // since the UEs in this test use CSMA with IP enabled, and
434 // the eNB uses CSMA but without IP, we fool the UE's ARP
435 // cache into thinking that the IP address of the GW can be
436 // reached by sending a CSMA packet to the broadcast
437 // address, so the eNB will get it.
438 int32_t ueLteIpv4IfIndex = ueIpv4->GetInterfaceForDevice(ueLteDevice);
439 Ptr<Ipv4L3Protocol> ueIpv4L3Protocol = ue->GetObject<Ipv4L3Protocol>();
440 Ptr<Ipv4Interface> ueLteIpv4Iface = ueIpv4L3Protocol->GetInterface(ueLteIpv4IfIndex);
441 Ptr<ArpCache> ueArpCache = ueLteIpv4Iface->GetArpCache();
442 ueArpCache->SetAliveTimeout(Seconds(1000));
443 ArpCache::Entry* arpCacheEntry = ueArpCache->Add(gwAddr);
444 arpCacheEntry->SetMacAddress(Mac48Address::GetBroadcast());
445 arpCacheEntry->MarkPermanent();
446
447 PacketSinkHelper packetSinkHelper(
448 "ns3::UdpSocketFactory",
449 InetSocketAddress(Ipv4Address::GetAny(), udpSinkPort));
450 ApplicationContainer sinkApp = packetSinkHelper.Install(remoteHost);
451 sinkApp.Start(Seconds(1.0));
452 sinkApp.Stop(Seconds(10.0));
453 enbit->ues[u].serverApp = sinkApp.Get(0)->GetObject<PacketSink>();
454
455 Time interPacketInterval = Seconds(0.01);
457 CreateObject<EpsBearerTagUdpClient>(enbit->ues[u].rnti, enbit->ues[u].bid);
458 client->SetAttribute("RemoteAddress",
459 Ipv4AddressValue(internetNodesIpIfaceContainer.GetAddress(1)));
460 client->SetAttribute("RemotePort", UintegerValue(udpSinkPort));
461 client->SetAttribute("MaxPackets", UintegerValue(enbit->ues[u].numPkts));
462 client->SetAttribute("Interval", TimeValue(interPacketInterval));
463 client->SetAttribute("PacketSize", UintegerValue(enbit->ues[u].pktSize));
464 ue->AddApplication(client);
465 ApplicationContainer clientApp;
466 clientApp.Add(client);
467 clientApp.Start(Seconds(2.0));
468 clientApp.Stop(Seconds(10.0));
469 enbit->ues[u].clientApp = client;
470
471 uint64_t imsi = ++imsiCounter;
472 epcHelper->AddUe(ueLteDevice, imsi);
473 epcHelper->ActivateEpsBearer(ueLteDevice,
474 imsi,
475 EpcTft::Default(),
476 EpsBearer(EpsBearer::NGBR_VIDEO_TCP_DEFAULT));
477 Simulator::Schedule(MilliSeconds(10),
478 &EpcEnbS1SapProvider::InitialUeMessage,
479 enbApp->GetS1SapProvider(),
480 imsi,
481 enbit->ues[u].rnti);
482 // need this since all sinks are installed in the same node
483 ++udpSinkPort;
484 }
485 }
486
487 Simulator::Run();
488
489 for (std::vector<EnbUlTestData>::iterator enbit = m_enbUlTestData.begin();
490 enbit < m_enbUlTestData.end();
491 ++enbit)
492 {
493 for (std::vector<UeUlTestData>::iterator ueit = enbit->ues.begin(); ueit < enbit->ues.end();
494 ++ueit)
495 {
496 NS_TEST_ASSERT_MSG_EQ(ueit->serverApp->GetTotalRx(),
497 (ueit->numPkts) * (ueit->pktSize),
498 "wrong total received bytes");
499 }
500 }
501
502 Simulator::Destroy();
503}
504
509{
510 public:
512
514
516 : TestSuite("epc-s1u-uplink", SYSTEM)
517{
518 std::vector<EnbUlTestData> v1;
519 EnbUlTestData e1;
520 UeUlTestData f1(1, 100, 1, 1);
521 e1.ues.push_back(f1);
522 v1.push_back(e1);
523 AddTestCase(new EpcS1uUlTestCase("1 eNB, 1UE", v1), TestCase::QUICK);
524
525 std::vector<EnbUlTestData> v2;
526 EnbUlTestData e2;
527 UeUlTestData f2_1(1, 100, 1, 1);
528 e2.ues.push_back(f2_1);
529 UeUlTestData f2_2(2, 200, 2, 1);
530 e2.ues.push_back(f2_2);
531 v2.push_back(e2);
532 AddTestCase(new EpcS1uUlTestCase("1 eNB, 2UEs", v2), TestCase::QUICK);
533
534 std::vector<EnbUlTestData> v3;
535 v3.push_back(e1);
536 v3.push_back(e2);
537 AddTestCase(new EpcS1uUlTestCase("2 eNBs", v3), TestCase::QUICK);
538
539 EnbUlTestData e3;
540 UeUlTestData f3_1(3, 50, 1, 1);
541 e3.ues.push_back(f3_1);
542 UeUlTestData f3_2(5, 1472, 2, 1);
543 e3.ues.push_back(f3_2);
544 UeUlTestData f3_3(1, 1, 3, 1);
545 e3.ues.push_back(f3_2);
546 std::vector<EnbUlTestData> v4;
547 v4.push_back(e3);
548 v4.push_back(e1);
549 v4.push_back(e2);
550 AddTestCase(new EpcS1uUlTestCase("3 eNBs", v4), TestCase::QUICK);
551
552 std::vector<EnbUlTestData> v5;
553 EnbUlTestData e5;
554 UeUlTestData f5(10, 3000, 1, 1);
555 e5.ues.push_back(f5);
556 v5.push_back(e5);
557 AddTestCase(new EpcS1uUlTestCase("1 eNB, 10 pkts 3000 bytes each", v5), TestCase::QUICK);
558
559 std::vector<EnbUlTestData> v6;
560 EnbUlTestData e6;
561 UeUlTestData f6(50, 3000, 1, 1);
562 e6.ues.push_back(f6);
563 v6.push_back(e6);
564 AddTestCase(new EpcS1uUlTestCase("1 eNB, 50 pkts 3000 bytes each", v6), TestCase::QUICK);
565
566 std::vector<EnbUlTestData> v7;
567 EnbUlTestData e7;
568 UeUlTestData f7(10, 15000, 1, 1);
569 e7.ues.push_back(f7);
570 v7.push_back(e7);
571 AddTestCase(new EpcS1uUlTestCase("1 eNB, 10 pkts 15000 bytes each", v7), TestCase::QUICK);
572
573 std::vector<EnbUlTestData> v8;
574 EnbUlTestData e8;
575 UeUlTestData f8(100, 15000, 1, 1);
576 e8.ues.push_back(f8);
577 v8.push_back(e8);
578 AddTestCase(new EpcS1uUlTestCase("1 eNB, 100 pkts 15000 bytes each", v8), TestCase::QUICK);
579}
EpcS1uUlTestCase class.
EpcS1uUlTestCase(std::string name, std::vector< EnbUlTestData > v)
Constructor.
std::vector< EnbUlTestData > m_enbUlTestData
ENB UL test data.
void DoRun() override
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 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
void ScheduleTransmit(Time dt)
Schedule transmit function.
Ptr< Socket > m_socket
the socket
uint32_t m_size
the size of packets generated
void StartApplication() override
Application specific startup code.
uint8_t m_bid
the bearer identificator
void StopApplication() override
Application specific shutdown code.
EventId m_sendEvent
the send event
void Send()
Send function.
Ipv4Address m_peerAddress
the peer address of the outbound packets
void DoDispose() override
Destructor implementation.
Time m_interval
the time between packets
static TypeId GetTypeId()
Get the type ID.
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)
Start all of the Applications in this container at the start 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:107
A record that that holds information about an ArpCache entry.
Definition: arp-cache.h:184
void MarkPermanent()
Changes the state of this entry to Permanent.
Definition: arp-cache.cc:447
void SetMacAddress(Address macAddress)
Definition: arp-cache.cc:507
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:353
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:226
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:91
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:55
bool IsExpired() const
This method is syntactic sugar for the ns3::Simulator::IsExpired method.
Definition: event-id.cc:69
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:43
AttributeValue implementation for Ipv4Address.
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:79
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:258
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() 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() 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:180
uint32_t AddApplication(Ptr< Application > application)
Associate an Application to this Node.
Definition: node.cc:169
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:200
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition: object.h:471
void AggregateObject(Ptr< Object > other)
Aggregate two Objects together.
Definition: object.cc:259
void AddHeader(const Header &header)
Add header to this packet.
Definition: packet.cc:268
void AddPacketTag(const Tag &tag) const
Add a packet tag.
Definition: packet.cc:979
uint64_t GetUid() const
Returns the packet's Uid.
Definition: packet.cc:412
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:74
void AddEnb(Ptr< Node > enbNode, Ptr< NetDevice > lteEnbNetDevice, std::vector< uint16_t > cellIds) override
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:126
virtual int Bind(const Address &address)=0
Allocate a local endpoint for this socket.
encapsulates test code
Definition: test.h:1060
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:305
A suite of tests to run.
Definition: test.h:1256
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
AttributeValue implementation for Time.
Definition: nstime.h:1423
a unique identifier for an interface.
Definition: type-id.h:60
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:935
Hold an unsigned integer type.
Definition: uinteger.h:45
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:66
#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:86
Ptr< const AttributeAccessor > MakeTimeAccessor(T1 a1)
Definition: nstime.h:1424
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Definition: uinteger.h:46
Callback< R, Args... > MakeNullCallback()
Definition: callback.h:734
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:891
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
#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:275
void(* DataRate)(DataRate oldValue, DataRate newValue)
TracedValue callback signature for DataRate.
Definition: data-rate.h:328
Time Now()
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:296
#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:144
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1336
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1348
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:535
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)