A Discrete-Event Network Simulator
API
epc-test-s1u-downlink.cc
Go to the documentation of this file.
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
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  * Author: Nicola Baldo <nbaldo@cttc.es>
19  */
20 
21 
22 
23 #include "ns3/simulator.h"
24 #include "ns3/log.h"
25 #include "ns3/test.h"
26 #include "ns3/point-to-point-epc-helper.h"
27 #include "ns3/epc-enb-application.h"
28 #include "ns3/packet-sink-helper.h"
29 #include "ns3/udp-echo-helper.h"
30 #include "ns3/point-to-point-helper.h"
31 #include "ns3/csma-helper.h"
32 #include "ns3/internet-stack-helper.h"
33 #include "ns3/ipv4-address-helper.h"
34 #include "ns3/inet-socket-address.h"
35 #include "ns3/packet-sink.h"
36 #include <ns3/ipv4-static-routing-helper.h>
37 #include <ns3/ipv4-static-routing.h>
38 #include "ns3/boolean.h"
39 #include "ns3/uinteger.h"
40 #include "ns3/config.h"
41 #include "ns3/eps-bearer.h"
42 #include "lte-test-entities.h"
43 
44 using namespace ns3;
45 
46 NS_LOG_COMPONENT_DEFINE ("EpcTestS1uDownlink");
47 
48 
56 {
63  UeDlTestData (uint32_t n, uint32_t s);
64 
65  uint32_t numPkts;
66  uint32_t pktSize;
67 
70 };
71 
72 UeDlTestData::UeDlTestData (uint32_t n, uint32_t s)
73  : numPkts (n),
74  pktSize (s)
75 {
76 }
77 
86 {
87  std::vector<UeDlTestData> ues;
88 };
89 
90 
91 
98 class EpcS1uDlTestCase : public TestCase
99 {
100 public:
107  EpcS1uDlTestCase (std::string name, std::vector<EnbDlTestData> v);
108  virtual ~EpcS1uDlTestCase ();
109 
110 private:
111  virtual void DoRun (void);
112  std::vector<EnbDlTestData> m_enbDlTestData;
113 };
114 
115 
116 EpcS1uDlTestCase::EpcS1uDlTestCase (std::string name, std::vector<EnbDlTestData> v)
117  : TestCase (name),
118  m_enbDlTestData (v)
119 {
120 }
121 
123 {
124 }
125 void
127 {
128  Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper> ();
129  Ptr<Node> pgw = epcHelper->GetPgwNode ();
130 
131  // allow jumbo packets
132  Config::SetDefault ("ns3::CsmaNetDevice::Mtu", UintegerValue (30000));
133  Config::SetDefault ("ns3::PointToPointNetDevice::Mtu", UintegerValue (30000));
134  epcHelper->SetAttribute ("S1uLinkMtu", UintegerValue (30000));
135 
136  // Create a single RemoteHost
137  NodeContainer remoteHostContainer;
138  remoteHostContainer.Create (1);
139  Ptr<Node> remoteHost = remoteHostContainer.Get (0);
140  InternetStackHelper internet;
141  internet.Install (remoteHostContainer);
142 
143  // Create the internet
144  PointToPointHelper p2ph;
145  p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("100Gb/s")));
146  NetDeviceContainer internetDevices = p2ph.Install (pgw, remoteHost);
147  Ipv4AddressHelper ipv4h;
148  ipv4h.SetBase ("1.0.0.0", "255.0.0.0");
149  ipv4h.Assign (internetDevices);
150 
151  // setup default gateway for the remote hosts
152  Ipv4StaticRoutingHelper ipv4RoutingHelper;
153  Ptr<Ipv4StaticRouting> remoteHostStaticRouting = ipv4RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv4> ());
154 
155  // hardcoded UE addresses for now
156  remoteHostStaticRouting->AddNetworkRouteTo (Ipv4Address ("7.0.0.0"), Ipv4Mask ("255.255.255.0"), 1);
157 
158 
159 
160 
161  NodeContainer enbs;
162  uint16_t cellIdCounter = 0;
163  uint64_t imsiCounter = 0;
164 
165  for (std::vector<EnbDlTestData>::iterator enbit = m_enbDlTestData.begin ();
166  enbit < m_enbDlTestData.end ();
167  ++enbit)
168  {
169  Ptr<Node> enb = CreateObject<Node> ();
170  enbs.Add (enb);
171 
172  // we test EPC without LTE, hence we use:
173  // 1) a CSMA network to simulate the cell
174  // 2) a raw socket opened on the CSMA device to simulate the LTE socket
175 
176  uint16_t cellId = ++cellIdCounter;
177 
178  NodeContainer ues;
179  ues.Create (enbit->ues.size ());
180 
181  NodeContainer cell;
182  cell.Add (ues);
183  cell.Add (enb);
184 
185  CsmaHelper csmaCell;
186  NetDeviceContainer cellDevices = csmaCell.Install (cell);
187 
188  // the eNB's CSMA NetDevice acting as an LTE NetDevice.
189  Ptr<NetDevice> enbDevice = cellDevices.Get (cellDevices.GetN () - 1);
190 
191  // Note that the EpcEnbApplication won't care of the actual NetDevice type
192  epcHelper->AddEnb (enb, enbDevice, cellId);
193 
194  // Plug test RRC entity
196  NS_ASSERT_MSG (enbApp != 0, "cannot retrieve EpcEnbApplication");
197  Ptr<EpcTestRrc> rrc = CreateObject<EpcTestRrc> ();
198  enb->AggregateObject (rrc);
199  rrc->SetS1SapProvider (enbApp->GetS1SapProvider ());
200  enbApp->SetS1SapUser (rrc->GetS1SapUser ());
201 
202  // we install the IP stack on UEs only
203  InternetStackHelper internet;
204  internet.Install (ues);
205 
206  // assign IP address to UEs, and install applications
207  for (uint32_t u = 0; u < ues.GetN (); ++u)
208  {
209  Ptr<NetDevice> ueLteDevice = cellDevices.Get (u);
210  Ipv4InterfaceContainer ueIpIface = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueLteDevice));
211 
212  Ptr<Node> ue = ues.Get (u);
213 
214  // disable IP Forwarding on the UE. This is because we use
215  // CSMA broadcast MAC addresses for this test. The problem
216  // won't happen with a LteUeNetDevice.
217  ue->GetObject<Ipv4> ()->SetAttribute ("IpForward", BooleanValue (false));
218 
219  uint16_t port = 1234;
220  PacketSinkHelper packetSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), port));
221  ApplicationContainer apps = packetSinkHelper.Install (ue);
222  apps.Start (Seconds (1.0));
223  apps.Stop (Seconds (10.0));
224  enbit->ues[u].serverApp = apps.Get (0)->GetObject<PacketSink> ();
225 
226  Time interPacketInterval = Seconds (0.01);
227  UdpEchoClientHelper client (ueIpIface.GetAddress (0), port);
228  client.SetAttribute ("MaxPackets", UintegerValue (enbit->ues[u].numPkts));
229  client.SetAttribute ("Interval", TimeValue (interPacketInterval));
230  client.SetAttribute ("PacketSize", UintegerValue (enbit->ues[u].pktSize));
231  apps = client.Install (remoteHost);
232  apps.Start (Seconds (2.0));
233  apps.Stop (Seconds (10.0));
234  enbit->ues[u].clientApp = apps.Get (0);
235 
236  uint64_t imsi = ++imsiCounter;
237  epcHelper->AddUe (ueLteDevice, imsi);
238  epcHelper->ActivateEpsBearer (ueLteDevice, imsi, EpcTft::Default (), EpsBearer (EpsBearer::NGBR_VIDEO_TCP_DEFAULT));
239  Simulator::Schedule (MilliSeconds (10),
240  &EpcEnbS1SapProvider::InitialUeMessage,
241  enbApp->GetS1SapProvider (), imsi, (uint16_t) imsi);
242  }
243 
244  }
245 
246  Simulator::Run ();
247 
248  for (std::vector<EnbDlTestData>::iterator enbit = m_enbDlTestData.begin ();
249  enbit < m_enbDlTestData.end ();
250  ++enbit)
251  {
252  for (std::vector<UeDlTestData>::iterator ueit = enbit->ues.begin ();
253  ueit < enbit->ues.end ();
254  ++ueit)
255  {
256  NS_TEST_ASSERT_MSG_EQ (ueit->serverApp->GetTotalRx (), (ueit->numPkts) * (ueit->pktSize), "wrong total received bytes");
257  }
258  }
259 
260  Simulator::Destroy ();
261 }
262 
263 
264 
265 
266 
271 {
272 public:
274 
276 
278  : TestSuite ("epc-s1u-downlink", SYSTEM)
279 {
280  std::vector<EnbDlTestData> v1;
281  EnbDlTestData e1;
282  UeDlTestData f1 (1, 100);
283  e1.ues.push_back (f1);
284  v1.push_back (e1);
285  AddTestCase (new EpcS1uDlTestCase ("1 eNB, 1UE", v1), TestCase::QUICK);
286 
287 
288  std::vector<EnbDlTestData> v2;
289  EnbDlTestData e2;
290  UeDlTestData f2_1 (1, 100);
291  e2.ues.push_back (f2_1);
292  UeDlTestData f2_2 (2, 200);
293  e2.ues.push_back (f2_2);
294  v2.push_back (e2);
295  AddTestCase (new EpcS1uDlTestCase ("1 eNB, 2UEs", v2), TestCase::QUICK);
296 
297 
298  std::vector<EnbDlTestData> v3;
299  v3.push_back (e1);
300  v3.push_back (e2);
301  AddTestCase (new EpcS1uDlTestCase ("2 eNBs", v3), TestCase::QUICK);
302 
303 
304  EnbDlTestData e3;
305  UeDlTestData f3_1 (3, 50);
306  e3.ues.push_back (f3_1);
307  UeDlTestData f3_2 (5, 1472);
308  e3.ues.push_back (f3_2);
309  UeDlTestData f3_3 (1, 1);
310  e3.ues.push_back (f3_2);
311  std::vector<EnbDlTestData> v4;
312  v4.push_back (e3);
313  v4.push_back (e1);
314  v4.push_back (e2);
315  AddTestCase (new EpcS1uDlTestCase ("3 eNBs", v4), TestCase::QUICK);
316 
317  std::vector<EnbDlTestData> v5;
318  EnbDlTestData e5;
319  UeDlTestData f5 (10, 3000);
320  e5.ues.push_back (f5);
321  v5.push_back (e5);
322  AddTestCase (new EpcS1uDlTestCase ("1 eNB, 10 pkts 3000 bytes each", v5), TestCase::QUICK);
323 
324  std::vector<EnbDlTestData> v6;
325  EnbDlTestData e6;
326  UeDlTestData f6 (50, 3000);
327  e6.ues.push_back (f6);
328  v6.push_back (e6);
329  AddTestCase (new EpcS1uDlTestCase ("1 eNB, 50 pkts 3000 bytes each", v6), TestCase::QUICK);
330 
331  std::vector<EnbDlTestData> v7;
332  EnbDlTestData e7;
333  UeDlTestData f7 (10, 15000);
334  e7.ues.push_back (f7);
335  v7.push_back (e7);
336  AddTestCase (new EpcS1uDlTestCase ("1 eNB, 10 pkts 15000 bytes each", v7), TestCase::QUICK);
337 
338  std::vector<EnbDlTestData> v8;
339  EnbDlTestData e8;
340  UeDlTestData f8 (100, 15000);
341  e8.ues.push_back (f8);
342  v8.push_back (e8);
343  AddTestCase (new EpcS1uDlTestCase ("1 eNB, 100 pkts 15000 bytes each", v8), TestCase::QUICK);
344 }
345 
holds a vector of ns3::Application pointers.
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:102
an Inet address class
AttributeValue implementation for Boolean.
Definition: boolean.h:36
std::vector< EnbDlTestData > m_enbDlTestData
ENB DL test data.
holds a vector of std::pair of Ptr<Ipv4> and interface index.
NS_ASSERT_MSG(false, "Ipv4AddressGenerator::MaskToIndex(): Impossible")
NetDeviceContainer Install(NodeContainer c)
a class to represent an Ipv4 address mask
Definition: ipv4-address.h:263
A suite of tests to run.
Definition: test.h:1343
void AggregateObject(Ptr< Object > other)
Aggregate two Objects together.
Definition: object.cc:252
Create an application which sends a UDP packet and waits for an echo of this packet.
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1078
ApplicationContainer Install(NodeContainer c) const
Install an ns3::PacketSinkApplication on each node of the input container configured with all the att...
aggregate IP/TCP/UDP functionality to existing Nodes.
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes...
uint32_t pktSize
packet size
Build a set of PointToPointNetDevice objects.
encapsulates test code
Definition: test.h:1153
void SetDeviceAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each NetDevice created by the helper.
std::vector< UeDlTestData > ues
list of data structure for different UEs
EpcS1uDlTestCase(std::string name, std::vector< EnbDlTestData > v)
Constructor.
uint16_t port
Definition: dsdv-manet.cc:45
uint32_t numPkts
number of packets
Class for representing data rates.
Definition: data-rate.h:88
void SetS1SapUser(EpcEnbS1SapUser *s)
Set the S1 SAP User.
virtual Ipv4InterfaceContainer AssignUeIpv4Address(NetDeviceContainer ueDevices)
Assign IPv4 addresses to UE devices.
Ptr< PacketSink > serverApp
Server application.
Custom structure for testing UE downlink data.
AttributeValue implementation for Time.
Definition: nstime.h:1132
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:299
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
Ptr< Application > clientApp
Client application.
Hold an unsigned integer type.
Definition: uinteger.h:44
#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:166
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.
Ptr< Application > GetApplication(uint32_t index) const
Retrieve the index-th Application associated to this node.
Definition: node.cc:168
holds a vector of ns3::NetDevice pointers
UeDlTestData(uint32_t n, uint32_t s)
Constructor.
void Start(Time start)
Arrange for all of the Applications in this container to Start() at the Time given as a parameter...
void SetS1SapProvider(EpcEnbS1SapProvider *s)
Set the S1 SAP Provider.
EpcEnbS1SapUser * GetS1SapUser()
virtual void AddEnb(Ptr< Node > enbNode, Ptr< NetDevice > lteEnbNetDevice, uint16_t cellId)
Add an eNB to the EPC.
uint32_t GetN(void) const
Get the number of Ptr<Node> stored in this container.
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:76
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:464
EpcS1uDlTestCase class.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
keep track of a set of node pointers.
EpcEnbS1SapProvider * GetS1SapProvider()
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:91
build a set of CsmaNetDevice objects
Definition: csma-helper.h:46
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
NetDeviceContainer Install(Ptr< Node > node) const
This method creates an ns3::CsmaChannel with the attributes configured by CsmaHelper::SetChannelAttri...
Definition: csma-helper.cc:218
void AddNetworkRouteTo(Ipv4Address network, Ipv4Mask networkMask, Ipv4Address nextHop, uint32_t interface, uint32_t metric=0)
Add a network route to the static routing table.
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.
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:41
void Stop(Time stop)
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter...
Ipv4InterfaceContainer Assign(const NetDeviceContainer &c)
Assign IP addresses to the net devices specified in the container based on the current network prefix...
This application is installed inside eNBs and provides the bridge functionality for user data plane p...
virtual void DoRun(void)
Implementation to actually run this TestCase.
void Add(NodeContainer other)
Append the contents of another NodeContainer to the end of this container.
Helper class that adds ns3::Ipv4StaticRouting objects.
AttributeValue implementation for DataRate.
Definition: data-rate.h:242
virtual Ptr< Node > GetPgwNode() const
Get the PGW node.
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1070
uint32_t GetN(void) const
Get the number of Ptr<NetDevice> stored in this container.
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:812
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
Custom structure for testing eNodeB downlink data, contains the list of data structures for UEs...
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
Test that the S1-U interface implementation works correctly.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
void SetAttribute(std::string name, const AttributeValue &value)
Record an attribute to be set in each Application after it is is created.
Receive and consume traffic generated to an IP address and port.
Definition: packet-sink.h:71
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:187
Ptr< Application > Get(uint32_t i) const
Get the Ptr<Application> stored in this container at a given index.
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...
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.