A Discrete-Event Network Simulator
API
bs-scheduler-rtps.cc
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2007,2008 INRIA
3  * 2009 TELEMATICS LAB, Politecnico di Bari
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: Giuseppe Piro <g.piro@poliba.it>
19  */
20 
21 #include "bs-scheduler-rtps.h"
22 
23 #include "bs-net-device.h"
24 #include "burst-profile-manager.h"
25 #include "cid.h"
26 #include "connection-manager.h"
27 #include "service-flow-manager.h"
28 #include "service-flow-record.h"
29 #include "service-flow.h"
30 #include "ss-manager.h"
31 #include "ss-record.h"
32 #include "wimax-connection.h"
33 #include "wimax-mac-header.h"
34 #include "wimax-mac-queue.h"
35 
36 #include "ns3/log.h"
37 #include "ns3/packet-burst.h"
38 #include "ns3/simulator.h"
39 
40 namespace ns3
41 {
42 
43 NS_LOG_COMPONENT_DEFINE("BSSchedulerRtps");
44 
45 NS_OBJECT_ENSURE_REGISTERED(BSSchedulerRtps);
46 
47 TypeId
48 BSSchedulerRtps::GetTypeId()
49 {
50  static TypeId tid = TypeId("ns3::BSSchedulerRtps")
51  .SetParent<BSScheduler>()
52  .SetGroupName("Wimax")
53  .AddConstructor<BSSchedulerRtps>();
54  return tid;
55 }
56 
57 BSSchedulerRtps::BSSchedulerRtps()
58  : m_downlinkBursts(new std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst>>>())
59 {
60  SetBs(nullptr);
61 }
62 
63 BSSchedulerRtps::BSSchedulerRtps(Ptr<BaseStationNetDevice> bs)
64  : m_downlinkBursts(new std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst>>>())
65 {
66  // m_downlinkBursts is filled by AddDownlinkBurst and emptied by
67  // wimax-bs-net-device::sendBurst and wimax-ss-net-device::sendBurst
68  SetBs(bs);
69 }
70 
71 BSSchedulerRtps::~BSSchedulerRtps()
72 {
73  std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst>>>* downlinkBursts = m_downlinkBursts;
74  std::pair<OfdmDlMapIe*, Ptr<PacketBurst>> pair;
75  while (!downlinkBursts->empty())
76  {
77  pair = downlinkBursts->front();
78  pair.second = nullptr;
79  delete pair.first;
80  }
81 
82  SetBs(nullptr);
83  delete m_downlinkBursts;
84  m_downlinkBursts = nullptr;
85 }
86 
87 std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst>>>*
88 BSSchedulerRtps::GetDownlinkBursts() const
89 {
90  return m_downlinkBursts;
91 }
92 
93 void
94 BSSchedulerRtps::AddDownlinkBurst(Ptr<const WimaxConnection> connection,
95  uint8_t diuc,
96  WimaxPhy::ModulationType modulationType,
97  Ptr<PacketBurst> burst)
98 {
99  OfdmDlMapIe* dlMapIe = new OfdmDlMapIe();
100  dlMapIe->SetCid(connection->GetCid());
101  dlMapIe->SetDiuc(diuc);
102 
103  NS_LOG_INFO("BS scheduler, burst size: " << burst->GetSize() << " bytes"
104  << ", pkts: " << burst->GetNPackets()
105  << ", connection: " << connection->GetTypeStr()
106  << ", CID: " << connection->GetCid());
107  if (connection->GetType() == Cid::TRANSPORT)
108  {
109  NS_LOG_INFO(", SFID: " << connection->GetServiceFlow()->GetSfid() << ", service: "
110  << connection->GetServiceFlow()->GetSchedulingTypeStr());
111  }
112  NS_LOG_INFO(", modulation: " << modulationType << ", DIUC: " << (uint32_t)diuc);
113 
114  m_downlinkBursts->push_back(std::make_pair(dlMapIe, burst));
115 }
116 
131 void
132 BSSchedulerRtps::Schedule()
133 {
134  uint32_t availableSymbols = GetBs()->GetNrDlSymbols();
135 
136  BSSchedulerBroadcastConnection(availableSymbols);
137 
138  BSSchedulerInitialRangingConnection(availableSymbols);
139 
140  BSSchedulerBasicConnection(availableSymbols);
141 
142  BSSchedulerPrimaryConnection(availableSymbols);
143 
144  BSSchedulerUGSConnection(availableSymbols);
145 
146  BSSchedulerRTPSConnection(availableSymbols);
147 
148  BSSchedulerNRTPSConnection(availableSymbols);
149 
150  BSSchedulerBEConnection(availableSymbols);
151 
152  if (!m_downlinkBursts->empty())
153  {
154  NS_LOG_DEBUG(
155  "BS scheduler, number of bursts: "
156  << m_downlinkBursts->size() << ", symbols left: " << availableSymbols << std::endl
157  << "BS scheduler, queues:"
158  << " IR " << GetBs()->GetInitialRangingConnection()->GetQueue()->GetSize()
159  << " broadcast " << GetBs()->GetBroadcastConnection()->GetQueue()->GetSize()
160  << " basic "
161  << GetBs()->GetConnectionManager()->GetNPackets(Cid::BASIC, ServiceFlow::SF_TYPE_NONE)
162  << " primary "
163  << GetBs()->GetConnectionManager()->GetNPackets(Cid::PRIMARY, ServiceFlow::SF_TYPE_NONE)
164  << " transport "
165  << GetBs()->GetConnectionManager()->GetNPackets(Cid::TRANSPORT,
166  ServiceFlow::SF_TYPE_ALL));
167  }
168 }
169 
170 Ptr<PacketBurst>
171 BSSchedulerRtps::CreateUgsBurst(ServiceFlow* serviceFlow,
172  WimaxPhy::ModulationType modulationType,
173  uint32_t availableSymbols)
174 {
175  Time timeStamp;
176  GenericMacHeader hdr;
177  Ptr<Packet> packet;
178  Ptr<PacketBurst> burst = Create<PacketBurst>();
179  uint32_t nrSymbolsRequired = 0;
180 
181  // serviceFlow->CleanUpQueue ();
182  Ptr<WimaxConnection> connection = serviceFlow->GetConnection();
183  while (serviceFlow->HasPackets())
184  {
185  uint32_t FirstPacketSize =
186  connection->GetQueue()->GetFirstPacketRequiredByte(MacHeaderType::HEADER_TYPE_GENERIC);
187  nrSymbolsRequired = GetBs()->GetPhy()->GetNrSymbols(FirstPacketSize, modulationType);
188  if (availableSymbols < nrSymbolsRequired &&
189  CheckForFragmentation(connection, availableSymbols, modulationType))
190  {
191  uint32_t availableByte =
192  GetBs()->GetPhy()->GetNrBytes(availableSymbols, modulationType);
193  packet = connection->Dequeue(MacHeaderType::HEADER_TYPE_GENERIC, availableByte);
194  availableSymbols = 0;
195  }
196  else
197  {
198  packet = connection->Dequeue();
199  availableSymbols -= nrSymbolsRequired;
200  }
201  burst->AddPacket(packet);
202  if (availableSymbols <= 0)
203  {
204  break;
205  }
206  }
207  return burst;
208 }
209 
210 bool
211 BSSchedulerRtps::SelectConnection(Ptr<WimaxConnection>& connection)
212 {
213  return false;
214 }
215 
216 void
217 BSSchedulerRtps::BSSchedulerBroadcastConnection(uint32_t& availableSymbols)
218 {
219  Ptr<WimaxConnection> connection;
220  WimaxPhy::ModulationType modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
221  uint8_t diuc = OfdmDlBurstProfile::DIUC_BURST_PROFILE_1;
222  uint32_t nrSymbolsRequired = 0;
223  GenericMacHeader hdr;
224  Ptr<Packet> packet;
225  Ptr<PacketBurst> burst = Create<PacketBurst>();
226 
227  while (GetBs()->GetBroadcastConnection()->HasPackets() && availableSymbols > 0)
228  {
229  connection = GetBs()->GetBroadcastConnection();
230 
231  packet = connection->GetQueue()->Peek(hdr);
232  nrSymbolsRequired = GetBs()->GetPhy()->GetNrSymbols(packet->GetSize(), modulationType);
233 
234  if (availableSymbols < nrSymbolsRequired &&
235  !CheckForFragmentation(connection, availableSymbols, modulationType))
236  {
237  break;
238  }
239  else if (availableSymbols < nrSymbolsRequired &&
240  CheckForFragmentation(connection, availableSymbols, modulationType))
241  {
242  uint32_t availableByte =
243  GetBs()->GetPhy()->GetNrBytes(availableSymbols, modulationType);
244  packet = connection->Dequeue(MacHeaderType::HEADER_TYPE_GENERIC, availableByte);
245  }
246  else
247  {
248  packet = connection->Dequeue();
249  }
250 
251  NS_ASSERT_MSG(hdr.GetCid().GetIdentifier() == connection->GetCid(),
252  "Base station: Error while scheduling broadcast connection: header CID != "
253  "connection CID");
254  burst->AddPacket(packet);
255  availableSymbols -= nrSymbolsRequired;
256  }
257  if (burst->GetNPackets() != 0)
258  {
259  AddDownlinkBurst(connection, diuc, modulationType, burst);
260  }
261 }
262 
263 void
264 BSSchedulerRtps::BSSchedulerInitialRangingConnection(uint32_t& availableSymbols)
265 {
266  Ptr<WimaxConnection> connection;
267  WimaxPhy::ModulationType modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
268  uint8_t diuc = OfdmDlBurstProfile::DIUC_BURST_PROFILE_1;
269  uint32_t nrSymbolsRequired = 0;
270  GenericMacHeader hdr;
271  Ptr<Packet> packet;
272  Ptr<PacketBurst> burst = Create<PacketBurst>();
273 
274  while (GetBs()->GetInitialRangingConnection()->HasPackets() && availableSymbols > 0)
275  {
276  connection = GetBs()->GetInitialRangingConnection();
277 
278  packet = connection->GetQueue()->Peek(hdr);
279  nrSymbolsRequired = GetBs()->GetPhy()->GetNrSymbols(packet->GetSize(), modulationType);
280 
281  // PIRO: check for fragmentation
282  if (availableSymbols < nrSymbolsRequired &&
283  !CheckForFragmentation(connection, availableSymbols, modulationType))
284  {
285  break;
286  }
287  else if (availableSymbols < nrSymbolsRequired &&
288  CheckForFragmentation(connection, availableSymbols, modulationType))
289  {
290  uint32_t availableByte =
291  GetBs()->GetPhy()->GetNrBytes(availableSymbols, modulationType);
292  packet = connection->Dequeue(MacHeaderType::HEADER_TYPE_GENERIC, availableByte);
293  }
294  else
295  {
296  packet = connection->Dequeue();
297  }
298 
299  NS_ASSERT_MSG(hdr.GetCid() == connection->GetCid(),
300  "Base station: Error while scheduling initial ranging connection: header CID "
301  "!= connection CID");
302  burst->AddPacket(packet);
303  availableSymbols -= nrSymbolsRequired;
304  }
305  if (burst->GetNPackets())
306  {
307  AddDownlinkBurst(connection, diuc, modulationType, burst);
308  }
309 }
310 
311 void
312 BSSchedulerRtps::BSSchedulerBasicConnection(uint32_t& availableSymbols)
313 {
314  Ptr<WimaxConnection> connection;
315  WimaxPhy::ModulationType modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
316  uint8_t diuc = OfdmDlBurstProfile::DIUC_BURST_PROFILE_1;
317  uint32_t nrSymbolsRequired = 0;
318  GenericMacHeader hdr;
319  Ptr<Packet> packet;
320  Ptr<PacketBurst> burst = Create<PacketBurst>();
321 
322  std::vector<Ptr<WimaxConnection>>::const_iterator iter;
323  std::vector<Ptr<WimaxConnection>> connections;
324 
325  connections = GetBs()->GetConnectionManager()->GetConnections(Cid::BASIC);
326  for (iter = connections.begin(); iter != connections.end(); ++iter)
327  {
328  while ((*iter)->HasPackets() && availableSymbols > 0)
329  {
330  connection = *iter;
331 
332  modulationType =
333  GetBs()->GetSSManager()->GetSSRecord(connection->GetCid())->GetModulationType();
334  diuc = GetBs()->GetBurstProfileManager()->GetBurstProfile(
335  modulationType,
336  WimaxNetDevice::DIRECTION_DOWNLINK);
337 
338  packet = connection->GetQueue()->Peek(hdr);
339  nrSymbolsRequired = GetBs()->GetPhy()->GetNrSymbols(packet->GetSize(), modulationType);
340 
341  // PIRO: check for fragmentation
342  if (availableSymbols < nrSymbolsRequired &&
343  !CheckForFragmentation(connection, availableSymbols, modulationType))
344  {
345  break;
346  }
347  else if (availableSymbols < nrSymbolsRequired &&
348  CheckForFragmentation(connection, availableSymbols, modulationType))
349  {
350  uint32_t availableByte =
351  GetBs()->GetPhy()->GetNrBytes(availableSymbols, modulationType);
352  packet = connection->Dequeue(MacHeaderType::HEADER_TYPE_GENERIC, availableByte);
353  }
354  else
355  {
356  packet = connection->Dequeue();
357  }
358 
359  NS_ASSERT_MSG(hdr.GetCid() == connection->GetCid(),
360  "Base station: Error while scheduling basic connection: header CID != "
361  "connection CID");
362  burst->AddPacket(packet);
363  availableSymbols -= nrSymbolsRequired;
364  }
365  if (burst->GetNPackets() != 0)
366  {
367  AddDownlinkBurst(connection, diuc, modulationType, burst);
368  burst = Create<PacketBurst>();
369  }
370  }
371 }
372 
373 void
374 BSSchedulerRtps::BSSchedulerPrimaryConnection(uint32_t& availableSymbols)
375 {
376  Ptr<WimaxConnection> connection;
377  WimaxPhy::ModulationType modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
378  uint8_t diuc = 0;
379  uint32_t nrSymbolsRequired = 0;
380  GenericMacHeader hdr;
381  Ptr<Packet> packet;
382  Ptr<PacketBurst> burst = Create<PacketBurst>();
383 
384  std::vector<Ptr<WimaxConnection>>::const_iterator iter;
385  std::vector<Ptr<WimaxConnection>> connections;
386 
387  connections = GetBs()->GetConnectionManager()->GetConnections(Cid::PRIMARY);
388  for (iter = connections.begin(); iter != connections.end(); ++iter)
389  {
390  while ((*iter)->HasPackets() && availableSymbols > 0)
391  {
392  connection = *iter;
393 
394  modulationType =
395  GetBs()->GetSSManager()->GetSSRecord(connection->GetCid())->GetModulationType();
396  diuc = GetBs()->GetBurstProfileManager()->GetBurstProfile(
397  modulationType,
398  WimaxNetDevice::DIRECTION_DOWNLINK);
399 
400  packet = connection->GetQueue()->Peek(hdr);
401  nrSymbolsRequired = GetBs()->GetPhy()->GetNrSymbols(packet->GetSize(), modulationType);
402 
403  // PIRO: check for fragmentation
404  if (availableSymbols < nrSymbolsRequired &&
405  !CheckForFragmentation(connection, availableSymbols, modulationType))
406  {
407  break;
408  }
409  else if (availableSymbols < nrSymbolsRequired &&
410  CheckForFragmentation(connection, availableSymbols, modulationType))
411  {
412  uint32_t availableByte =
413  GetBs()->GetPhy()->GetNrBytes(availableSymbols, modulationType);
414  packet = connection->Dequeue(MacHeaderType::HEADER_TYPE_GENERIC, availableByte);
415  }
416  else
417  {
418  packet = connection->Dequeue();
419  }
420 
421  NS_ASSERT_MSG(hdr.GetCid() == connection->GetCid(),
422  "Base station: Error while scheduling primary connection: header CID != "
423  "connection CID");
424  burst->AddPacket(packet);
425  availableSymbols -= nrSymbolsRequired;
426  }
427  if (burst->GetNPackets() != 0)
428  {
429  AddDownlinkBurst(connection, diuc, modulationType, burst);
430  }
431  }
432 }
433 
434 void
435 BSSchedulerRtps::BSSchedulerUGSConnection(uint32_t& availableSymbols)
436 {
437  Ptr<WimaxConnection> connection;
438  WimaxPhy::ModulationType modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
439  uint8_t diuc;
440  uint32_t nrSymbolsRequired = 0;
441  GenericMacHeader hdr;
442  Ptr<Packet> packet;
443  Ptr<PacketBurst> burst = Create<PacketBurst>();
444 
445  Time currentTime = Simulator::Now();
446 
447  std::vector<ServiceFlow*>::iterator iter;
448  ServiceFlowRecord* serviceFlowRecord;
449  std::vector<ServiceFlow*> serviceFlows;
450 
451  serviceFlows = GetBs()->GetServiceFlowManager()->GetServiceFlows(ServiceFlow::SF_TYPE_UGS);
452  for (iter = serviceFlows.begin(); iter != serviceFlows.end(); ++iter)
453  {
454  serviceFlowRecord = (*iter)->GetRecord();
455  // if latency would exceed in case grant is allocated in next frame then allocate in current
456  // frame
457  if ((*iter)->HasPackets() &&
458  ((currentTime - serviceFlowRecord->GetDlTimeStamp()) +
459  GetBs()->GetPhy()->GetFrameDuration()) > MilliSeconds((*iter)->GetMaximumLatency()))
460  {
461  connection = (*iter)->GetConnection();
462  if (connection->GetType() == Cid::MULTICAST)
463  {
464  modulationType = connection->GetServiceFlow()->GetModulation();
465  }
466  else
467  {
468  modulationType =
469  GetBs()->GetSSManager()->GetSSRecord(connection->GetCid())->GetModulationType();
470  }
471  diuc = GetBs()->GetBurstProfileManager()->GetBurstProfile(
472  modulationType,
473  WimaxNetDevice::DIRECTION_DOWNLINK);
474 
475  nrSymbolsRequired = connection->GetServiceFlow()->GetRecord()->GetGrantSize();
476 
477  // Packet fragmentation for UGS connections has not been implemented yet!
478  if (availableSymbols > nrSymbolsRequired)
479  {
480  availableSymbols -= nrSymbolsRequired;
481  burst =
482  CreateUgsBurst(connection->GetServiceFlow(), modulationType, nrSymbolsRequired);
483  if (burst->GetNPackets() != 0)
484  {
485  AddDownlinkBurst(connection, diuc, modulationType, burst);
486  currentTime = Simulator::Now();
487  serviceFlowRecord->SetDlTimeStamp(currentTime);
488  burst = Create<PacketBurst>();
489  }
490  }
491  }
492  }
493 }
494 
495 void
496 BSSchedulerRtps::BSSchedulerRTPSConnection(uint32_t& availableSymbols)
497 {
498  Ptr<WimaxConnection> connection;
499  GenericMacHeader hdr;
500  Ptr<Packet> packet;
501  Ptr<PacketBurst> burst = Create<PacketBurst>();
502 
503  Time currentTime = Simulator::Now();
504 
505  std::vector<Ptr<WimaxConnection>> connections;
506  std::vector<ServiceFlow*>::iterator iter2;
507  ServiceFlowRecord* serviceFlowRecord;
508  std::vector<ServiceFlow*> serviceFlows;
509 
510  uint32_t symbolsRequired[100];
511  WimaxPhy::ModulationType modulationType_[100];
512  uint8_t diuc_[100];
513  Ptr<WimaxConnection> rtPSConnection[100];
514  uint32_t dataToSend;
515  uint32_t totSymbolsRequired = 0;
516  int nbConnection = 0;
517 
518  NS_LOG_INFO("\tDL Scheduler for rtPS flows \n"
519  << "\t\tavailableSymbols = " << availableSymbols);
520 
521  serviceFlows = GetBs()->GetServiceFlowManager()->GetServiceFlows(ServiceFlow::SF_TYPE_RTPS);
522  nbConnection = 0;
523  for (iter2 = serviceFlows.begin(); iter2 != serviceFlows.end(); ++iter2)
524  {
525  // DL RTPS Scheduler works for all rtPS connection that have packets to transmitt!!!
526  serviceFlowRecord = (*iter2)->GetRecord();
527 
528  if ((*iter2)->HasPackets())
529  {
530  currentTime = Simulator::Now();
531  serviceFlowRecord->SetDlTimeStamp(currentTime);
532  rtPSConnection[nbConnection] = (*iter2)->GetConnection();
533  if (rtPSConnection[nbConnection]->GetType() == Cid::MULTICAST)
534  {
535  modulationType_[nbConnection] =
536  rtPSConnection[nbConnection]->GetServiceFlow()->GetModulation();
537  }
538  else
539  {
540  modulationType_[nbConnection] =
541  GetBs()
542  ->GetSSManager()
543  ->GetSSRecord(rtPSConnection[nbConnection]->GetCid())
544  ->GetModulationType();
545  }
546  diuc_[nbConnection] = GetBs()->GetBurstProfileManager()->GetBurstProfile(
547  modulationType_[nbConnection],
548  WimaxNetDevice::DIRECTION_DOWNLINK);
549 
550  dataToSend = rtPSConnection[nbConnection]->GetQueue()->GetQueueLengthWithMACOverhead();
551  NS_LOG_INFO("\t\tRTPS DL Scheduler for CID = " << rtPSConnection[nbConnection]->GetCid()
552  << "\n\t\t\t dataToSend = "
553  << dataToSend);
554 
555  symbolsRequired[nbConnection] =
556  GetBs()->GetPhy()->GetNrSymbols(dataToSend, modulationType_[nbConnection]);
557 
558  totSymbolsRequired += symbolsRequired[nbConnection];
559  nbConnection++;
560  }
561  }
562 
563  NS_LOG_INFO("\t\ttotSymbolsRequired = " << totSymbolsRequired);
564 
565  // Channel Saturation
566  while (totSymbolsRequired > availableSymbols)
567  {
568  NS_LOG_INFO("\tDL Channel Saturation: totSymbolsRequired > availableSymbols_rtPS");
569  double delta = double(availableSymbols) / double(totSymbolsRequired);
570  NS_LOG_INFO("\t\tdelta = " << delta);
571  totSymbolsRequired = 0;
572  for (int i = 0; i < nbConnection; i++)
573  {
574  NS_LOG_INFO("\t\tprevious symbolsRequired[" << i << "] = " << symbolsRequired[i]);
575  symbolsRequired[i] = (uint32_t)std::floor(symbolsRequired[i] * delta);
576  totSymbolsRequired += symbolsRequired[i];
577  NS_LOG_INFO("\t\tnew symbolsRequired[" << i << "] = " << symbolsRequired[i]);
578  }
579  NS_LOG_INFO("\t\ttotSymbolsRequired = " << totSymbolsRequired);
580  }
581 
582  // Downlink Bandwidth Allocation
583  for (int i = 0; i < nbConnection; i++)
584  {
585  packet = rtPSConnection[i]->GetQueue()->Peek(hdr);
586  uint32_t symbolsForPacketTransmission = 0;
587  burst = Create<PacketBurst>();
588  NS_LOG_INFO("\t\tCID = " << rtPSConnection[i]->GetCid()
589  << " assignedSymbols = " << symbolsRequired[i]);
590 
591  while (symbolsRequired[i] > 0)
592  {
593  symbolsForPacketTransmission = GetBs()->GetPhy()->GetNrSymbols(
594  rtPSConnection[i]->GetQueue()->GetFirstPacketRequiredByte(
595  MacHeaderType::HEADER_TYPE_GENERIC),
596  modulationType_[i]);
597 
598  // PIRO: check for fragmentation
599  if (symbolsForPacketTransmission > symbolsRequired[i] &&
600  !CheckForFragmentation(rtPSConnection[i], symbolsRequired[i], modulationType_[i]))
601  {
602  break;
603  }
604  else if (symbolsForPacketTransmission > symbolsRequired[i] &&
605  CheckForFragmentation(rtPSConnection[i],
606  symbolsRequired[i],
607  modulationType_[i]))
608  {
609  uint32_t availableByte =
610  GetBs()->GetPhy()->GetNrBytes(symbolsRequired[i], modulationType_[i]);
611  packet =
612  rtPSConnection[i]->Dequeue(MacHeaderType::HEADER_TYPE_GENERIC, availableByte);
613  symbolsRequired[i] = 0;
614  }
615  else
616  {
617  packet = rtPSConnection[i]->Dequeue();
618  symbolsRequired[i] -= symbolsForPacketTransmission;
619  }
620 
621  NS_ASSERT_MSG(hdr.GetCid() == rtPSConnection[i]->GetCid(),
622  "Base station: Error while scheduling RTPs connection: header CID != "
623  "connection CID");
624  burst->AddPacket(packet);
625  }
626 
627  if (burst->GetNPackets() != 0)
628  {
629  AddDownlinkBurst(rtPSConnection[i], diuc_[i], modulationType_[i], burst);
630  }
631  }
632 
633  availableSymbols -= totSymbolsRequired;
634 }
635 
636 void
637 BSSchedulerRtps::BSSchedulerNRTPSConnection(uint32_t& availableSymbols)
638 {
639  Ptr<WimaxConnection> connection;
640  WimaxPhy::ModulationType modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
641  uint8_t diuc = 0;
642  uint32_t nrSymbolsRequired = 0;
643  GenericMacHeader hdr;
644  Ptr<Packet> packet;
645  Ptr<PacketBurst> burst = Create<PacketBurst>();
646 
647  std::vector<ServiceFlow*>::iterator iter;
648  std::vector<ServiceFlow*> serviceFlows;
649 
650  serviceFlows = GetBs()->GetServiceFlowManager()->GetServiceFlows(ServiceFlow::SF_TYPE_NRTPS);
651  for (iter = serviceFlows.begin(); iter != serviceFlows.end(); ++iter)
652  {
653  connection = (*iter)->GetConnection();
654 
655  while ((*iter)->HasPackets() && availableSymbols > 0)
656  {
657  if (connection->GetType() == Cid::MULTICAST)
658  {
659  modulationType = connection->GetServiceFlow()->GetModulation();
660  }
661  else
662  {
663  modulationType =
664  GetBs()->GetSSManager()->GetSSRecord(connection->GetCid())->GetModulationType();
665  }
666 
667  diuc = GetBs()->GetBurstProfileManager()->GetBurstProfile(
668  modulationType,
669  WimaxNetDevice::DIRECTION_DOWNLINK);
670 
671  packet = connection->GetQueue()->Peek(hdr);
672  nrSymbolsRequired = GetBs()->GetPhy()->GetNrSymbols(packet->GetSize(), modulationType);
673 
674  if (availableSymbols < nrSymbolsRequired)
675  {
676  break;
677  }
678 
679  packet = connection->Dequeue();
680  NS_ASSERT_MSG(hdr.GetCid() == connection->GetCid(),
681  "Base station: Error while scheduling NRTPs connection: header CID != "
682  "connection CID");
683  burst->AddPacket(packet);
684  availableSymbols -= nrSymbolsRequired;
685  }
686  if (burst->GetNPackets() != 0)
687  {
688  AddDownlinkBurst(connection, diuc, modulationType, burst);
689  burst = Create<PacketBurst>();
690  }
691  }
692 }
693 
694 void
695 BSSchedulerRtps::BSSchedulerBEConnection(uint32_t& availableSymbols)
696 {
697  Ptr<WimaxConnection> connection;
698  WimaxPhy::ModulationType modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
699  uint8_t diuc = 0;
700  uint32_t nrSymbolsRequired = 0;
701  GenericMacHeader hdr;
702  Ptr<Packet> packet;
703  Ptr<PacketBurst> burst = Create<PacketBurst>();
704 
705  std::vector<ServiceFlow*>::iterator iter;
706  std::vector<ServiceFlow*> serviceFlows;
707 
708  serviceFlows = GetBs()->GetServiceFlowManager()->GetServiceFlows(ServiceFlow::SF_TYPE_BE);
709  for (iter = serviceFlows.begin(); iter != serviceFlows.end(); ++iter)
710  {
711  connection = (*iter)->GetConnection();
712 
713  while ((*iter)->HasPackets() && availableSymbols > 0)
714  {
715  if (connection->GetType() == Cid::MULTICAST)
716  {
717  modulationType = connection->GetServiceFlow()->GetModulation();
718  }
719  else
720  {
721  modulationType =
722  GetBs()->GetSSManager()->GetSSRecord(connection->GetCid())->GetModulationType();
723  }
724  diuc = GetBs()->GetBurstProfileManager()->GetBurstProfile(
725  modulationType,
726  WimaxNetDevice::DIRECTION_DOWNLINK);
727 
728  packet = connection->GetQueue()->Peek(hdr);
729  nrSymbolsRequired = GetBs()->GetPhy()->GetNrSymbols(packet->GetSize(), modulationType);
730 
731  if (availableSymbols < nrSymbolsRequired)
732  {
733  break;
734  }
735 
736  packet = connection->Dequeue();
737  NS_ASSERT_MSG(
738  hdr.GetCid() == connection->GetCid(),
739  "Base station: Error while scheduling BE connection: header CID != connection CID");
740  burst->AddPacket(packet);
741  availableSymbols -= nrSymbolsRequired;
742  }
743  if (burst->GetNPackets() != 0)
744  {
745  AddDownlinkBurst(connection, diuc, modulationType, burst);
746  burst = Create<PacketBurst>();
747  }
748  }
749 }
750 
751 } // namespace ns3
ns3::BSScheduler
BaseStation Scheduler.
Definition: bs-scheduler.h:48
ns3::BSScheduler::GetBs
virtual Ptr< BaseStationNetDevice > GetBs()
Get the base station.
Definition: bs-scheduler.cc:89
ns3::BSScheduler::SetBs
virtual void SetBs(Ptr< BaseStationNetDevice > bs)
Set the base station.
Definition: bs-scheduler.cc:83
ns3::BSScheduler::CheckForFragmentation
bool CheckForFragmentation(Ptr< WimaxConnection > connection, int availableSymbols, WimaxPhy::ModulationType modulationType)
Check if the packet fragmentation is possible for transport connection.
Definition: bs-scheduler.cc:95
ns3::BSSchedulerRtps
This class implements a simple downlink scheduler for rtPS flows.
Definition: bs-scheduler-rtps.h:61
ns3::BSSchedulerRtps::GetTypeId
static TypeId GetTypeId()
Get the type ID.
Definition: bs-scheduler-rtps.cc:48
ns3::BSSchedulerRtps::Schedule
void Schedule() override
Schedule function.
Definition: bs-scheduler-rtps.cc:132
ns3::BSSchedulerRtps::BSSchedulerPrimaryConnection
void BSSchedulerPrimaryConnection(uint32_t &availableSymbols)
schedules the primary connection
Definition: bs-scheduler-rtps.cc:374
ns3::BSSchedulerRtps::GetDownlinkBursts
std::list< std::pair< OfdmDlMapIe *, Ptr< PacketBurst > > > * GetDownlinkBursts() const override
This function returns all the downlink bursts scheduled for the next downlink sub-frame.
Definition: bs-scheduler-rtps.cc:88
ns3::BSSchedulerRtps::BSSchedulerUGSConnection
void BSSchedulerUGSConnection(uint32_t &availableSymbols)
schedules the UGS connection
Definition: bs-scheduler-rtps.cc:435
ns3::BSSchedulerRtps::BSSchedulerBEConnection
void BSSchedulerBEConnection(uint32_t &availableSymbols)
schedules the BE connection
Definition: bs-scheduler-rtps.cc:695
ns3::BSSchedulerRtps::BSSchedulerBasicConnection
void BSSchedulerBasicConnection(uint32_t &availableSymbols)
schedules the basic connections
Definition: bs-scheduler-rtps.cc:312
ns3::BSSchedulerRtps::AddDownlinkBurst
void AddDownlinkBurst(Ptr< const WimaxConnection > connection, uint8_t diuc, WimaxPhy::ModulationType modulationType, Ptr< PacketBurst > burst) override
This function adds a downlink burst to the list of downlink bursts scheduled for the next downlink su...
Definition: bs-scheduler-rtps.cc:94
ns3::BSSchedulerRtps::BSSchedulerInitialRangingConnection
void BSSchedulerInitialRangingConnection(uint32_t &availableSymbols)
schedules the IR connections
Definition: bs-scheduler-rtps.cc:264
ns3::BSSchedulerRtps::BSSchedulerRTPSConnection
void BSSchedulerRTPSConnection(uint32_t &availableSymbols)
Downlink Scheduler for rtPS connections.
Definition: bs-scheduler-rtps.cc:496
ns3::BSSchedulerRtps::BSSchedulerBroadcastConnection
void BSSchedulerBroadcastConnection(uint32_t &availableSymbols)
schedules the broadcast connections
Definition: bs-scheduler-rtps.cc:217
ns3::BSSchedulerRtps::BSSchedulerNRTPSConnection
void BSSchedulerNRTPSConnection(uint32_t &availableSymbols)
schedules the NRTPS connections
Definition: bs-scheduler-rtps.cc:637
ns3::BSSchedulerRtps::CreateUgsBurst
Ptr< PacketBurst > CreateUgsBurst(ServiceFlow *serviceFlow, WimaxPhy::ModulationType modulationType, uint32_t availableSymbols) override
Creates a downlink UGS burst.
Definition: bs-scheduler-rtps.cc:171
ns3::BSSchedulerRtps::SelectConnection
bool SelectConnection(Ptr< WimaxConnection > &connection) override
Selects a connection from the list of connections having packets to be sent .
Definition: bs-scheduler-rtps.cc:211
ns3::BSSchedulerRtps::m_downlinkBursts
std::list< std::pair< OfdmDlMapIe *, Ptr< PacketBurst > > > * m_downlinkBursts
down link bursts
Definition: bs-scheduler-rtps.h:221
ns3::Cid::PRIMARY
@ PRIMARY
Definition: cid.h:45
ns3::Cid::TRANSPORT
@ TRANSPORT
Definition: cid.h:46
ns3::Cid::MULTICAST
@ MULTICAST
Definition: cid.h:47
ns3::Cid::BASIC
@ BASIC
Definition: cid.h:44
ns3::Cid::GetIdentifier
uint16_t GetIdentifier() const
Definition: cid.cc:45
ns3::GenericMacHeader
This class implements the Generic mac Header as described by IEEE Standard for Local and metropolitan...
Definition: wimax-mac-header.h:114
ns3::GenericMacHeader::GetCid
Cid GetCid() const
Get CID field.
Definition: wimax-mac-header.cc:210
ns3::OfdmDlMapIe
This class implements the OFDM DL-MAP information element as described by "IEEE Standard for Local an...
Definition: dl-mac-messages.h:460
ns3::OfdmDlMapIe::SetCid
void SetCid(Cid cid)
Set CID function.
Definition: dl-mac-messages.cc:471
ns3::OfdmDlMapIe::SetDiuc
void SetDiuc(uint8_t diuc)
Set DIUC field.
Definition: dl-mac-messages.cc:477
ns3::PacketBurst
this class implement a burst as a list of packets
Definition: packet-burst.h:37
ns3::Packet::GetSize
uint32_t GetSize() const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:863
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:78
ns3::ServiceFlow
This class implements service flows as described by the IEEE-802.16 standard.
Definition: service-flow.h:43
ns3::ServiceFlow::HasPackets
bool HasPackets() const
Check if packets are present.
Definition: service-flow.cc:256
ns3::ServiceFlow::GetConnection
Ptr< WimaxConnection > GetConnection() const
Can return a null connection is this service flow has not been associated yet to a connection.
Definition: service-flow.cc:210
ns3::ServiceFlowRecord
this class implements a structure to manage some parameters and statistics related to a service flow
Definition: service-flow-record.h:40
ns3::ServiceFlowRecord::SetDlTimeStamp
void SetDlTimeStamp(Time dlTimeStamp)
Set the DlTimeStamp.
Definition: service-flow-record.cc:72
ns3::Simulator::Now
static Time Now()
Return the current simulation virtual time.
Definition: simulator.cc:199
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
ns3::TypeId
a unique identifier for an interface.
Definition: type-id.h:60
ns3::TypeId::SetParent
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:935
ns3::WimaxPhy::ModulationType
ModulationType
ModulationType enumeration.
Definition: wimax-phy.h:54
ns3::WimaxPhy::MODULATION_TYPE_BPSK_12
@ MODULATION_TYPE_BPSK_12
Definition: wimax-phy.h:55
NS_ASSERT_MSG
#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
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
NS_LOG_DEBUG
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:268
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:275
NS_OBJECT_ENSURE_REGISTERED
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:46
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1348
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::GetSize
uint32_t GetSize(Ptr< const Packet > packet, const WifiMacHeader *hdr, bool isAmpdu)
Return the total size of the packet after WifiMacHeader and FCS trailer have been added.
Definition: wifi-utils.cc:132
list
#define list
Definition: openflow-interface.h:46