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