A Discrete-Event Network Simulator
API
lte-test-mimo.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: Marco Miozzo <marco.miozzo@cttc.es>
19 */
20
21#include <iostream>
22#include <sstream>
23#include <string>
24#include <ns3/object.h>
25#include <ns3/spectrum-interference.h>
26#include <ns3/spectrum-error-model.h>
27#include <ns3/log.h>
28#include <ns3/test.h>
29#include <ns3/simulator.h>
30#include <ns3/packet.h>
31#include <ns3/ptr.h>
32#include "ns3/radio-bearer-stats-calculator.h"
33#include <ns3/mobility-building-info.h>
34#include <ns3/buildings-propagation-loss-model.h>
35#include <ns3/eps-bearer.h>
36#include <ns3/node-container.h>
37#include <ns3/mobility-helper.h>
38#include <ns3/net-device-container.h>
39#include <ns3/lte-ue-net-device.h>
40#include <ns3/lte-enb-net-device.h>
41#include <ns3/lte-ue-rrc.h>
42#include <ns3/lte-helper.h>
43#include "ns3/string.h"
44#include "ns3/double.h"
45#include <ns3/lte-enb-phy.h>
46#include <ns3/lte-ue-phy.h>
47#include <ns3/boolean.h>
48#include <ns3/rr-ff-mac-scheduler.h>
49#include <ns3/pf-ff-mac-scheduler.h>
50#include <ns3/pointer.h>
51#include <ns3/enum.h>
52#include <ns3/buildings-helper.h>
53#include "lte-test-mimo.h"
54
55
56using namespace ns3;
57
58NS_LOG_COMPONENT_DEFINE ("LteTestMimo");
59
61 : TestSuite ("lte-mimo", SYSTEM)
62{
63 NS_LOG_INFO ("creating LenaMimoTestCase");
64
65 // RR DOWNLINK- DISTANCE 300
66 // interval 1 : [0.1, 0.2) sec TxMode 0: MCS 20 -> TB size 1191 bytes
67 // interval 2 : [0.3, 0.4) sec TxMode 1: MCS 26 -> TB size 1836 bytes
68 // interval 3 : [0.5, 0.6) sec TxMode 2: MCS 18 -> TB size 967 bytes (x2 layers)
69 // -->
70 std::vector<uint32_t> estThrDl;
71 estThrDl.push_back (119100); // interval 1 : estimated throughput for TxMode 1
72 estThrDl.push_back (183600); // interval 2 : estimated throughput for TxMode 2
73 estThrDl.push_back (193400); // interval 3 : estimated throughput for TxMode 3
74 AddTestCase (new LenaMimoTestCase(300, estThrDl, "ns3::RrFfMacScheduler", true), TestCase::QUICK);
75 AddTestCase (new LenaMimoTestCase(300, estThrDl, "ns3::PfFfMacScheduler", true), TestCase::QUICK);
76 AddTestCase (new LenaMimoTestCase(300, estThrDl, "ns3::RrFfMacScheduler", false), TestCase::QUICK);
77 AddTestCase (new LenaMimoTestCase(300, estThrDl, "ns3::PfFfMacScheduler", false), TestCase::QUICK);
78
79}
80
82
83std::string
84LenaMimoTestCase::BuildNameString (uint16_t dist, std::string schedulerType, bool useIdealRrc)
85{
86 std::ostringstream oss;
87 oss << " UE distance " << dist << " m" << " Scheduler " << schedulerType;
88 if (useIdealRrc)
89 {
90 oss << ", ideal RRC";
91 }
92 else
93 {
94 oss << ", real RRC";
95 }
96 return oss.str ();
97}
98
99LenaMimoTestCase::LenaMimoTestCase (uint16_t dist, std::vector<uint32_t> estThrDl, std::string schedulerType, bool useIdealRrc)
100 : TestCase (BuildNameString (dist, schedulerType, useIdealRrc)),
101 m_dist (dist),
102 m_estThrDl (estThrDl),
103 m_schedulerType (schedulerType),
104 m_useIdealRrc (useIdealRrc)
105{
106}
107
109{
110}
111
112void
114{
115 NS_LOG_FUNCTION (this << GetName ());
116 Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false));
117 Config::SetDefault ("ns3::LteAmc::AmcModel", EnumValue (LteAmc::PiroEW2010));
118 Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (m_useIdealRrc));
119 Config::SetDefault ("ns3::MacStatsCalculator::DlOutputFilename", StringValue (CreateTempDirFilename ("DlMacStats.txt")));
120 Config::SetDefault ("ns3::MacStatsCalculator::UlOutputFilename", StringValue (CreateTempDirFilename ("UlMacStats.txt")));
121 Config::SetDefault ("ns3::RadioBearerStatsCalculator::DlRlcOutputFilename", StringValue (CreateTempDirFilename ("DlRlcStats.txt")));
122 Config::SetDefault ("ns3::RadioBearerStatsCalculator::UlRlcOutputFilename", StringValue (CreateTempDirFilename ("UlRlcStats.txt")));
123
124 //Disable Uplink Power Control
125 Config::SetDefault ("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue (false));
126
132 Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
133 Config::SetDefault ("ns3::RrFfMacScheduler::HarqEnabled", BooleanValue (false));
134 Config::SetDefault ("ns3::PfFfMacScheduler::HarqEnabled", BooleanValue (false));
135
136// lteHelper->SetSchedulerAttribute ("HarqEnabled", BooleanValue (false));
137
138
139 lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::HybridBuildingsPropagationLossModel"));
140 lteHelper->SetPathlossModelAttribute ("ShadowSigmaOutdoor", DoubleValue (0.0));
141 lteHelper->SetPathlossModelAttribute ("ShadowSigmaIndoor", DoubleValue (0.0));
142 lteHelper->SetPathlossModelAttribute ("ShadowSigmaExtWalls", DoubleValue (0.0));
143
144// lteHelper->EnableLogComponents ();
145
146 // Create Nodes: eNodeB and UE
147 NodeContainer enbNodes;
148 NodeContainer ueNodes;
149 enbNodes.Create (1);
150 ueNodes.Create (1);
151
152 // Install Mobility Model
154 mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
155 mobility.Install (enbNodes);
156 BuildingsHelper::Install (enbNodes);
157 mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
158 mobility.Install (ueNodes);
159 BuildingsHelper::Install (ueNodes);
160
161 // Create Devices and install them in the Nodes (eNB and UE)
162 NetDeviceContainer enbDevs;
163 NetDeviceContainer ueDevs;
165 enbDevs = lteHelper->InstallEnbDevice (enbNodes);
166 ueDevs = lteHelper->InstallUeDevice (ueNodes);
167
168 // Attach a UE to a eNB
169 lteHelper->Attach (ueDevs, enbDevs.Get (0));
170
171 // Activate an EPS bearer
172 enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
173 EpsBearer bearer (q);
174 lteHelper->ActivateDataRadioBearer (ueDevs, bearer);
175
176
177 Ptr<LteEnbNetDevice> lteEnbDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();
178 Ptr<LteEnbPhy> enbPhy = lteEnbDev->GetPhy ();
179 enbPhy->SetAttribute ("TxPower", DoubleValue (46.0));
180 enbPhy->SetAttribute ("NoiseFigure", DoubleValue (5.0));
181 Ptr<MobilityModel> mmenb = enbNodes.Get (0)->GetObject<MobilityModel> ();
182 mmenb->SetPosition (Vector (0.0, 0.0, 30.0));
183
184 // Set UE's position and power
185 Ptr<MobilityModel> mmue = ueNodes.Get (0)->GetObject<MobilityModel> ();
186 mmue->SetPosition (Vector (m_dist, 0.0, 1.0));
187 Ptr<LteUeNetDevice> lteUeDev = ueDevs.Get (0)->GetObject<LteUeNetDevice> ();
188 Ptr<LteUePhy> uePhy = lteUeDev->GetPhy ();
189 uePhy->SetAttribute ("TxPower", DoubleValue (23.0));
190 uePhy->SetAttribute ("NoiseFigure", DoubleValue (9.0));
191
192 // need to allow for RRC connection establishment + SRS before enabling traces
193 lteHelper->EnableRlcTraces ();
194 lteHelper->EnableMacTraces ();
195 double simulationTime = 0.6;
196 double tolerance = 0.1;
197
198 uint8_t rnti = 1;
199 Ptr<LteEnbNetDevice> enbNetDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();
200
201 PointerValue ptrval;
202 enbNetDev->GetCcMap()[0]->GetAttribute ("FfMacScheduler", ptrval);
203 Ptr<PfFfMacScheduler> pfsched;
204 Ptr<RrFfMacScheduler> rrsched;
205 if (m_schedulerType.compare ("ns3::RrFfMacScheduler") == 0)
206 {
207 rrsched = ptrval.Get<RrFfMacScheduler> ();
208 if (!rrsched)
209 {
210 NS_FATAL_ERROR ("No RR Scheduler available");
211 }
212 Simulator::Schedule (Seconds (0.2), &RrFfMacScheduler::TransmissionModeConfigurationUpdate, rrsched, rnti, 1);
213 Simulator::Schedule (Seconds (0.4), &RrFfMacScheduler::TransmissionModeConfigurationUpdate, rrsched, rnti, 2);
214 }
215 else if (m_schedulerType.compare ("ns3::PfFfMacScheduler") == 0)
216 {
217 pfsched = ptrval.Get<PfFfMacScheduler> ();
218 if (!pfsched)
219 {
220 NS_FATAL_ERROR ("No Pf Scheduler available");
221 }
222
223 Simulator::Schedule (Seconds (0.2), &PfFfMacScheduler::TransmissionModeConfigurationUpdate, pfsched, rnti, 1);
224 Simulator::Schedule (Seconds (0.4), &PfFfMacScheduler::TransmissionModeConfigurationUpdate, pfsched, rnti, 2);
225 }
226 else
227 {
228 NS_FATAL_ERROR ("Scheduler not supported by this test");
229 }
230
231
232 Ptr<RadioBearerStatsCalculator> rlcStats = lteHelper->GetRlcStats ();
233 rlcStats->SetAttribute ("EpochDuration", TimeValue (Seconds (0.1)));
234
235 NS_LOG_INFO (m_schedulerType << " MIMO test:");
236 double sampleTime = 0.199999; // at 0.2 RlcStats are reset
237 for (uint8_t j = 0; j < m_estThrDl.size (); j ++)
238 {
239 NS_LOG_INFO ("\t test with user at distance " << m_dist << " time " << sampleTime);
240 // get the imsi
241 uint64_t imsi = ueDevs.Get (0)->GetObject<LteUeNetDevice> ()->GetImsi ();
242 uint8_t lcId = 3;
243 Time t = Seconds (sampleTime);
244 Simulator::Schedule(t, &LenaMimoTestCase::GetRlcBufferSample, this, rlcStats, imsi, lcId);
245 sampleTime += 0.2;
246 }
247 Simulator::Stop (Seconds (simulationTime));
249 Simulator::Destroy ();
250
251 NS_LOG_INFO ("Check consistency");
252 for (uint8_t i = 0; i < m_estThrDl.size (); i++)
253 {
254 NS_LOG_INFO ("interval " << i + 1 << ": bytes rxed " << (double)m_dlDataRxed.at (i) << " ref " << m_estThrDl.at (i));
255 NS_TEST_ASSERT_MSG_EQ_TOL ((double)m_dlDataRxed.at (i) , m_estThrDl.at (i), m_estThrDl.at (i) * tolerance, " Unfair Throughput!");
256 }
257
258}
259
260
261void
263{
264 m_dlDataRxed.push_back (rlcStats->GetDlRxData (imsi, lcId));
265 NS_LOG_INFO (Simulator::Now () << "\t get bytes " << m_dlDataRxed.at (m_dlDataRxed.size () - 1));
266}
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.
This system test program creates different test cases with a single eNB and single UE.
Definition: lte-test-mimo.h:41
void GetRlcBufferSample(Ptr< RadioBearerStatsCalculator > rlcStats, uint64_t imsi, uint8_t rnti)
Get RLC buffer sample.
std::string m_schedulerType
the scheduler type
Definition: lte-test-mimo.h:75
LenaMimoTestCase(uint16_t dist, std::vector< uint32_t > estThrDl, std::string schedulerType, bool useIdealRrc)
Constructor.
virtual void DoRun(void)
Implementation to actually run this TestCase.
bool m_useIdealRrc
whether to use the ideal RRC
Definition: lte-test-mimo.h:76
std::vector< uint64_t > m_dlDataRxed
DL data received.
Definition: lte-test-mimo.h:78
std::vector< uint32_t > m_estThrDl
estimated throughput DL
Definition: lte-test-mimo.h:74
virtual ~LenaMimoTestCase()
uint16_t m_dist
the distance
Definition: lte-test-mimo.h:73
static std::string BuildNameString(uint16_t dist, std::string schedulerType, bool useIdealRrc)
Builds the test name string based on provided parameter values.
Lena Test Mimo Suite.
Definition: lte-test-mimo.h:91
AttributeValue implementation for Boolean.
Definition: boolean.h:37
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:41
Hold variables of type enum.
Definition: enum.h:55
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:92
Qci
QoS Class Indicator.
Definition: eps-bearer.h:107
The eNodeB device implementation.
Ptr< LteEnbPhy > GetPhy(void) const
std::map< uint8_t, Ptr< ComponentCarrierBaseStation > > GetCcMap(void) const
NetDeviceContainer InstallEnbDevice(NodeContainer c)
Create a set of eNodeB devices.
Definition: lte-helper.cc:474
Ptr< RadioBearerStatsCalculator > GetRlcStats(void)
Definition: lte-helper.cc:1576
void SetSchedulerType(std::string type)
Set the type of scheduler to be used by eNodeB devices.
Definition: lte-helper.cc:279
void Attach(NetDeviceContainer ueDevices)
Enables automatic attachment of a set of UE devices to a suitable cell using Idle mode initial cell s...
Definition: lte-helper.cc:959
void SetPathlossModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the path loss models to be created.
Definition: lte-helper.cc:393
void EnableRlcTraces(void)
Enable trace sinks for RLC layer.
Definition: lte-helper.cc:1435
void ActivateDataRadioBearer(NetDeviceContainer ueDevices, EpsBearer bearer)
Activate a Data Radio Bearer on a given UE devices (for LTE-only simulation).
Definition: lte-helper.cc:1313
NetDeviceContainer InstallUeDevice(NodeContainer c)
Create a set of UE devices.
Definition: lte-helper.cc:489
void EnableMacTraces(void)
Enable trace sinks for MAC layer.
Definition: lte-helper.cc:1533
The LteUeNetDevice class implements the UE net device.
Helper class used to assign positions and mobility models to nodes.
Keep track of the current position and velocity of an object.
void SetPosition(const Vector &position)
holds a vector of ns3::NetDevice pointers
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
keep track of a set of node pointers.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
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
Implements the SCHED SAP and CSCHED SAP for a Proportional Fair scheduler.
Hold objects of type Ptr<T>.
Definition: pointer.h:37
Implements the SCHED SAP and CSCHED SAP for a Round Robin scheduler.
Hold variables of type string.
Definition: string.h:41
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
std::string CreateTempDirFilename(std::string filename)
Construct the full path to a file in a temporary directory.
Definition: test.cc:430
std::string GetName(void) const
Definition: test.cc:370
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
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:849
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:165
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:206
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
#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_TOL(actual, limit, tol, msg)
Test that actual and expected (limit) values are equal to plus or minus some tolerance and report and...
Definition: test.h:323
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1245
static LenaTestMimoSuite lenaTestMimoSuite
Every class exported by the ns3 library is enclosed in the ns3 namespace.
mobility
Definition: third.py:98