1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
3 * Copyright (c) 2012 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: Manuel Requena <manuel.requena@cttc.es>
19 * Nicola Baldo <nbaldo@cttc.es>
20 */
21
22 #include "ns3/config.h"
23 #include "ns3/simulator.h"
24 #include "ns3/pointer.h"
25 #include "ns3/log.h"
26 #include "ns3/packet.h"
27 #include "ns3/node-container.h"
28 #include "ns3/net-device-container.h"
29 #include "ns3/error-model.h"
30 #include "ns3/rng-seed-manager.h"
31 #include "ns3/radio-bearer-stats-calculator.h"
32 #include "ns3/lte-rlc-header.h"
33 #include "ns3/lte-rlc-um.h"
34 #include "ns3/config-store.h"
35
36 #include "lte-test-rlc-am-e2e.h"
37 #include "lte-simple-helper.h"
38 #include "lte-test-entities.h"
39
40
41 using namespace ns3;
42
43 NS_LOG_COMPONENT_DEFINE ("LteRlcAmE2eTest");
44
LteRlcAmE2eTestSuite()45 LteRlcAmE2eTestSuite::LteRlcAmE2eTestSuite ()
46 : TestSuite ("lte-rlc-am-e2e", SYSTEM)
47 {
48 // NS_LOG_INFO ("Creating LteRlcAmE2eTestSuite");
49
50 double losses[] = {0.0, 0.05, 0.10, 0.15, 0.25, 0.50, 0.75, 0.90, 0.95};
51 uint32_t runs[] = {1111, 2222, 3333, 4444, 5555, 6666, 7777, 8888, 9999, 11110,
52 12221, 13332, 14443, 15554, 16665, 17776, 18887, 19998, 21109, 22220,
53 23331, 24442, 25553, 26664, 27775, 28886, 29997, 31108, 32219, 33330};
54
55 for ( uint32_t l = 0; l < (sizeof (losses) / sizeof (double)); l++ )
56 {
57 for ( uint32_t s = 0; s < (sizeof (runs) / sizeof (uint32_t)); s++ )
58 {
59 for (uint32_t sduArrivalType = 0; sduArrivalType <= 1; ++sduArrivalType)
60 {
61 std::ostringstream name;
62 name << " losses = " << losses[l] * 100 << "%; run = " << runs[s];
63
64 bool bulkSduArrival;
65 switch (sduArrivalType)
66 {
67 case 0:
68 bulkSduArrival = false;
69 name << "; continuous SDU arrival";
70 break;
71 case 1:
72 bulkSduArrival = true;
73 name << "; bulk SDU arrival";
74 break;
75 default:
76 NS_FATAL_ERROR ("unsupported option");
77 break;
78 }
79
80 TestCase::TestDuration testDuration;
81 if (l == 1 && s == 0)
82 {
83 testDuration = TestCase::QUICK;
84 }
85 else if (s <= 4)
86 {
87 testDuration = TestCase::EXTENSIVE;
88 }
89 else
90 {
91 testDuration = TestCase::TAKES_FOREVER;
92 }
93 AddTestCase (new LteRlcAmE2eTestCase (name.str (), runs[s], losses[l], bulkSduArrival), testDuration);
94 }
95 }
96 }
97 }
98
99 static LteRlcAmE2eTestSuite lteRlcAmE2eTestSuite;
100
LteRlcAmE2eTestCase(std::string name,uint32_t run,double losses,bool bulkSduArrival)101 LteRlcAmE2eTestCase::LteRlcAmE2eTestCase (std::string name, uint32_t run, double losses, bool bulkSduArrival)
102 : TestCase (name),
103 m_run (run),
104 m_losses (losses),
105 m_bulkSduArrival (bulkSduArrival),
106 m_dlDrops (0),
107 m_ulDrops (0)
108 {
109 NS_LOG_INFO ("Creating LteRlcAmTestingTestCase: " + name);
110 }
111
~LteRlcAmE2eTestCase()112 LteRlcAmE2eTestCase::~LteRlcAmE2eTestCase ()
113 {}
114
115
116 void
DlDropEvent(Ptr<const Packet> p)117 LteRlcAmE2eTestCase::DlDropEvent (Ptr<const Packet> p)
118 {
119 // NS_LOG_FUNCTION (this);
120 m_dlDrops++;
121 }
122
123 void
UlDropEvent(Ptr<const Packet> p)124 LteRlcAmE2eTestCase::UlDropEvent (Ptr<const Packet> p)
125 {
126 // NS_LOG_FUNCTION (this);
127 m_ulDrops++;
128 }
129
130 void
DoRun(void)131 LteRlcAmE2eTestCase::DoRun (void)
132 {
133 uint16_t numberOfNodes = 1;
134
135 // LogLevel level = (LogLevel) (LOG_LEVEL_ALL | LOG_PREFIX_TIME | LOG_PREFIX_NODE | LOG_PREFIX_FUNC);
136 // LogComponentEnable ("LteRlcAmE2eTest", level);
137 // LogComponentEnable ("ErrorModel", level);
138 // LogComponentEnable ("LteSimpleHelper", level);
139 // LogComponentEnable ("LteSimpleNetDevice", level);
140 // LogComponentEnable ("SimpleNetDevice", level);
141 // LogComponentEnable ("SimpleChannel", level);
142 // LogComponentEnable ("LteTestEntities", level);
143 // LogComponentEnable ("LtePdcp", level);
144 // LogComponentEnable ("LteRlc", level);
145 // LogComponentEnable ("LteRlcUm", level);
146 // LogComponentEnable ("LteRlcAm", level);
147
148 Config::SetGlobal ("RngRun", UintegerValue (m_run));
149 Config::SetDefault ("ns3::LteRlcAm::PollRetransmitTimer", TimeValue (MilliSeconds (20)));
150 Config::SetDefault ("ns3::LteRlcAm::ReorderingTimer", TimeValue (MilliSeconds (10)));
151 Config::SetDefault ("ns3::LteRlcAm::StatusProhibitTimer", TimeValue (MilliSeconds (40)));
152 // This test was written for an unlimited transmit buffer (special value of 0)
153 Config::SetDefault ("ns3::LteRlcAm::MaxTxBufferSize", UintegerValue (0));
154
155 Ptr<LteSimpleHelper> lteSimpleHelper = CreateObject<LteSimpleHelper> ();
156 // lteSimpleHelper->EnableLogComponents ();
157 // lteSimpleHelper->EnableTraces ();
158
159 lteSimpleHelper->SetAttribute ("RlcEntity", StringValue ("RlcAm"));
160
161 // eNB and UE nodes
162 NodeContainer ueNodes;
163 NodeContainer enbNodes;
164 enbNodes.Create (numberOfNodes);
165 ueNodes.Create (numberOfNodes);
166
167 // Install LTE Devices to the nodes
168 NetDeviceContainer enbLteDevs = lteSimpleHelper->InstallEnbDevice (enbNodes);
169 NetDeviceContainer ueLteDevs = lteSimpleHelper->InstallUeDevice (ueNodes);
170
171 // Note: Just one eNB and UE is supported. Everything is done in InstallEnbDevice and InstallUeDevice
172
173 // Attach one UE per eNodeB
174 // for (uint16_t i = 0; i < numberOfNodes; i++)
175 // {
176 // lteSimpleHelper->Attach (ueLteDevs.Get(i), enbLteDevs.Get(i));
177 // }
178
179 // lteSimpleHelper->ActivateEpsBearer (ueLteDevs, EpsBearer (EpsBearer::NGBR_VIDEO_TCP_DEFAULT), EpcTft::Default ());
180
181
182 // Error models: downlink and uplink
183 Ptr<RateErrorModel> dlEm = CreateObject<RateErrorModel> ();
184 // fix the stream so that subsequent test cases get a number from the same stream
185 // if RngRun is different, the number shall then be different
186 dlEm->AssignStreams (3);
187 dlEm->SetAttribute ("ErrorRate", DoubleValue (m_losses));
188 dlEm->SetAttribute ("ErrorUnit", StringValue ("ERROR_UNIT_PACKET"));
189
190 // Ptr<RateErrorModel> ueEm = CreateObjectWithAttributes<RateErrorModel> ("RanVar", StringValue ("ns3::UniformRandomVariable[Min=0.0|Max=1.0]"));
191 // ueEm->SetAttribute ("ErrorRate", DoubleValue (m_losses));
192 // ueEm->SetAttribute ("ErrorUnit", StringValue ("ERROR_UNIT_PACKET"));
193
194 // The below hooks will cause drops and receptions to be counted
195 ueLteDevs.Get (0)->SetAttribute ("ReceiveErrorModel", PointerValue (dlEm));
196 ueLteDevs.Get (0)->TraceConnectWithoutContext ("PhyRxDrop", MakeCallback (&LteRlcAmE2eTestCase::DlDropEvent, this));
197 // enbLteDevs.Get (0)->SetAttribute ("ReceiveErrorModel", PointerValue (enbEm));
198 // enbLteDevs.Get (0)->TraceConnectWithoutContext ("PhyRxDrop", MakeCallback (&LteRlcAmE2eTestCase::EnbDropEvent, this));
199
200
201
202 uint32_t sduSizeBytes = 100;
203 uint32_t numSdu = 1000;
204 double sduStartTimeSeconds = 0.100;
205 double sduStopTimeSeconds;
206 double sduArrivalTimeSeconds;
207 uint32_t dlTxOppSizeBytes = 150;
208 double dlTxOpprTimeSeconds = 0.003;
209 uint32_t ulTxOppSizeBytes = 140;
210 double ulTxOpprTimeSeconds = 0.003;
211
212 if (m_bulkSduArrival)
213 {
214 sduStopTimeSeconds = sduStartTimeSeconds + 0.010;
215 }
216 else
217 {
218 sduStopTimeSeconds = sduStartTimeSeconds + 10;
219 }
220 sduArrivalTimeSeconds = (sduStopTimeSeconds - sduStartTimeSeconds) / numSdu;
221
222
223
224 // Sending packets from RRC layer
225 lteSimpleHelper->m_enbRrc->SetArrivalTime (Seconds (sduArrivalTimeSeconds));
226 lteSimpleHelper->m_enbRrc->SetPduSize (sduSizeBytes);
227
228 // MAC sends transmission opportunities (TxOpp)
229 lteSimpleHelper->m_enbMac->SetTxOppSize (dlTxOppSizeBytes);
230 lteSimpleHelper->m_enbMac->SetTxOppTime (Seconds (dlTxOpprTimeSeconds));
231 lteSimpleHelper->m_enbMac->SetTxOpportunityMode (LteTestMac::AUTOMATIC_MODE);
232
233 // MAC sends transmission opportunities (TxOpp)
234 lteSimpleHelper->m_ueMac->SetTxOppSize (ulTxOppSizeBytes);
235 lteSimpleHelper->m_ueMac->SetTxOppTime (Seconds (ulTxOpprTimeSeconds));
236 lteSimpleHelper->m_ueMac->SetTxOpportunityMode (LteTestMac::AUTOMATIC_MODE);
237
238 // Start/Stop pseudo-application at RRC layer
239 Simulator::Schedule (Seconds (sduStartTimeSeconds), &LteTestRrc::Start, lteSimpleHelper->m_enbRrc);
240 Simulator::Schedule (Seconds (sduStopTimeSeconds), &LteTestRrc::Stop, lteSimpleHelper->m_enbRrc);
241
242
243 double maxDlThroughput = (dlTxOppSizeBytes / (dlTxOppSizeBytes + 4.0)) * (dlTxOppSizeBytes / dlTxOpprTimeSeconds) * (1.0 - m_losses);
244 const double statusProhibitSeconds = 0.020;
245 double pollFrequency = (1.0 / dlTxOpprTimeSeconds) * (1 - m_losses);
246 double statusFrequency = std::min (pollFrequency, 1.0 / statusProhibitSeconds);
247 const uint32_t numNackSnPerStatusPdu = (ulTxOppSizeBytes * 8 - 14) / 10;
248 double maxRetxThroughput = ((double)numNackSnPerStatusPdu * (double)dlTxOppSizeBytes) * statusFrequency;
249 double throughput = std::min (maxDlThroughput, maxRetxThroughput);
250 double totBytes = ((sduSizeBytes) * (sduStopTimeSeconds - sduStartTimeSeconds) / sduArrivalTimeSeconds);
251
252
253 // note: the throughput estimation is valid only for the full buffer
254 // case. However, the test sends a finite number of SDUs. Hence, the
255 // estimated throughput will only be effective at the beginning of
256 // the test. Towards the end of the test, two issues are present:
257 // 1) no new data is transmitted, hence less feedback is sent,
258 // hence the transmission rate for the last PDUs to be
259 // retransmitted is much lower. This effect can be best noteed
260 // at very high loss rates, and can be adjusted by timers and
261 // params.
262 // 2) throuhgput is not meaningful, you need to evaluate the time
263 // it takes for all PDUs to be (re)transmitted successfully,
264 // i.e., how long it takes for the TX and reTX queues to deplete.
265
266 // Estimating correctly this effect would require a complex stateful
267 // model (e.g., a Markov chain model) so to avoid the hassle we just
268 // use a margin here which we empirically determine as something we
269 // think reasonable based on the PDU loss rate
270 Time margin;
271 if (m_losses < 0.07)
272 {
273 margin = Seconds (0.500);
274 }
275 else if (m_losses < 0.20)
276 {
277 margin = Seconds (1);
278 }
279 else if (m_losses < 0.50)
280 {
281 margin = Seconds (2);
282 }
283 else if (m_losses < 0.70)
284 {
285 margin = Seconds (10);
286 }
287 else if (m_losses < 0.91)
288 {
289 margin = Seconds (20);
290 }
291 else // 0.95
292 {
293 margin = Seconds (30);
294 }
295 Time stopTime = Seconds (std::max (sduStartTimeSeconds + totBytes / throughput, sduStopTimeSeconds)) + margin;
296
297 NS_LOG_INFO ("statusFrequency=" << statusFrequency << ", maxDlThroughput=" << maxDlThroughput << ", maxRetxThroughput=" << maxRetxThroughput << ", totBytes=" << totBytes << ", stopTime=" << stopTime.As (Time::S));
298
299 Simulator::Stop (stopTime);
300 Simulator::Run ();
301
302 uint32_t txEnbRrcPdus = lteSimpleHelper->m_enbRrc->GetTxPdus ();
303 uint32_t rxUeRrcPdus = lteSimpleHelper->m_ueRrc->GetRxPdus ();
304
305 uint32_t txEnbRlcPdus = lteSimpleHelper->m_enbMac->GetTxPdus ();
306 uint32_t rxUeRlcPdus = lteSimpleHelper->m_ueMac->GetRxPdus ();
307
308 NS_LOG_INFO ("Run = " << m_run);
309 NS_LOG_INFO ("Loss rate (%) = " << uint32_t (m_losses * 100));
310
311
312 NS_LOG_INFO ("RLC PDUs TX: " << txEnbRlcPdus
313 << " RX: " << rxUeRlcPdus
314 << " LOST: " << m_dlDrops
315 << " (" << (100.0 * (double) m_dlDrops) / txEnbRlcPdus << "%)");
316
317 NS_TEST_ASSERT_MSG_EQ (txEnbRlcPdus, rxUeRlcPdus + m_dlDrops, "lost RLC PDUs don't match TX + RX");
318
319 NS_LOG_INFO ("eNB tx RRC count = " << txEnbRrcPdus);
320 NS_LOG_INFO ("UE rx RRC count = " << rxUeRrcPdus);
321
322
323 NS_TEST_ASSERT_MSG_EQ (txEnbRrcPdus, rxUeRrcPdus,
324 "TX PDUs (" << txEnbRrcPdus << ") != RX PDUs (" << rxUeRrcPdus << ")");
325
326 Simulator::Destroy ();
327 }
328