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 
164  for (std::vector<EnbDlTestData>::iterator enbit = m_enbDlTestData.begin ();
165  enbit < m_enbDlTestData.end ();
166  ++enbit)
167  {
168  Ptr<Node> enb = CreateObject<Node> ();
169  enbs.Add (enb);
170 
171  // we test EPC without LTE, hence we use:
172  // 1) a CSMA network to simulate the cell
173  // 2) a raw socket opened on the CSMA device to simulate the LTE socket
174 
175  uint16_t cellId = ++cellIdCounter;
176 
177  NodeContainer ues;
178  ues.Create (enbit->ues.size ());
179 
180  NodeContainer cell;
181  cell.Add (ues);
182  cell.Add (enb);
183 
184  CsmaHelper csmaCell;
185  NetDeviceContainer cellDevices = csmaCell.Install (cell);
186 
187  // the eNB's CSMA NetDevice acting as an LTE NetDevice.
188  Ptr<NetDevice> enbDevice = cellDevices.Get (cellDevices.GetN () - 1);
189 
190  // Note that the EpcEnbApplication won't care of the actual NetDevice type
191  epcHelper->AddEnb (enb, enbDevice, cellId);
192 
193  // Plug test RRC entity
195  NS_ASSERT_MSG (enbApp != 0, "cannot retrieve EpcEnbApplication");
196  Ptr<EpcTestRrc> rrc = CreateObject<EpcTestRrc> ();
197  rrc->SetS1SapProvider (enbApp->GetS1SapProvider ());
198  enbApp->SetS1SapUser (rrc->GetS1SapUser ());
199 
200  // we install the IP stack on UEs only
201  InternetStackHelper internet;
202  internet.Install (ues);
203 
204  // assign IP address to UEs, and install applications
205  for (uint32_t u = 0; u < ues.GetN (); ++u)
206  {
207  Ptr<NetDevice> ueLteDevice = cellDevices.Get (u);
208  Ipv4InterfaceContainer ueIpIface = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueLteDevice));
209 
210  Ptr<Node> ue = ues.Get (u);
211 
212  // disable IP Forwarding on the UE. This is because we use
213  // CSMA broadcast MAC addresses for this test. The problem
214  // won't happen with a LteUeNetDevice.
215  ue->GetObject<Ipv4> ()->SetAttribute ("IpForward", BooleanValue (false));
216 
217  uint16_t port = 1234;
218  PacketSinkHelper packetSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), port));
219  ApplicationContainer apps = packetSinkHelper.Install (ue);
220  apps.Start (Seconds (1.0));
221  apps.Stop (Seconds (10.0));
222  enbit->ues[u].serverApp = apps.Get (0)->GetObject<PacketSink> ();
223 
224  Time interPacketInterval = Seconds (0.01);
225  UdpEchoClientHelper client (ueIpIface.GetAddress (0), port);
226  client.SetAttribute ("MaxPackets", UintegerValue (enbit->ues[u].numPkts));
227  client.SetAttribute ("Interval", TimeValue (interPacketInterval));
228  client.SetAttribute ("PacketSize", UintegerValue (enbit->ues[u].pktSize));
229  apps = client.Install (remoteHost);
230  apps.Start (Seconds (2.0));
231  apps.Stop (Seconds (10.0));
232  enbit->ues[u].clientApp = apps.Get (0);
233 
234  uint64_t imsi = u+1;
235  epcHelper->AddUe (ueLteDevice, imsi);
236  epcHelper->ActivateEpsBearer (ueLteDevice, imsi, EpcTft::Default (), EpsBearer (EpsBearer::NGBR_VIDEO_TCP_DEFAULT));
237  enbApp->GetS1SapProvider ()->InitialUeMessage (imsi, (uint16_t) imsi);
238  }
239 
240  }
241 
242  Simulator::Run ();
243 
244  for (std::vector<EnbDlTestData>::iterator enbit = m_enbDlTestData.begin ();
245  enbit < m_enbDlTestData.end ();
246  ++enbit)
247  {
248  for (std::vector<UeDlTestData>::iterator ueit = enbit->ues.begin ();
249  ueit < enbit->ues.end ();
250  ++ueit)
251  {
252  NS_TEST_ASSERT_MSG_EQ (ueit->serverApp->GetTotalRx (), (ueit->numPkts) * (ueit->pktSize), "wrong total received bytes");
253  }
254  }
255 
256  Simulator::Destroy ();
257 }
258 
259 
260 
261 
262 
267 {
268 public:
270 
272 
274  : TestSuite ("epc-s1u-downlink", SYSTEM)
275 {
276  std::vector<EnbDlTestData> v1;
277  EnbDlTestData e1;
278  UeDlTestData f1 (1, 100);
279  e1.ues.push_back (f1);
280  v1.push_back (e1);
281  AddTestCase (new EpcS1uDlTestCase ("1 eNB, 1UE", v1), TestCase::QUICK);
282 
283 
284  std::vector<EnbDlTestData> v2;
285  EnbDlTestData e2;
286  UeDlTestData f2_1 (1, 100);
287  e2.ues.push_back (f2_1);
288  UeDlTestData f2_2 (2, 200);
289  e2.ues.push_back (f2_2);
290  v2.push_back (e2);
291  AddTestCase (new EpcS1uDlTestCase ("1 eNB, 2UEs", v2), TestCase::QUICK);
292 
293 
294  std::vector<EnbDlTestData> v3;
295  v3.push_back (e1);
296  v3.push_back (e2);
297  AddTestCase (new EpcS1uDlTestCase ("2 eNBs", v3), TestCase::QUICK);
298 
299 
300  EnbDlTestData e3;
301  UeDlTestData f3_1 (3, 50);
302  e3.ues.push_back (f3_1);
303  UeDlTestData f3_2 (5, 1472);
304  e3.ues.push_back (f3_2);
305  UeDlTestData f3_3 (1, 1);
306  e3.ues.push_back (f3_2);
307  std::vector<EnbDlTestData> v4;
308  v4.push_back (e3);
309  v4.push_back (e1);
310  v4.push_back (e2);
311  AddTestCase (new EpcS1uDlTestCase ("3 eNBs", v4), TestCase::QUICK);
312 
313  std::vector<EnbDlTestData> v5;
314  EnbDlTestData e5;
315  UeDlTestData f5 (10, 3000);
316  e5.ues.push_back (f5);
317  v5.push_back (e5);
318  AddTestCase (new EpcS1uDlTestCase ("1 eNB, 10 pkts 3000 bytes each", v5), TestCase::QUICK);
319 
320  std::vector<EnbDlTestData> v6;
321  EnbDlTestData e6;
322  UeDlTestData f6 (50, 3000);
323  e6.ues.push_back (f6);
324  v6.push_back (e6);
325  AddTestCase (new EpcS1uDlTestCase ("1 eNB, 50 pkts 3000 bytes each", v6), TestCase::QUICK);
326 
327  std::vector<EnbDlTestData> v7;
328  EnbDlTestData e7;
329  UeDlTestData f7 (10, 15000);
330  e7.ues.push_back (f7);
331  v7.push_back (e7);
332  AddTestCase (new EpcS1uDlTestCase ("1 eNB, 10 pkts 15000 bytes each", v7), TestCase::QUICK);
333 
334  std::vector<EnbDlTestData> v8;
335  EnbDlTestData e8;
336  UeDlTestData f8 (100, 15000);
337  e8.ues.push_back (f8);
338  v8.push_back (e8);
339  AddTestCase (new EpcS1uDlTestCase ("1 eNB, 100 pkts 15000 bytes each", v8), TestCase::QUICK);
340 }
341 
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:258
A suite of tests to run.
Definition: test.h:1342
Create an application which sends a UDP packet and waits for an echo of this packet.
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.
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
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:1155
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.
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:71
Ptr< PacketSink > serverApp
Server application.
Custom structure for testing UE downlink data.
AttributeValue implementation for Time.
Definition: nstime.h:1076
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.
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:168
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:459
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()
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:217
virtual Ipv4InterfaceContainer AssignUeIpv4Address(NetDeviceContainer ueDevices)
Assign IPv4 addresses to UE devices.
virtual void InitialUeMessage(uint64_t imsi, uint16_t rnti)=0
void AddNetworkRouteTo(Ipv4Address network, Ipv4Mask networkMask, Ipv4Address nextHop, uint32_t interface, uint32_t metric=0)
Add a network route to the static routing table.
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:40
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
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1014
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:782
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:68
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:185
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.