A Discrete-Event Network Simulator
API
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
pf-ff-mac-scheduler.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 <ns3/log.h>
22 #include <ns3/pointer.h>
23 #include <ns3/math.h>
24 
25 #include <ns3/simulator.h>
26 #include <ns3/lte-amc.h>
27 #include <ns3/pf-ff-mac-scheduler.h>
28 #include <ns3/lte-vendor-specific-parameters.h>
29 #include <ns3/boolean.h>
30 #include <cfloat>
31 #include <set>
32 
33 NS_LOG_COMPONENT_DEFINE ("PfFfMacScheduler");
34 
35 namespace ns3 {
36 
37 static const int PfType0AllocationRbg[4] = {
38  10, // RGB size 1
39  26, // RGB size 2
40  63, // RGB size 3
41  110 // RGB size 4
42 }; // see table 7.1.6.1-1 of 36.213
43 
44 
45 NS_OBJECT_ENSURE_REGISTERED (PfFfMacScheduler);
46 
47 
48 
50 {
51 public:
53 
54  // inherited from FfMacCschedSapProvider
55  virtual void CschedCellConfigReq (const struct CschedCellConfigReqParameters& params);
56  virtual void CschedUeConfigReq (const struct CschedUeConfigReqParameters& params);
57  virtual void CschedLcConfigReq (const struct CschedLcConfigReqParameters& params);
58  virtual void CschedLcReleaseReq (const struct CschedLcReleaseReqParameters& params);
59  virtual void CschedUeReleaseReq (const struct CschedUeReleaseReqParameters& params);
60 
61 private:
64 };
65 
67 {
68 }
69 
71 {
72 }
73 
74 
75 void
77 {
79 }
80 
81 void
83 {
85 }
86 
87 
88 void
90 {
92 }
93 
94 void
96 {
98 }
99 
100 void
102 {
104 }
105 
106 
107 
108 
110 {
111 public:
113 
114  // inherited from FfMacSchedSapProvider
115  virtual void SchedDlRlcBufferReq (const struct SchedDlRlcBufferReqParameters& params);
116  virtual void SchedDlPagingBufferReq (const struct SchedDlPagingBufferReqParameters& params);
117  virtual void SchedDlMacBufferReq (const struct SchedDlMacBufferReqParameters& params);
118  virtual void SchedDlTriggerReq (const struct SchedDlTriggerReqParameters& params);
119  virtual void SchedDlRachInfoReq (const struct SchedDlRachInfoReqParameters& params);
120  virtual void SchedDlCqiInfoReq (const struct SchedDlCqiInfoReqParameters& params);
121  virtual void SchedUlTriggerReq (const struct SchedUlTriggerReqParameters& params);
122  virtual void SchedUlNoiseInterferenceReq (const struct SchedUlNoiseInterferenceReqParameters& params);
123  virtual void SchedUlSrInfoReq (const struct SchedUlSrInfoReqParameters& params);
124  virtual void SchedUlMacCtrlInfoReq (const struct SchedUlMacCtrlInfoReqParameters& params);
125  virtual void SchedUlCqiInfoReq (const struct SchedUlCqiInfoReqParameters& params);
126 
127 
128 private:
131 };
132 
133 
134 
136 {
137 }
138 
139 
141  : m_scheduler (scheduler)
142 {
143 }
144 
145 void
147 {
149 }
150 
151 void
153 {
155 }
156 
157 void
159 {
161 }
162 
163 void
165 {
167 }
168 
169 void
171 {
173 }
174 
175 void
177 {
179 }
180 
181 void
183 {
185 }
186 
187 void
189 {
191 }
192 
193 void
195 {
197 }
198 
199 void
201 {
203 }
204 
205 void
207 {
209 }
210 
211 
212 
213 
214 
216  : m_cschedSapUser (0),
217  m_schedSapUser (0),
218  m_timeWindow (99.0),
219  m_nextRntiUl (0)
220 {
221  m_amc = CreateObject <LteAmc> ();
224 }
225 
227 {
228  NS_LOG_FUNCTION (this);
229 }
230 
231 void
233 {
234  NS_LOG_FUNCTION (this);
236  m_dlHarqProcessesTimer.clear ();
238  m_dlInfoListBuffered.clear ();
239  m_ulHarqCurrentProcessId.clear ();
240  m_ulHarqProcessesStatus.clear ();
242  delete m_cschedSapProvider;
243  delete m_schedSapProvider;
244 }
245 
246 TypeId
248 {
249  static TypeId tid = TypeId ("ns3::PfFfMacScheduler")
251  .AddConstructor<PfFfMacScheduler> ()
252  .AddAttribute ("CqiTimerThreshold",
253  "The number of TTIs a CQI is valid (default 1000 - 1 sec.)",
254  UintegerValue (1000),
255  MakeUintegerAccessor (&PfFfMacScheduler::m_cqiTimersThreshold),
256  MakeUintegerChecker<uint32_t> ())
257  .AddAttribute ("HarqEnabled",
258  "Activate/Deactivate the HARQ [by default is active].",
259  BooleanValue (true),
260  MakeBooleanAccessor (&PfFfMacScheduler::m_harqOn),
261  MakeBooleanChecker ())
262  .AddAttribute ("UlGrantMcs",
263  "The MCS of the UL grant, must be [0..15] (default 0)",
264  UintegerValue (0),
265  MakeUintegerAccessor (&PfFfMacScheduler::m_ulGrantMcs),
266  MakeUintegerChecker<uint8_t> ())
267  ;
268  return tid;
269 }
270 
271 
272 
273 void
275 {
276  m_cschedSapUser = s;
277 }
278 
279 void
281 {
282  m_schedSapUser = s;
283 }
284 
287 {
288  return m_cschedSapProvider;
289 }
290 
293 {
294  return m_schedSapProvider;
295 }
296 
297 void
299 {
300  NS_LOG_FUNCTION (this);
301  // Read the subset of parameters used
302  m_cschedCellConfig = params;
305  cnf.m_result = SUCCESS;
307  return;
308 }
309 
310 void
312 {
313  NS_LOG_FUNCTION (this << " RNTI " << params.m_rnti << " txMode " << (uint16_t)params.m_transmissionMode);
314  std::map <uint16_t,uint8_t>::iterator it = m_uesTxMode.find (params.m_rnti);
315  if (it == m_uesTxMode.end ())
316  {
317  m_uesTxMode.insert (std::pair <uint16_t, double> (params.m_rnti, params.m_transmissionMode));
318  // generate HARQ buffers
319  m_dlHarqCurrentProcessId.insert (std::pair <uint16_t,uint8_t > (params.m_rnti, 0));
320  DlHarqProcessesStatus_t dlHarqPrcStatus;
321  dlHarqPrcStatus.resize (8,0);
322  m_dlHarqProcessesStatus.insert (std::pair <uint16_t, DlHarqProcessesStatus_t> (params.m_rnti, dlHarqPrcStatus));
323  DlHarqProcessesTimer_t dlHarqProcessesTimer;
324  dlHarqProcessesTimer.resize (8,0);
325  m_dlHarqProcessesTimer.insert (std::pair <uint16_t, DlHarqProcessesTimer_t> (params.m_rnti, dlHarqProcessesTimer));
326  DlHarqProcessesDciBuffer_t dlHarqdci;
327  dlHarqdci.resize (8);
328  m_dlHarqProcessesDciBuffer.insert (std::pair <uint16_t, DlHarqProcessesDciBuffer_t> (params.m_rnti, dlHarqdci));
329  DlHarqRlcPduListBuffer_t dlHarqRlcPdu;
330  dlHarqRlcPdu.resize (2);
331  dlHarqRlcPdu.at (0).resize (8);
332  dlHarqRlcPdu.at (1).resize (8);
333  m_dlHarqProcessesRlcPduListBuffer.insert (std::pair <uint16_t, DlHarqRlcPduListBuffer_t> (params.m_rnti, dlHarqRlcPdu));
334  m_ulHarqCurrentProcessId.insert (std::pair <uint16_t,uint8_t > (params.m_rnti, 0));
335  UlHarqProcessesStatus_t ulHarqPrcStatus;
336  ulHarqPrcStatus.resize (8,0);
337  m_ulHarqProcessesStatus.insert (std::pair <uint16_t, UlHarqProcessesStatus_t> (params.m_rnti, ulHarqPrcStatus));
338  UlHarqProcessesDciBuffer_t ulHarqdci;
339  ulHarqdci.resize (8);
340  m_ulHarqProcessesDciBuffer.insert (std::pair <uint16_t, UlHarqProcessesDciBuffer_t> (params.m_rnti, ulHarqdci));
341  }
342  else
343  {
344  (*it).second = params.m_transmissionMode;
345  }
346  return;
347 }
348 
349 void
351 {
352  NS_LOG_FUNCTION (this << " New LC, rnti: " << params.m_rnti);
353 
354  std::map <uint16_t, pfsFlowPerf_t>::iterator it;
355  for (uint16_t i = 0; i < params.m_logicalChannelConfigList.size (); i++)
356  {
357  it = m_flowStatsDl.find (params.m_rnti);
358 
359  if (it == m_flowStatsDl.end ())
360  {
361  pfsFlowPerf_t flowStatsDl;
362  flowStatsDl.flowStart = Simulator::Now ();
363  flowStatsDl.totalBytesTransmitted = 0;
364  flowStatsDl.lastTtiBytesTrasmitted = 0;
365  flowStatsDl.lastAveragedThroughput = 1;
366  m_flowStatsDl.insert (std::pair<uint16_t, pfsFlowPerf_t> (params.m_rnti, flowStatsDl));
367  pfsFlowPerf_t flowStatsUl;
368  flowStatsUl.flowStart = Simulator::Now ();
369  flowStatsUl.totalBytesTransmitted = 0;
370  flowStatsUl.lastTtiBytesTrasmitted = 0;
371  flowStatsUl.lastAveragedThroughput = 1;
372  m_flowStatsUl.insert (std::pair<uint16_t, pfsFlowPerf_t> (params.m_rnti, flowStatsUl));
373  }
374  }
375 
376  return;
377 }
378 
379 void
381 {
382  NS_LOG_FUNCTION (this);
383  for (uint16_t i = 0; i < params.m_logicalChannelIdentity.size (); i++)
384  {
385  std::map<LteFlowId_t, FfMacSchedSapProvider::SchedDlRlcBufferReqParameters>::iterator it = m_rlcBufferReq.begin ();
386  std::map<LteFlowId_t, FfMacSchedSapProvider::SchedDlRlcBufferReqParameters>::iterator temp;
387  while (it!=m_rlcBufferReq.end ())
388  {
389  if (((*it).first.m_rnti == params.m_rnti) && ((*it).first.m_lcId == params.m_logicalChannelIdentity.at (i)))
390  {
391  temp = it;
392  it++;
393  m_rlcBufferReq.erase (temp);
394  }
395  else
396  {
397  it++;
398  }
399  }
400  }
401  return;
402 }
403 
404 void
406 {
407  NS_LOG_FUNCTION (this);
408 
409  m_uesTxMode.erase (params.m_rnti);
410  m_dlHarqCurrentProcessId.erase (params.m_rnti);
411  m_dlHarqProcessesStatus.erase (params.m_rnti);
412  m_dlHarqProcessesTimer.erase (params.m_rnti);
413  m_dlHarqProcessesDciBuffer.erase (params.m_rnti);
415  m_ulHarqCurrentProcessId.erase (params.m_rnti);
416  m_ulHarqProcessesStatus.erase (params.m_rnti);
417  m_ulHarqProcessesDciBuffer.erase (params.m_rnti);
418  m_flowStatsDl.erase (params.m_rnti);
419  m_flowStatsUl.erase (params.m_rnti);
420  m_ceBsrRxed.erase (params.m_rnti);
421  std::map<LteFlowId_t, FfMacSchedSapProvider::SchedDlRlcBufferReqParameters>::iterator it = m_rlcBufferReq.begin ();
422  std::map<LteFlowId_t, FfMacSchedSapProvider::SchedDlRlcBufferReqParameters>::iterator temp;
423  while (it!=m_rlcBufferReq.end ())
424  {
425  if ((*it).first.m_rnti == params.m_rnti)
426  {
427  temp = it;
428  it++;
429  m_rlcBufferReq.erase (temp);
430  }
431  else
432  {
433  it++;
434  }
435  }
436  if (m_nextRntiUl == params.m_rnti)
437  {
438  m_nextRntiUl = 0;
439  }
440 
441  return;
442 }
443 
444 
445 void
447 {
448  NS_LOG_FUNCTION (this << params.m_rnti << (uint32_t) params.m_logicalChannelIdentity);
449  // API generated by RLC for updating RLC parameters on a LC (tx and retx queues)
450 
451  std::map <LteFlowId_t, FfMacSchedSapProvider::SchedDlRlcBufferReqParameters>::iterator it;
452 
453  LteFlowId_t flow (params.m_rnti, params.m_logicalChannelIdentity);
454 
455  it = m_rlcBufferReq.find (flow);
456 
457  if (it == m_rlcBufferReq.end ())
458  {
459  m_rlcBufferReq.insert (std::pair <LteFlowId_t, FfMacSchedSapProvider::SchedDlRlcBufferReqParameters> (flow, params));
460  }
461  else
462  {
463  (*it).second = params;
464  }
465 
466  return;
467 }
468 
469 void
471 {
472  NS_LOG_FUNCTION (this);
473  NS_FATAL_ERROR ("method not implemented");
474  return;
475 }
476 
477 void
479 {
480  NS_LOG_FUNCTION (this);
481  NS_FATAL_ERROR ("method not implemented");
482  return;
483 }
484 
485 int
487 {
488  for (int i = 0; i < 4; i++)
489  {
490  if (dlbandwidth < PfType0AllocationRbg[i])
491  {
492  return (i + 1);
493  }
494  }
495 
496  return (-1);
497 }
498 
499 
500 int
502 {
503  std::map <LteFlowId_t, FfMacSchedSapProvider::SchedDlRlcBufferReqParameters>::iterator it;
504  int lcActive = 0;
505  for (it = m_rlcBufferReq.begin (); it != m_rlcBufferReq.end (); it++)
506  {
507  if (((*it).first.m_rnti == rnti) && (((*it).second.m_rlcTransmissionQueueSize > 0)
508  || ((*it).second.m_rlcRetransmissionQueueSize > 0)
509  || ((*it).second.m_rlcStatusPduSize > 0) ))
510  {
511  lcActive++;
512  }
513  if ((*it).first.m_rnti > rnti)
514  {
515  break;
516  }
517  }
518  return (lcActive);
519 
520 }
521 
522 
523 uint8_t
525 {
526  NS_LOG_FUNCTION (this << rnti);
527 
528  std::map <uint16_t, uint8_t>::iterator it = m_dlHarqCurrentProcessId.find (rnti);
529  if (it == m_dlHarqCurrentProcessId.end ())
530  {
531  NS_FATAL_ERROR ("No Process Id found for this RNTI " << rnti);
532  }
533  std::map <uint16_t, DlHarqProcessesStatus_t>::iterator itStat = m_dlHarqProcessesStatus.find (rnti);
534  if (itStat == m_dlHarqProcessesStatus.end ())
535  {
536  NS_FATAL_ERROR ("No Process Id Statusfound for this RNTI " << rnti);
537  }
538  uint8_t i = (*it).second;
539  do
540  {
541  i = (i + 1) % HARQ_PROC_NUM;
542  }
543  while ( ((*itStat).second.at (i) != 0)&&(i != (*it).second));
544  if ((*itStat).second.at (i) == 0)
545  {
546  return (true);
547  }
548  else
549  {
550  return (false); // return a not valid harq proc id
551  }
552 }
553 
554 
555 
556 uint8_t
558 {
559  NS_LOG_FUNCTION (this << rnti);
560 
561  if (m_harqOn == false)
562  {
563  return (0);
564  }
565 
566 
567  std::map <uint16_t, uint8_t>::iterator it = m_dlHarqCurrentProcessId.find (rnti);
568  if (it == m_dlHarqCurrentProcessId.end ())
569  {
570  NS_FATAL_ERROR ("No Process Id found for this RNTI " << rnti);
571  }
572  std::map <uint16_t, DlHarqProcessesStatus_t>::iterator itStat = m_dlHarqProcessesStatus.find (rnti);
573  if (itStat == m_dlHarqProcessesStatus.end ())
574  {
575  NS_FATAL_ERROR ("No Process Id Statusfound for this RNTI " << rnti);
576  }
577  uint8_t i = (*it).second;
578  do
579  {
580  i = (i + 1) % HARQ_PROC_NUM;
581  }
582  while ( ((*itStat).second.at (i) != 0)&&(i != (*it).second));
583  if ((*itStat).second.at (i) == 0)
584  {
585  (*it).second = i;
586  (*itStat).second.at (i) = 1;
587  }
588  else
589  {
590  NS_FATAL_ERROR ("No HARQ process available for RNTI " << rnti << " check before update with HarqProcessAvailability");
591  }
592 
593  return ((*it).second);
594 }
595 
596 
597 void
599 {
600  NS_LOG_FUNCTION (this);
601 
602  std::map <uint16_t, DlHarqProcessesTimer_t>::iterator itTimers;
603  for (itTimers = m_dlHarqProcessesTimer.begin (); itTimers != m_dlHarqProcessesTimer.end (); itTimers ++)
604  {
605  for (uint16_t i = 0; i < HARQ_PROC_NUM; i++)
606  {
607  if ((*itTimers).second.at (i) == HARQ_DL_TIMEOUT)
608  {
609  // reset HARQ process
610 
611  NS_LOG_DEBUG (this << " Reset HARQ proc " << i << " for RNTI " << (*itTimers).first);
612  std::map <uint16_t, DlHarqProcessesStatus_t>::iterator itStat = m_dlHarqProcessesStatus.find ((*itTimers).first);
613  if (itStat == m_dlHarqProcessesStatus.end ())
614  {
615  NS_FATAL_ERROR ("No Process Id Status found for this RNTI " << (*itTimers).first);
616  }
617  (*itStat).second.at (i) = 0;
618  (*itTimers).second.at (i) = 0;
619  }
620  else
621  {
622  (*itTimers).second.at (i)++;
623  }
624  }
625  }
626 
627 }
628 
629 
630 void
632 {
633  NS_LOG_FUNCTION (this << " Frame no. " << (params.m_sfnSf >> 4) << " subframe no. " << (0xF & params.m_sfnSf));
634  // API generated by RLC for triggering the scheduling of a DL subframe
635 
636 
637  // evaluate the relative channel quality indicator for each UE per each RBG
638  // (since we are using allocation type 0 the small unit of allocation is RBG)
639  // Resource allocation type 0 (see sec 7.1.6.1 of 36.213)
640 
641  RefreshDlCqiMaps ();
642 
644  int rbgNum = m_cschedCellConfig.m_dlBandwidth / rbgSize;
645  std::map <uint16_t, std::vector <uint16_t> > allocationMap; // RBs map per RNTI
646  std::vector <bool> rbgMap; // global RBGs map
647  uint16_t rbgAllocatedNum = 0;
648  std::set <uint16_t> rntiAllocated;
649  rbgMap.resize (m_cschedCellConfig.m_dlBandwidth / rbgSize, false);
651 
652  // update UL HARQ proc id
653  std::map <uint16_t, uint8_t>::iterator itProcId;
654  for (itProcId = m_ulHarqCurrentProcessId.begin (); itProcId != m_ulHarqCurrentProcessId.end (); itProcId++)
655  {
656  (*itProcId).second = ((*itProcId).second + 1) % HARQ_PROC_NUM;
657  }
658 
659 
660  // RACH Allocation
662  uint16_t rbStart = 0;
663  std::vector <struct RachListElement_s>::iterator itRach;
664  for (itRach = m_rachList.begin (); itRach != m_rachList.end (); itRach++)
665  {
666  NS_ASSERT_MSG (m_amc->GetTbSizeFromMcs (m_ulGrantMcs, m_cschedCellConfig.m_ulBandwidth) > (*itRach).m_estimatedSize, " Default UL Grant MCS does not allow to send RACH messages");
667  BuildRarListElement_s newRar;
668  newRar.m_rnti = (*itRach).m_rnti;
669  // DL-RACH Allocation
670  // Ideal: no needs of configuring m_dci
671  // UL-RACH Allocation
672  newRar.m_grant.m_rnti = newRar.m_rnti;
673  newRar.m_grant.m_mcs = m_ulGrantMcs;
674  uint16_t rbLen = 1;
675  uint16_t tbSizeBits = 0;
676  // find lowest TB size that fits UL grant estimated size
677  while ((tbSizeBits < (*itRach).m_estimatedSize) && (rbStart + rbLen < m_cschedCellConfig.m_ulBandwidth))
678  {
679  rbLen++;
680  tbSizeBits = m_amc->GetTbSizeFromMcs (m_ulGrantMcs, rbLen);
681  }
682  if (tbSizeBits < (*itRach).m_estimatedSize)
683  {
684  // no more allocation space: finish allocation
685  break;
686  }
687  newRar.m_grant.m_rbStart = rbStart;
688  newRar.m_grant.m_rbLen = rbLen;
689  newRar.m_grant.m_tbSize = tbSizeBits / 8;
690  newRar.m_grant.m_hopping = false;
691  newRar.m_grant.m_tpc = 0;
692  newRar.m_grant.m_cqiRequest = false;
693  newRar.m_grant.m_ulDelay = false;
694  NS_LOG_INFO (this << " UL grant allocated to RNTI " << (*itRach).m_rnti << " rbStart " << rbStart << " rbLen " << rbLen << " MCS " << m_ulGrantMcs << " tbSize " << newRar.m_grant.m_tbSize);
695  for (uint16_t i = rbStart; i < rbStart + rbLen; i++)
696  {
697  m_rachAllocationMap.at (i) = (*itRach).m_rnti;
698  }
699  rbStart = rbStart + rbLen;
700 
701  if (m_harqOn == true)
702  {
703  // generate UL-DCI for HARQ retransmissions
704  UlDciListElement_s uldci;
705  uldci.m_rnti = newRar.m_rnti;
706  uldci.m_rbLen = rbLen;
707  uldci.m_rbStart = rbStart;
708  uldci.m_mcs = m_ulGrantMcs;
709  uldci.m_tbSize = tbSizeBits / 8;
710  uldci.m_ndi = 1;
711  uldci.m_cceIndex = 0;
712  uldci.m_aggrLevel = 1;
713  uldci.m_ueTxAntennaSelection = 3; // antenna selection OFF
714  uldci.m_hopping = false;
715  uldci.m_n2Dmrs = 0;
716  uldci.m_tpc = 0; // no power control
717  uldci.m_cqiRequest = false; // only period CQI at this stage
718  uldci.m_ulIndex = 0; // TDD parameter
719  uldci.m_dai = 1; // TDD parameter
720  uldci.m_freqHopping = 0;
721  uldci.m_pdcchPowerOffset = 0; // not used
722 
723  uint8_t harqId = 0;
724  std::map <uint16_t, uint8_t>::iterator itProcId;
725  itProcId = m_ulHarqCurrentProcessId.find (uldci.m_rnti);
726  if (itProcId == m_ulHarqCurrentProcessId.end ())
727  {
728  NS_FATAL_ERROR ("No info find in HARQ buffer for UE " << uldci.m_rnti);
729  }
730  harqId = (*itProcId).second;
731  std::map <uint16_t, UlHarqProcessesDciBuffer_t>::iterator itDci = m_ulHarqProcessesDciBuffer.find (uldci.m_rnti);
732  if (itDci == m_ulHarqProcessesDciBuffer.end ())
733  {
734  NS_FATAL_ERROR ("Unable to find RNTI entry in UL DCI HARQ buffer for RNTI " << uldci.m_rnti);
735  }
736  (*itDci).second.at (harqId) = uldci;
737  }
738 
739  ret.m_buildRarList.push_back (newRar);
740  }
741  m_rachList.clear ();
742 
743 
744  // Process DL HARQ feedback
746  // retrieve past HARQ retx buffered
747  if (m_dlInfoListBuffered.size () > 0)
748  {
749  if (params.m_dlInfoList.size () > 0)
750  {
751  NS_LOG_INFO (this << " Received DL-HARQ feedback");
752  m_dlInfoListBuffered.insert (m_dlInfoListBuffered.end (), params.m_dlInfoList.begin (), params.m_dlInfoList.end ());
753  }
754  }
755  else
756  {
757  if (params.m_dlInfoList.size () > 0)
758  {
760  }
761  }
762  if (m_harqOn == false)
763  {
764  // Ignore HARQ feedback
765  m_dlInfoListBuffered.clear ();
766  }
767  std::vector <struct DlInfoListElement_s> dlInfoListUntxed;
768  for (uint16_t i = 0; i < m_dlInfoListBuffered.size (); i++)
769  {
770  std::set <uint16_t>::iterator itRnti = rntiAllocated.find (m_dlInfoListBuffered.at (i).m_rnti);
771  if (itRnti != rntiAllocated.end ())
772  {
773  // RNTI already allocated for retx
774  continue;
775  }
776  uint8_t nLayers = m_dlInfoListBuffered.at (i).m_harqStatus.size ();
777  std::vector <bool> retx;
778  NS_LOG_INFO (this << " Processing DLHARQ feedback");
779  if (nLayers == 1)
780  {
781  retx.push_back (m_dlInfoListBuffered.at (i).m_harqStatus.at (0) == DlInfoListElement_s::NACK);
782  retx.push_back (false);
783  }
784  else
785  {
786  retx.push_back (m_dlInfoListBuffered.at (i).m_harqStatus.at (0) == DlInfoListElement_s::NACK);
787  retx.push_back (m_dlInfoListBuffered.at (i).m_harqStatus.at (1) == DlInfoListElement_s::NACK);
788  }
789  if (retx.at (0) || retx.at (1))
790  {
791  // retrieve HARQ process information
792  uint16_t rnti = m_dlInfoListBuffered.at (i).m_rnti;
793  uint8_t harqId = m_dlInfoListBuffered.at (i).m_harqProcessId;
794  NS_LOG_INFO (this << " HARQ retx RNTI " << rnti << " harqId " << (uint16_t)harqId);
795  std::map <uint16_t, DlHarqProcessesDciBuffer_t>::iterator itHarq = m_dlHarqProcessesDciBuffer.find (rnti);
796  if (itHarq == m_dlHarqProcessesDciBuffer.end ())
797  {
798  NS_FATAL_ERROR ("No info find in HARQ buffer for UE " << rnti);
799  }
800 
801  DlDciListElement_s dci = (*itHarq).second.at (harqId);
802  int rv = 0;
803  if (dci.m_rv.size () == 1)
804  {
805  rv = dci.m_rv.at (0);
806  }
807  else
808  {
809  rv = (dci.m_rv.at (0) > dci.m_rv.at (1) ? dci.m_rv.at (0) : dci.m_rv.at (1));
810  }
811 
812  if (rv == 3)
813  {
814  // maximum number of retx reached -> drop process
815  NS_LOG_INFO ("Maximum number of retransmissions reached -> drop process");
816  std::map <uint16_t, DlHarqProcessesStatus_t>::iterator it = m_dlHarqProcessesStatus.find (rnti);
817  if (it == m_dlHarqProcessesStatus.end ())
818  {
819  NS_LOG_ERROR ("No info find in HARQ buffer for UE (might change eNB) " << m_dlInfoListBuffered.at (i).m_rnti);
820  }
821  (*it).second.at (harqId) = 0;
822  std::map <uint16_t, DlHarqRlcPduListBuffer_t>::iterator itRlcPdu = m_dlHarqProcessesRlcPduListBuffer.find (rnti);
823  if (itRlcPdu == m_dlHarqProcessesRlcPduListBuffer.end ())
824  {
825  NS_FATAL_ERROR ("Unable to find RlcPdcList in HARQ buffer for RNTI " << m_dlInfoListBuffered.at (i).m_rnti);
826  }
827  for (uint16_t k = 0; k < (*itRlcPdu).second.size (); k++)
828  {
829  (*itRlcPdu).second.at (k).at (harqId).clear ();
830  }
831  continue;
832  }
833  // check the feasibility of retransmitting on the same RBGs
834  // translate the DCI to Spectrum framework
835  std::vector <int> dciRbg;
836  uint32_t mask = 0x1;
837  NS_LOG_INFO ("Original RBGs " << dci.m_rbBitmap << " rnti " << dci.m_rnti);
838  for (int j = 0; j < 32; j++)
839  {
840  if (((dci.m_rbBitmap & mask) >> j) == 1)
841  {
842  dciRbg.push_back (j);
843  NS_LOG_INFO ("\t" << j);
844  }
845  mask = (mask << 1);
846  }
847  bool free = true;
848  for (uint8_t j = 0; j < dciRbg.size (); j++)
849  {
850  if (rbgMap.at (dciRbg.at (j)) == true)
851  {
852  free = false;
853  break;
854  }
855  }
856  if (free)
857  {
858  // use the same RBGs for the retx
859  // reserve RBGs
860  for (uint8_t j = 0; j < dciRbg.size (); j++)
861  {
862  rbgMap.at (dciRbg.at (j)) = true;
863  NS_LOG_INFO ("RBG " << dciRbg.at (j) << " assigned");
864  rbgAllocatedNum++;
865  }
866 
867  NS_LOG_INFO (this << " Send retx in the same RBGs");
868  }
869  else
870  {
871  // find RBGs for sending HARQ retx
872  uint8_t j = 0;
873  uint8_t rbgId = (dciRbg.at (dciRbg.size () - 1) + 1) % rbgNum;
874  uint8_t startRbg = dciRbg.at (dciRbg.size () - 1);
875  std::vector <bool> rbgMapCopy = rbgMap;
876  while ((j < dciRbg.size ())&&(startRbg != rbgId))
877  {
878  if (rbgMapCopy.at (rbgId) == false)
879  {
880  rbgMapCopy.at (rbgId) = true;
881  dciRbg.at (j) = rbgId;
882  j++;
883  }
884  rbgId++;
885  }
886  if (j == dciRbg.size ())
887  {
888  // find new RBGs -> update DCI map
889  uint32_t rbgMask = 0;
890  for (uint16_t k = 0; k < dciRbg.size (); k++)
891  {
892  rbgMask = rbgMask + (0x1 << dciRbg.at (k));
893  rbgAllocatedNum++;
894  }
895  dci.m_rbBitmap = rbgMask;
896  rbgMap = rbgMapCopy;
897  NS_LOG_INFO (this << " Move retx in RBGs " << dciRbg.size ());
898  }
899  else
900  {
901  // HARQ retx cannot be performed on this TTI -> store it
902  dlInfoListUntxed.push_back (params.m_dlInfoList.at (i));
903  NS_LOG_INFO (this << " No resource for this retx -> buffer it");
904  }
905  }
906  // retrieve RLC PDU list for retx TBsize and update DCI
908  std::map <uint16_t, DlHarqRlcPduListBuffer_t>::iterator itRlcPdu = m_dlHarqProcessesRlcPduListBuffer.find (rnti);
909  if (itRlcPdu == m_dlHarqProcessesRlcPduListBuffer.end ())
910  {
911  NS_FATAL_ERROR ("Unable to find RlcPdcList in HARQ buffer for RNTI " << rnti);
912  }
913  for (uint8_t j = 0; j < nLayers; j++)
914  {
915  if (retx.at (j))
916  {
917  if (j >= dci.m_ndi.size ())
918  {
919  // for avoiding errors in MIMO transient phases
920  dci.m_ndi.push_back (0);
921  dci.m_rv.push_back (0);
922  dci.m_mcs.push_back (0);
923  dci.m_tbsSize.push_back (0);
924  NS_LOG_INFO (this << " layer " << (uint16_t)j << " no txed (MIMO transition)");
925  }
926  else
927  {
928  dci.m_ndi.at (j) = 0;
929  dci.m_rv.at (j)++;
930  (*itHarq).second.at (harqId).m_rv.at (j)++;
931  NS_LOG_INFO (this << " layer " << (uint16_t)j << " RV " << (uint16_t)dci.m_rv.at (j));
932  }
933  }
934  else
935  {
936  // empty TB of layer j
937  dci.m_ndi.at (j) = 0;
938  dci.m_rv.at (j) = 0;
939  dci.m_mcs.at (j) = 0;
940  dci.m_tbsSize.at (j) = 0;
941  NS_LOG_INFO (this << " layer " << (uint16_t)j << " no retx");
942  }
943  }
944  for (uint16_t k = 0; k < (*itRlcPdu).second.at (0).at (dci.m_harqProcess).size (); k++)
945  {
946  std::vector <struct RlcPduListElement_s> rlcPduListPerLc;
947  for (uint8_t j = 0; j < nLayers; j++)
948  {
949  if (retx.at (j))
950  {
951  if (j < dci.m_ndi.size ())
952  {
953  rlcPduListPerLc.push_back ((*itRlcPdu).second.at (j).at (dci.m_harqProcess).at (k));
954  }
955  }
956  }
957 
958  if (rlcPduListPerLc.size () > 0)
959  {
960  newEl.m_rlcPduList.push_back (rlcPduListPerLc);
961  }
962  }
963  newEl.m_rnti = rnti;
964  newEl.m_dci = dci;
965  (*itHarq).second.at (harqId).m_rv = dci.m_rv;
966  // refresh timer
967  std::map <uint16_t, DlHarqProcessesTimer_t>::iterator itHarqTimer = m_dlHarqProcessesTimer.find (rnti);
968  if (itHarqTimer== m_dlHarqProcessesTimer.end ())
969  {
970  NS_FATAL_ERROR ("Unable to find HARQ timer for RNTI " << (uint16_t)rnti);
971  }
972  (*itHarqTimer).second.at (harqId) = 0;
973  ret.m_buildDataList.push_back (newEl);
974  rntiAllocated.insert (rnti);
975  }
976  else
977  {
978  // update HARQ process status
979  NS_LOG_INFO (this << " HARQ received ACK for UE " << m_dlInfoListBuffered.at (i).m_rnti);
980  std::map <uint16_t, DlHarqProcessesStatus_t>::iterator it = m_dlHarqProcessesStatus.find (m_dlInfoListBuffered.at (i).m_rnti);
981  if (it == m_dlHarqProcessesStatus.end ())
982  {
983  NS_FATAL_ERROR ("No info find in HARQ buffer for UE " << m_dlInfoListBuffered.at (i).m_rnti);
984  }
985  (*it).second.at (m_dlInfoListBuffered.at (i).m_harqProcessId) = 0;
986  std::map <uint16_t, DlHarqRlcPduListBuffer_t>::iterator itRlcPdu = m_dlHarqProcessesRlcPduListBuffer.find (m_dlInfoListBuffered.at (i).m_rnti);
987  if (itRlcPdu == m_dlHarqProcessesRlcPduListBuffer.end ())
988  {
989  NS_FATAL_ERROR ("Unable to find RlcPdcList in HARQ buffer for RNTI " << m_dlInfoListBuffered.at (i).m_rnti);
990  }
991  for (uint16_t k = 0; k < (*itRlcPdu).second.size (); k++)
992  {
993  (*itRlcPdu).second.at (k).at (m_dlInfoListBuffered.at (i).m_harqProcessId).clear ();
994  }
995  }
996  }
997  m_dlInfoListBuffered.clear ();
998  m_dlInfoListBuffered = dlInfoListUntxed;
999 
1000  if (rbgAllocatedNum == rbgNum)
1001  {
1002  // all the RBGs are already allocated -> exit
1003  if ((ret.m_buildDataList.size () > 0) || (ret.m_buildRarList.size () > 0))
1004  {
1006  }
1007  return;
1008  }
1009 
1010 
1011 
1012  for (int i = 0; i < rbgNum; i++)
1013  {
1014  NS_LOG_INFO (this << " ALLOCATION for RBG " << i << " of " << rbgNum);
1015  if (rbgMap.at (i) == false)
1016  {
1017  std::map <uint16_t, pfsFlowPerf_t>::iterator it;
1018  std::map <uint16_t, pfsFlowPerf_t>::iterator itMax = m_flowStatsDl.end ();
1019  double rcqiMax = 0.0;
1020  for (it = m_flowStatsDl.begin (); it != m_flowStatsDl.end (); it++)
1021  {
1022  std::set <uint16_t>::iterator itRnti = rntiAllocated.find ((*it).first);
1023  if ((itRnti != rntiAllocated.end ())||(!HarqProcessAvailability ((*it).first)))
1024  {
1025  // UE already allocated for HARQ or without HARQ process available -> drop it
1026  if (itRnti != rntiAllocated.end ())
1027  {
1028  NS_LOG_DEBUG (this << " RNTI discared for HARQ tx" << (uint16_t)(*it).first);
1029  }
1030  if (!HarqProcessAvailability ((*it).first))
1031  {
1032  NS_LOG_DEBUG (this << " RNTI discared for HARQ id" << (uint16_t)(*it).first);
1033  }
1034  continue;
1035  }
1036  std::map <uint16_t,SbMeasResult_s>::iterator itCqi;
1037  itCqi = m_a30CqiRxed.find ((*it).first);
1038  std::map <uint16_t,uint8_t>::iterator itTxMode;
1039  itTxMode = m_uesTxMode.find ((*it).first);
1040  if (itTxMode == m_uesTxMode.end ())
1041  {
1042  NS_FATAL_ERROR ("No Transmission Mode info on user " << (*it).first);
1043  }
1044  int nLayer = TransmissionModesLayers::TxMode2LayerNum ((*itTxMode).second);
1045  std::vector <uint8_t> sbCqi;
1046  if (itCqi == m_a30CqiRxed.end ())
1047  {
1048  for (uint8_t k = 0; k < nLayer; k++)
1049  {
1050  sbCqi.push_back (1); // start with lowest value
1051  }
1052  }
1053  else
1054  {
1055  sbCqi = (*itCqi).second.m_higherLayerSelected.at (i).m_sbCqi;
1056  }
1057  uint8_t cqi1 = sbCqi.at (0);
1058  uint8_t cqi2 = 1;
1059  if (sbCqi.size () > 1)
1060  {
1061  cqi2 = sbCqi.at (1);
1062  }
1063 
1064  if ((cqi1 > 0)||(cqi2 > 0)) // CQI == 0 means "out of range" (see table 7.2.3-1 of 36.213)
1065  {
1066  if (LcActivePerFlow ((*it).first) > 0)
1067  {
1068  // this UE has data to transmit
1069  double achievableRate = 0.0;
1070  uint8_t mcs = 0;
1071  for (uint8_t k = 0; k < nLayer; k++)
1072  {
1073  if (sbCqi.size () > k)
1074  {
1075  mcs = m_amc->GetMcsFromCqi (sbCqi.at (k));
1076  }
1077  else
1078  {
1079  // no info on this subband -> worst MCS
1080  mcs = 0;
1081  }
1082  achievableRate += ((m_amc->GetTbSizeFromMcs (mcs, rbgSize) / 8) / 0.001); // = TB size / TTI
1083  }
1084 
1085  double rcqi = achievableRate / (*it).second.lastAveragedThroughput;
1086  NS_LOG_INFO (this << " RNTI " << (*it).first << " MCS " << (uint32_t)mcs << " achievableRate " << achievableRate << " avgThr " << (*it).second.lastAveragedThroughput << " RCQI " << rcqi);
1087 
1088  if (rcqi > rcqiMax)
1089  {
1090  rcqiMax = rcqi;
1091  itMax = it;
1092  }
1093  }
1094  } // end if cqi
1095  } // end for m_rlcBufferReq
1096 
1097  if (itMax == m_flowStatsDl.end ())
1098  {
1099  // no UE available for this RB
1100  NS_LOG_INFO (this << " any UE found");
1101  }
1102  else
1103  {
1104  rbgMap.at (i) = true;
1105  std::map <uint16_t, std::vector <uint16_t> >::iterator itMap;
1106  itMap = allocationMap.find ((*itMax).first);
1107  if (itMap == allocationMap.end ())
1108  {
1109  // insert new element
1110  std::vector <uint16_t> tempMap;
1111  tempMap.push_back (i);
1112  allocationMap.insert (std::pair <uint16_t, std::vector <uint16_t> > ((*itMax).first, tempMap));
1113  }
1114  else
1115  {
1116  (*itMap).second.push_back (i);
1117  }
1118  NS_LOG_INFO (this << " UE assigned " << (*itMax).first);
1119  }
1120  } // end for RBG free
1121  } // end for RBGs
1122 
1123  // reset TTI stats of users
1124  std::map <uint16_t, pfsFlowPerf_t>::iterator itStats;
1125  for (itStats = m_flowStatsDl.begin (); itStats != m_flowStatsDl.end (); itStats++)
1126  {
1127  (*itStats).second.lastTtiBytesTrasmitted = 0;
1128  }
1129 
1130  // generate the transmission opportunities by grouping the RBGs of the same RNTI and
1131  // creating the correspondent DCIs
1132  std::map <uint16_t, std::vector <uint16_t> >::iterator itMap = allocationMap.begin ();
1133  while (itMap != allocationMap.end ())
1134  {
1135  // create new BuildDataListElement_s for this LC
1136  BuildDataListElement_s newEl;
1137  newEl.m_rnti = (*itMap).first;
1138  // create the DlDciListElement_s
1139  DlDciListElement_s newDci;
1140  newDci.m_rnti = (*itMap).first;
1141  newDci.m_harqProcess = UpdateHarqProcessId ((*itMap).first);
1142 
1143  uint16_t lcActives = LcActivePerFlow ((*itMap).first);
1144  NS_LOG_INFO (this << "Allocate user " << newEl.m_rnti << " rbg " << lcActives);
1145  if (lcActives == 0)
1146  {
1147  // Set to max value, to avoid divide by 0 below
1148  lcActives = (uint16_t)65535; // UINT16_MAX;
1149  }
1150  uint16_t RgbPerRnti = (*itMap).second.size ();
1151  std::map <uint16_t,SbMeasResult_s>::iterator itCqi;
1152  itCqi = m_a30CqiRxed.find ((*itMap).first);
1153  std::map <uint16_t,uint8_t>::iterator itTxMode;
1154  itTxMode = m_uesTxMode.find ((*itMap).first);
1155  if (itTxMode == m_uesTxMode.end ())
1156  {
1157  NS_FATAL_ERROR ("No Transmission Mode info on user " << (*itMap).first);
1158  }
1159  int nLayer = TransmissionModesLayers::TxMode2LayerNum ((*itTxMode).second);
1160  std::vector <uint8_t> worstCqi (2, 15);
1161  if (itCqi != m_a30CqiRxed.end ())
1162  {
1163  for (uint16_t k = 0; k < (*itMap).second.size (); k++)
1164  {
1165  if ((*itCqi).second.m_higherLayerSelected.size () > (*itMap).second.at (k))
1166  {
1167  NS_LOG_INFO (this << " RBG " << (*itMap).second.at (k) << " CQI " << (uint16_t)((*itCqi).second.m_higherLayerSelected.at ((*itMap).second.at (k)).m_sbCqi.at (0)) );
1168  for (uint8_t j = 0; j < nLayer; j++)
1169  {
1170  if ((*itCqi).second.m_higherLayerSelected.at ((*itMap).second.at (k)).m_sbCqi.size () > j)
1171  {
1172  if (((*itCqi).second.m_higherLayerSelected.at ((*itMap).second.at (k)).m_sbCqi.at (j)) < worstCqi.at (j))
1173  {
1174  worstCqi.at (j) = ((*itCqi).second.m_higherLayerSelected.at ((*itMap).second.at (k)).m_sbCqi.at (j));
1175  }
1176  }
1177  else
1178  {
1179  // no CQI for this layer of this suband -> worst one
1180  worstCqi.at (j) = 1;
1181  }
1182  }
1183  }
1184  else
1185  {
1186  for (uint8_t j = 0; j < nLayer; j++)
1187  {
1188  worstCqi.at (j) = 1; // try with lowest MCS in RBG with no info on channel
1189  }
1190  }
1191  }
1192  }
1193  else
1194  {
1195  for (uint8_t j = 0; j < nLayer; j++)
1196  {
1197  worstCqi.at (j) = 1; // try with lowest MCS in RBG with no info on channel
1198  }
1199  }
1200  for (uint8_t j = 0; j < nLayer; j++)
1201  {
1202  NS_LOG_INFO (this << " Layer " << (uint16_t)j << " CQI selected " << (uint16_t)worstCqi.at (j));
1203  }
1204  uint32_t bytesTxed = 0;
1205  for (uint8_t j = 0; j < nLayer; j++)
1206  {
1207  newDci.m_mcs.push_back (m_amc->GetMcsFromCqi (worstCqi.at (j)));
1208  int tbSize = (m_amc->GetTbSizeFromMcs (newDci.m_mcs.at (j), RgbPerRnti * rbgSize) / 8); // (size of TB in bytes according to table 7.1.7.2.1-1 of 36.213)
1209  newDci.m_tbsSize.push_back (tbSize);
1210  NS_LOG_INFO (this << " Layer " << (uint16_t)j << " MCS selected" << m_amc->GetMcsFromCqi (worstCqi.at (j)));
1211  bytesTxed += tbSize;
1212  }
1213 
1214  newDci.m_resAlloc = 0; // only allocation type 0 at this stage
1215  newDci.m_rbBitmap = 0; // TBD (32 bit bitmap see 7.1.6 of 36.213)
1216  uint32_t rbgMask = 0;
1217  for (uint16_t k = 0; k < (*itMap).second.size (); k++)
1218  {
1219  rbgMask = rbgMask + (0x1 << (*itMap).second.at (k));
1220  NS_LOG_INFO (this << " Allocated RBG " << (*itMap).second.at (k));
1221  }
1222  newDci.m_rbBitmap = rbgMask; // (32 bit bitmap see 7.1.6 of 36.213)
1223 
1224  // create the rlc PDUs -> equally divide resources among actives LCs
1225  std::map <LteFlowId_t, FfMacSchedSapProvider::SchedDlRlcBufferReqParameters>::iterator itBufReq;
1226  for (itBufReq = m_rlcBufferReq.begin (); itBufReq != m_rlcBufferReq.end (); itBufReq++)
1227  {
1228  if (((*itBufReq).first.m_rnti == (*itMap).first)
1229  && (((*itBufReq).second.m_rlcTransmissionQueueSize > 0)
1230  || ((*itBufReq).second.m_rlcRetransmissionQueueSize > 0)
1231  || ((*itBufReq).second.m_rlcStatusPduSize > 0) ))
1232  {
1233  std::vector <struct RlcPduListElement_s> newRlcPduLe;
1234  for (uint8_t j = 0; j < nLayer; j++)
1235  {
1236  RlcPduListElement_s newRlcEl;
1237  newRlcEl.m_logicalChannelIdentity = (*itBufReq).first.m_lcId;
1238  newRlcEl.m_size = newDci.m_tbsSize.at (j) / lcActives;
1239  NS_LOG_INFO (this << " LCID " << (uint32_t) newRlcEl.m_logicalChannelIdentity << " size " << newRlcEl.m_size << " layer " << (uint16_t)j);
1240  newRlcPduLe.push_back (newRlcEl);
1241  UpdateDlRlcBufferInfo (newDci.m_rnti, newRlcEl.m_logicalChannelIdentity, newRlcEl.m_size);
1242  if (m_harqOn == true)
1243  {
1244  // store RLC PDU list for HARQ
1245  std::map <uint16_t, DlHarqRlcPduListBuffer_t>::iterator itRlcPdu = m_dlHarqProcessesRlcPduListBuffer.find ((*itMap).first);
1246  if (itRlcPdu == m_dlHarqProcessesRlcPduListBuffer.end ())
1247  {
1248  NS_FATAL_ERROR ("Unable to find RlcPdcList in HARQ buffer for RNTI " << (*itMap).first);
1249  }
1250  (*itRlcPdu).second.at (j).at (newDci.m_harqProcess).push_back (newRlcEl);
1251  }
1252  }
1253  newEl.m_rlcPduList.push_back (newRlcPduLe);
1254  }
1255  if ((*itBufReq).first.m_rnti > (*itMap).first)
1256  {
1257  break;
1258  }
1259  }
1260  for (uint8_t j = 0; j < nLayer; j++)
1261  {
1262  newDci.m_ndi.push_back (1);
1263  newDci.m_rv.push_back (0);
1264  }
1265 
1266  newEl.m_dci = newDci;
1267 
1268  if (m_harqOn == true)
1269  {
1270  // store DCI for HARQ
1271  std::map <uint16_t, DlHarqProcessesDciBuffer_t>::iterator itDci = m_dlHarqProcessesDciBuffer.find (newEl.m_rnti);
1272  if (itDci == m_dlHarqProcessesDciBuffer.end ())
1273  {
1274  NS_FATAL_ERROR ("Unable to find RNTI entry in DCI HARQ buffer for RNTI " << newEl.m_rnti);
1275  }
1276  (*itDci).second.at (newDci.m_harqProcess) = newDci;
1277  // refresh timer
1278  std::map <uint16_t, DlHarqProcessesTimer_t>::iterator itHarqTimer = m_dlHarqProcessesTimer.find (newEl.m_rnti);
1279  if (itHarqTimer== m_dlHarqProcessesTimer.end ())
1280  {
1281  NS_FATAL_ERROR ("Unable to find HARQ timer for RNTI " << (uint16_t)newEl.m_rnti);
1282  }
1283  (*itHarqTimer).second.at (newDci.m_harqProcess) = 0;
1284  }
1285 
1286  // ...more parameters -> ingored in this version
1287 
1288  ret.m_buildDataList.push_back (newEl);
1289  // update UE stats
1290  std::map <uint16_t, pfsFlowPerf_t>::iterator it;
1291  it = m_flowStatsDl.find ((*itMap).first);
1292  if (it != m_flowStatsDl.end ())
1293  {
1294  (*it).second.lastTtiBytesTrasmitted = bytesTxed;
1295  NS_LOG_INFO (this << " UE total bytes txed " << (*it).second.lastTtiBytesTrasmitted);
1296 
1297 
1298  }
1299  else
1300  {
1301  NS_FATAL_ERROR (this << " No Stats for this allocated UE");
1302  }
1303 
1304  itMap++;
1305  } // end while allocation
1306  ret.m_nrOfPdcchOfdmSymbols = 1;
1307 
1308 
1309  // update UEs stats
1310  NS_LOG_INFO (this << " Update UEs statistics");
1311  for (itStats = m_flowStatsDl.begin (); itStats != m_flowStatsDl.end (); itStats++)
1312  {
1313  (*itStats).second.totalBytesTransmitted += (*itStats).second.lastTtiBytesTrasmitted;
1314  // update average throughput (see eq. 12.3 of Sec 12.3.1.2 of LTE – The UMTS Long Term Evolution, Ed Wiley)
1315  (*itStats).second.lastAveragedThroughput = ((1.0 - (1.0 / m_timeWindow)) * (*itStats).second.lastAveragedThroughput) + ((1.0 / m_timeWindow) * (double)((*itStats).second.lastTtiBytesTrasmitted / 0.001));
1316  NS_LOG_INFO (this << " UE total bytes " << (*itStats).second.totalBytesTransmitted);
1317  NS_LOG_INFO (this << " UE average throughput " << (*itStats).second.lastAveragedThroughput);
1318  (*itStats).second.lastTtiBytesTrasmitted = 0;
1319  }
1320 
1322 
1323 
1324  return;
1325 }
1326 
1327 void
1329 {
1330  NS_LOG_FUNCTION (this);
1331 
1332  m_rachList = params.m_rachList;
1333 
1334  return;
1335 }
1336 
1337 void
1339 {
1340  NS_LOG_FUNCTION (this);
1341 
1342  for (unsigned int i = 0; i < params.m_cqiList.size (); i++)
1343  {
1344  if ( params.m_cqiList.at (i).m_cqiType == CqiListElement_s::P10 )
1345  {
1346  // wideband CQI reporting
1347  std::map <uint16_t,uint8_t>::iterator it;
1348  uint16_t rnti = params.m_cqiList.at (i).m_rnti;
1349  it = m_p10CqiRxed.find (rnti);
1350  if (it == m_p10CqiRxed.end ())
1351  {
1352  // create the new entry
1353  m_p10CqiRxed.insert ( std::pair<uint16_t, uint8_t > (rnti, params.m_cqiList.at (i).m_wbCqi.at (0)) ); // only codeword 0 at this stage (SISO)
1354  // generate correspondent timer
1355  m_p10CqiTimers.insert ( std::pair<uint16_t, uint32_t > (rnti, m_cqiTimersThreshold));
1356  }
1357  else
1358  {
1359  // update the CQI value and refresh correspondent timer
1360  (*it).second = params.m_cqiList.at (i).m_wbCqi.at (0);
1361  // update correspondent timer
1362  std::map <uint16_t,uint32_t>::iterator itTimers;
1363  itTimers = m_p10CqiTimers.find (rnti);
1364  (*itTimers).second = m_cqiTimersThreshold;
1365  }
1366  }
1367  else if ( params.m_cqiList.at (i).m_cqiType == CqiListElement_s::A30 )
1368  {
1369  // subband CQI reporting high layer configured
1370  std::map <uint16_t,SbMeasResult_s>::iterator it;
1371  uint16_t rnti = params.m_cqiList.at (i).m_rnti;
1372  it = m_a30CqiRxed.find (rnti);
1373  if (it == m_a30CqiRxed.end ())
1374  {
1375  // create the new entry
1376  m_a30CqiRxed.insert ( std::pair<uint16_t, SbMeasResult_s > (rnti, params.m_cqiList.at (i).m_sbMeasResult) );
1377  m_a30CqiTimers.insert ( std::pair<uint16_t, uint32_t > (rnti, m_cqiTimersThreshold));
1378  }
1379  else
1380  {
1381  // update the CQI value and refresh correspondent timer
1382  (*it).second = params.m_cqiList.at (i).m_sbMeasResult;
1383  std::map <uint16_t,uint32_t>::iterator itTimers;
1384  itTimers = m_a30CqiTimers.find (rnti);
1385  (*itTimers).second = m_cqiTimersThreshold;
1386  }
1387  }
1388  else
1389  {
1390  NS_LOG_ERROR (this << " CQI type unknown");
1391  }
1392  }
1393 
1394  return;
1395 }
1396 
1397 
1398 double
1399 PfFfMacScheduler::EstimateUlSinr (uint16_t rnti, uint16_t rb)
1400 {
1401  std::map <uint16_t, std::vector <double> >::iterator itCqi = m_ueCqi.find (rnti);
1402  if (itCqi == m_ueCqi.end ())
1403  {
1404  // no cqi info about this UE
1405  return (NO_SINR);
1406 
1407  }
1408  else
1409  {
1410  // take the average SINR value among the available
1411  double sinrSum = 0;
1412  int sinrNum = 0;
1413  for (uint32_t i = 0; i < m_cschedCellConfig.m_ulBandwidth; i++)
1414  {
1415  double sinr = (*itCqi).second.at (i);
1416  if (sinr != NO_SINR)
1417  {
1418  sinrSum += sinr;
1419  sinrNum++;
1420  }
1421  }
1422  double estimatedSinr = (sinrNum > 0) ? (sinrSum / sinrNum) : DBL_MAX;
1423  // store the value
1424  (*itCqi).second.at (rb) = estimatedSinr;
1425  return (estimatedSinr);
1426  }
1427 }
1428 
1429 void
1431 {
1432  NS_LOG_FUNCTION (this << " UL - Frame no. " << (params.m_sfnSf >> 4) << " subframe no. " << (0xF & params.m_sfnSf) << " size " << params.m_ulInfoList.size ());
1433 
1434  RefreshUlCqiMaps ();
1435 
1436  // Generate RBs map
1438  std::vector <bool> rbMap;
1439  uint16_t rbAllocatedNum = 0;
1440  std::set <uint16_t> rntiAllocated;
1441  std::vector <uint16_t> rbgAllocationMap;
1442  // update with RACH allocation map
1443  rbgAllocationMap = m_rachAllocationMap;
1444  //rbgAllocationMap.resize (m_cschedCellConfig.m_ulBandwidth, 0);
1445  m_rachAllocationMap.clear ();
1447 
1448  rbMap.resize (m_cschedCellConfig.m_ulBandwidth, false);
1449  // remove RACH allocation
1450  for (uint16_t i = 0; i < m_cschedCellConfig.m_ulBandwidth; i++)
1451  {
1452  if (rbgAllocationMap.at (i) != 0)
1453  {
1454  rbMap.at (i) = true;
1455  NS_LOG_DEBUG (this << " Allocated for RACH " << i);
1456  }
1457  }
1458 
1459 
1460  if (m_harqOn == true)
1461  {
1462  // Process UL HARQ feedback
1463 
1464  for (uint16_t i = 0; i < params.m_ulInfoList.size (); i++)
1465  {
1466  if (params.m_ulInfoList.at (i).m_receptionStatus == UlInfoListElement_s::NotOk)
1467  {
1468  // retx correspondent block: retrieve the UL-DCI
1469  uint16_t rnti = params.m_ulInfoList.at (i).m_rnti;
1470  std::map <uint16_t, uint8_t>::iterator itProcId = m_ulHarqCurrentProcessId.find (rnti);
1471  if (itProcId == m_ulHarqCurrentProcessId.end ())
1472  {
1473  NS_LOG_ERROR ("No info find in HARQ buffer for UE (might change eNB) " << rnti);
1474  }
1475  uint8_t harqId = (uint8_t)((*itProcId).second - HARQ_PERIOD) % HARQ_PROC_NUM;
1476  NS_LOG_INFO (this << " UL-HARQ retx RNTI " << rnti << " harqId " << (uint16_t)harqId << " i " << i << " size " << params.m_ulInfoList.size ());
1477  std::map <uint16_t, UlHarqProcessesDciBuffer_t>::iterator itHarq = m_ulHarqProcessesDciBuffer.find (rnti);
1478  if (itHarq == m_ulHarqProcessesDciBuffer.end ())
1479  {
1480  NS_LOG_ERROR ("No info find in HARQ buffer for UE (might change eNB) " << rnti);
1481  continue;
1482  }
1483  UlDciListElement_s dci = (*itHarq).second.at (harqId);
1484  std::map <uint16_t, UlHarqProcessesStatus_t>::iterator itStat = m_ulHarqProcessesStatus.find (rnti);
1485  if (itStat == m_ulHarqProcessesStatus.end ())
1486  {
1487  NS_LOG_ERROR ("No info find in HARQ buffer for UE (might change eNB) " << rnti);
1488  }
1489  if ((*itStat).second.at (harqId) >= 3)
1490  {
1491  NS_LOG_INFO ("Max number of retransmissions reached (UL)-> drop process");
1492  continue;
1493  }
1494  bool free = true;
1495  for (int j = dci.m_rbStart; j < dci.m_rbStart + dci.m_rbLen; j++)
1496  {
1497  if (rbMap.at (j) == true)
1498  {
1499  free = false;
1500  NS_LOG_INFO (this << " BUSY " << j);
1501  }
1502  }
1503  if (free)
1504  {
1505  // retx on the same RBs
1506  for (int j = dci.m_rbStart; j < dci.m_rbStart + dci.m_rbLen; j++)
1507  {
1508  rbMap.at (j) = true;
1509  rbgAllocationMap.at (j) = dci.m_rnti;
1510  NS_LOG_INFO ("\tRB " << j);
1511  rbAllocatedNum++;
1512  }
1513  NS_LOG_INFO (this << " Send retx in the same RBs " << (uint16_t)dci.m_rbStart << " to " << dci.m_rbStart + dci.m_rbLen << " RV " << (*itStat).second.at (harqId) + 1);
1514  }
1515  else
1516  {
1517  NS_LOG_INFO ("Cannot allocate retx due to RACH allocations for UE " << rnti);
1518  continue;
1519  }
1520  dci.m_ndi = 0;
1521  // Update HARQ buffers with new HarqId
1522  (*itStat).second.at ((*itProcId).second) = (*itStat).second.at (harqId) + 1;
1523  (*itStat).second.at (harqId) = 0;
1524  (*itHarq).second.at ((*itProcId).second) = dci;
1525  ret.m_dciList.push_back (dci);
1526  rntiAllocated.insert (dci.m_rnti);
1527  }
1528  else
1529  {
1530  NS_LOG_INFO (this << " HARQ-ACK feedback from RNTI " << params.m_ulInfoList.at (i).m_rnti);
1531  }
1532  }
1533  }
1534 
1535  std::map <uint16_t,uint32_t>::iterator it;
1536  int nflows = 0;
1537 
1538  for (it = m_ceBsrRxed.begin (); it != m_ceBsrRxed.end (); it++)
1539  {
1540  std::set <uint16_t>::iterator itRnti = rntiAllocated.find ((*it).first);
1541  // select UEs with queues not empty and not yet allocated for HARQ
1542  if (((*it).second > 0)&&(itRnti == rntiAllocated.end ()))
1543  {
1544  nflows++;
1545  }
1546  }
1547 
1548  if (nflows == 0)
1549  {
1550  if (ret.m_dciList.size () > 0)
1551  {
1552  m_allocationMaps.insert (std::pair <uint16_t, std::vector <uint16_t> > (params.m_sfnSf, rbgAllocationMap));
1554  }
1555 
1556  return; // no flows to be scheduled
1557  }
1558 
1559 
1560  // Divide the remaining resources equally among the active users starting from the subsequent one served last scheduling trigger
1561  uint16_t rbPerFlow = (m_cschedCellConfig.m_ulBandwidth) / (nflows + rntiAllocated.size ());
1562  if (rbPerFlow < 3)
1563  {
1564  rbPerFlow = 3; // at least 3 rbg per flow (till available resource) to ensure TxOpportunity >= 7 bytes
1565  }
1566  int rbAllocated = 0;
1567 
1568  std::map <uint16_t, pfsFlowPerf_t>::iterator itStats;
1569  if (m_nextRntiUl != 0)
1570  {
1571  for (it = m_ceBsrRxed.begin (); it != m_ceBsrRxed.end (); it++)
1572  {
1573  if ((*it).first == m_nextRntiUl)
1574  {
1575  break;
1576  }
1577  }
1578  if (it == m_ceBsrRxed.end ())
1579  {
1580  NS_LOG_ERROR (this << " no user found");
1581  }
1582  }
1583  else
1584  {
1585  it = m_ceBsrRxed.begin ();
1586  m_nextRntiUl = (*it).first;
1587  }
1588  do
1589  {
1590  std::set <uint16_t>::iterator itRnti = rntiAllocated.find ((*it).first);
1591  if ((itRnti != rntiAllocated.end ())||((*it).second == 0))
1592  {
1593  // UE already allocated for UL-HARQ -> skip it
1594  NS_LOG_DEBUG (this << " UE already allocated in HARQ -> discared, RNTI " << (*it).first);
1595  it++;
1596  if (it == m_ceBsrRxed.end ())
1597  {
1598  // restart from the first
1599  it = m_ceBsrRxed.begin ();
1600  }
1601  continue;
1602  }
1603  if (rbAllocated + rbPerFlow - 1 > m_cschedCellConfig.m_ulBandwidth)
1604  {
1605  // limit to physical resources last resource assignment
1606  rbPerFlow = m_cschedCellConfig.m_ulBandwidth - rbAllocated;
1607  // at least 3 rbg per flow to ensure TxOpportunity >= 7 bytes
1608  if (rbPerFlow < 3)
1609  {
1610  // terminate allocation
1611  rbPerFlow = 0;
1612  }
1613  }
1614 
1615  UlDciListElement_s uldci;
1616  uldci.m_rnti = (*it).first;
1617  uldci.m_rbLen = rbPerFlow;
1618  bool allocated = false;
1619  NS_LOG_INFO (this << " RB Allocated " << rbAllocated << " rbPerFlow " << rbPerFlow << " flows " << nflows);
1620  while ((!allocated)&&((rbAllocated + rbPerFlow - m_cschedCellConfig.m_ulBandwidth) < 1) && (rbPerFlow != 0))
1621  {
1622  // check availability
1623  bool free = true;
1624  for (uint16_t j = rbAllocated; j < rbAllocated + rbPerFlow; j++)
1625  {
1626  if (rbMap.at (j) == true)
1627  {
1628  free = false;
1629  break;
1630  }
1631  }
1632  if (free)
1633  {
1634  uldci.m_rbStart = rbAllocated;
1635 
1636  for (uint16_t j = rbAllocated; j < rbAllocated + rbPerFlow; j++)
1637  {
1638  rbMap.at (j) = true;
1639  // store info on allocation for managing ul-cqi interpretation
1640  rbgAllocationMap.at (j) = (*it).first;
1641  }
1642  rbAllocated += rbPerFlow;
1643  allocated = true;
1644  break;
1645  }
1646  rbAllocated++;
1647  if (rbAllocated + rbPerFlow - 1 > m_cschedCellConfig.m_ulBandwidth)
1648  {
1649  // limit to physical resources last resource assignment
1650  rbPerFlow = m_cschedCellConfig.m_ulBandwidth - rbAllocated;
1651  // at least 3 rbg per flow to ensure TxOpportunity >= 7 bytes
1652  if (rbPerFlow < 3)
1653  {
1654  // terminate allocation
1655  rbPerFlow = 0;
1656  }
1657  }
1658  }
1659  if (!allocated)
1660  {
1661  // unable to allocate new resource: finish scheduling
1662  m_nextRntiUl = (*it).first;
1663  if (ret.m_dciList.size () > 0)
1664  {
1666  }
1667  m_allocationMaps.insert (std::pair <uint16_t, std::vector <uint16_t> > (params.m_sfnSf, rbgAllocationMap));
1668  return;
1669  }
1670 
1671 
1672 
1673  std::map <uint16_t, std::vector <double> >::iterator itCqi = m_ueCqi.find ((*it).first);
1674  int cqi = 0;
1675  if (itCqi == m_ueCqi.end ())
1676  {
1677  // no cqi info about this UE
1678  uldci.m_mcs = 0; // MCS 0 -> UL-AMC TBD
1679  }
1680  else
1681  {
1682  // take the lowest CQI value (worst RB)
1683  double minSinr = (*itCqi).second.at (uldci.m_rbStart);
1684  if (minSinr == NO_SINR)
1685  {
1686  minSinr = EstimateUlSinr ((*it).first, uldci.m_rbStart);
1687  }
1688  for (uint16_t i = uldci.m_rbStart; i < uldci.m_rbStart + uldci.m_rbLen; i++)
1689  {
1690  double sinr = (*itCqi).second.at (i);
1691  if (sinr == NO_SINR)
1692  {
1693  sinr = EstimateUlSinr ((*it).first, i);
1694  }
1695  if ((*itCqi).second.at (i) < minSinr)
1696  {
1697  minSinr = (*itCqi).second.at (i);
1698  }
1699  }
1700 
1701  // translate SINR -> cqi: WILD ACK: same as DL
1702  double s = log2 ( 1 + (
1703  std::pow (10, minSinr / 10 ) /
1704  ( (-std::log (5.0 * 0.00005 )) / 1.5) ));
1705  cqi = m_amc->GetCqiFromSpectralEfficiency (s);
1706  if (cqi == 0)
1707  {
1708  it++;
1709  if (it == m_ceBsrRxed.end ())
1710  {
1711  // restart from the first
1712  it = m_ceBsrRxed.begin ();
1713  }
1714  NS_LOG_DEBUG (this << " UE discared for CQI=0, RNTI " << uldci.m_rnti);
1715  // remove UE from allocation map
1716  for (uint16_t i = uldci.m_rbStart; i < uldci.m_rbStart + uldci.m_rbLen; i++)
1717  {
1718  rbgAllocationMap.at (i) = 0;
1719  }
1720  continue; // CQI == 0 means "out of range" (see table 7.2.3-1 of 36.213)
1721  }
1722  uldci.m_mcs = m_amc->GetMcsFromCqi (cqi);
1723  }
1724 
1725  uldci.m_tbSize = (m_amc->GetTbSizeFromMcs (uldci.m_mcs, rbPerFlow) / 8);
1726  UpdateUlRlcBufferInfo (uldci.m_rnti, uldci.m_tbSize);
1727  uldci.m_ndi = 1;
1728  uldci.m_cceIndex = 0;
1729  uldci.m_aggrLevel = 1;
1730  uldci.m_ueTxAntennaSelection = 3; // antenna selection OFF
1731  uldci.m_hopping = false;
1732  uldci.m_n2Dmrs = 0;
1733  uldci.m_tpc = 0; // no power control
1734  uldci.m_cqiRequest = false; // only period CQI at this stage
1735  uldci.m_ulIndex = 0; // TDD parameter
1736  uldci.m_dai = 1; // TDD parameter
1737  uldci.m_freqHopping = 0;
1738  uldci.m_pdcchPowerOffset = 0; // not used
1739  ret.m_dciList.push_back (uldci);
1740  // store DCI for HARQ_PERIOD
1741  uint8_t harqId = 0;
1742  if (m_harqOn == true)
1743  {
1744  std::map <uint16_t, uint8_t>::iterator itProcId;
1745  itProcId = m_ulHarqCurrentProcessId.find (uldci.m_rnti);
1746  if (itProcId == m_ulHarqCurrentProcessId.end ())
1747  {
1748  NS_FATAL_ERROR ("No info find in HARQ buffer for UE " << uldci.m_rnti);
1749  }
1750  harqId = (*itProcId).second;
1751  std::map <uint16_t, UlHarqProcessesDciBuffer_t>::iterator itDci = m_ulHarqProcessesDciBuffer.find (uldci.m_rnti);
1752  if (itDci == m_ulHarqProcessesDciBuffer.end ())
1753  {
1754  NS_FATAL_ERROR ("Unable to find RNTI entry in UL DCI HARQ buffer for RNTI " << uldci.m_rnti);
1755  }
1756  (*itDci).second.at (harqId) = uldci;
1757  }
1758 
1759  NS_LOG_INFO (this << " UE Allocation RNTI " << (*it).first << " startPRB " << (uint32_t)uldci.m_rbStart << " nPRB " << (uint32_t)uldci.m_rbLen << " CQI " << cqi << " MCS " << (uint32_t)uldci.m_mcs << " TBsize " << uldci.m_tbSize << " RbAlloc " << rbAllocated << " harqId " << (uint16_t)harqId);
1760 
1761  // update TTI UE stats
1762  itStats = m_flowStatsUl.find ((*it).first);
1763  if (itStats != m_flowStatsUl.end ())
1764  {
1765  (*itStats).second.lastTtiBytesTrasmitted = uldci.m_tbSize;
1766  }
1767  else
1768  {
1769  NS_LOG_DEBUG (this << " No Stats for this allocated UE");
1770  }
1771 
1772 
1773  it++;
1774  if (it == m_ceBsrRxed.end ())
1775  {
1776  // restart from the first
1777  it = m_ceBsrRxed.begin ();
1778  }
1779  if ((rbAllocated == m_cschedCellConfig.m_ulBandwidth) || (rbPerFlow == 0))
1780  {
1781  // Stop allocation: no more PRBs
1782  m_nextRntiUl = (*it).first;
1783  break;
1784  }
1785  }
1786  while (((*it).first != m_nextRntiUl)&&(rbPerFlow!=0));
1787 
1788 
1789  // Update global UE stats
1790  // update UEs stats
1791  for (itStats = m_flowStatsUl.begin (); itStats != m_flowStatsUl.end (); itStats++)
1792  {
1793  (*itStats).second.totalBytesTransmitted += (*itStats).second.lastTtiBytesTrasmitted;
1794  // update average throughput (see eq. 12.3 of Sec 12.3.1.2 of LTE – The UMTS Long Term Evolution, Ed Wiley)
1795  (*itStats).second.lastAveragedThroughput = ((1.0 - (1.0 / m_timeWindow)) * (*itStats).second.lastAveragedThroughput) + ((1.0 / m_timeWindow) * (double)((*itStats).second.lastTtiBytesTrasmitted / 0.001));
1796  NS_LOG_INFO (this << " UE total bytes " << (*itStats).second.totalBytesTransmitted);
1797  NS_LOG_INFO (this << " UE average throughput " << (*itStats).second.lastAveragedThroughput);
1798  (*itStats).second.lastTtiBytesTrasmitted = 0;
1799  }
1800  m_allocationMaps.insert (std::pair <uint16_t, std::vector <uint16_t> > (params.m_sfnSf, rbgAllocationMap));
1802 
1803  return;
1804 }
1805 
1806 void
1808 {
1809  NS_LOG_FUNCTION (this);
1810  return;
1811 }
1812 
1813 void
1815 {
1816  NS_LOG_FUNCTION (this);
1817  return;
1818 }
1819 
1820 void
1822 {
1823  NS_LOG_FUNCTION (this);
1824 
1825  std::map <uint16_t,uint32_t>::iterator it;
1826 
1827  for (unsigned int i = 0; i < params.m_macCeList.size (); i++)
1828  {
1829  if ( params.m_macCeList.at (i).m_macCeType == MacCeListElement_s::BSR )
1830  {
1831  // buffer status report
1832  // note that this scheduler does not differentiate the
1833  // allocation according to which LCGs have more/less bytes
1834  // to send.
1835  // Hence the BSR of different LCGs are just summed up to get
1836  // a total queue size that is used for allocation purposes.
1837 
1838  uint32_t buffer = 0;
1839  for (uint8_t lcg = 0; lcg < 4; ++lcg)
1840  {
1841  uint8_t bsrId = params.m_macCeList.at (i).m_macCeValue.m_bufferStatus.at (lcg);
1842  buffer += BufferSizeLevelBsr::BsrId2BufferSize (bsrId);
1843  }
1844 
1845  uint16_t rnti = params.m_macCeList.at (i).m_rnti;
1846  NS_LOG_LOGIC (this << "RNTI=" << rnti << " buffer=" << buffer);
1847  it = m_ceBsrRxed.find (rnti);
1848  if (it == m_ceBsrRxed.end ())
1849  {
1850  // create the new entry
1851  m_ceBsrRxed.insert ( std::pair<uint16_t, uint32_t > (rnti, buffer));
1852  }
1853  else
1854  {
1855  // update the buffer size value
1856  (*it).second = buffer;
1857  }
1858  }
1859  }
1860 
1861  return;
1862 }
1863 
1864 void
1866 {
1867  NS_LOG_FUNCTION (this);
1868 // retrieve the allocation for this subframe
1869  switch (m_ulCqiFilter)
1870  {
1872  {
1873  // filter all the CQIs that are not SRS based
1874  if (params.m_ulCqi.m_type != UlCqi_s::SRS)
1875  {
1876  return;
1877  }
1878  }
1879  break;
1881  {
1882  // filter all the CQIs that are not SRS based
1883  if (params.m_ulCqi.m_type != UlCqi_s::PUSCH)
1884  {
1885  return;
1886  }
1887  }
1889  break;
1890 
1891  default:
1892  NS_FATAL_ERROR ("Unknown UL CQI type");
1893  }
1894 
1895  switch (params.m_ulCqi.m_type)
1896  {
1897  case UlCqi_s::PUSCH:
1898  {
1899  std::map <uint16_t, std::vector <uint16_t> >::iterator itMap;
1900  std::map <uint16_t, std::vector <double> >::iterator itCqi;
1901  NS_LOG_DEBUG (this << " Collect PUSCH CQIs of Frame no. " << (params.m_sfnSf >> 4) << " subframe no. " << (0xF & params.m_sfnSf));
1902  itMap = m_allocationMaps.find (params.m_sfnSf);
1903  if (itMap == m_allocationMaps.end ())
1904  {
1905  return;
1906  }
1907  for (uint32_t i = 0; i < (*itMap).second.size (); i++)
1908  {
1909  // convert from fixed point notation Sxxxxxxxxxxx.xxx to double
1910  double sinr = LteFfConverter::fpS11dot3toDouble (params.m_ulCqi.m_sinr.at (i));
1911  itCqi = m_ueCqi.find ((*itMap).second.at (i));
1912  if (itCqi == m_ueCqi.end ())
1913  {
1914  // create a new entry
1915  std::vector <double> newCqi;
1916  for (uint32_t j = 0; j < m_cschedCellConfig.m_ulBandwidth; j++)
1917  {
1918  if (i == j)
1919  {
1920  newCqi.push_back (sinr);
1921  }
1922  else
1923  {
1924  // initialize with NO_SINR value.
1925  newCqi.push_back (NO_SINR);
1926  }
1927 
1928  }
1929  m_ueCqi.insert (std::pair <uint16_t, std::vector <double> > ((*itMap).second.at (i), newCqi));
1930  // generate correspondent timer
1931  m_ueCqiTimers.insert (std::pair <uint16_t, uint32_t > ((*itMap).second.at (i), m_cqiTimersThreshold));
1932  }
1933  else
1934  {
1935  // update the value
1936  (*itCqi).second.at (i) = sinr;
1937  NS_LOG_DEBUG (this << " RNTI " << (*itMap).second.at (i) << " RB " << i << " SINR " << sinr);
1938  // update correspondent timer
1939  std::map <uint16_t, uint32_t>::iterator itTimers;
1940  itTimers = m_ueCqiTimers.find ((*itMap).second.at (i));
1941  (*itTimers).second = m_cqiTimersThreshold;
1942 
1943  }
1944 
1945  }
1946  // remove obsolete info on allocation
1947  m_allocationMaps.erase (itMap);
1948  }
1949  break;
1950  case UlCqi_s::SRS:
1951  {
1952  NS_LOG_DEBUG (this << " Collect SRS CQIs of Frame no. " << (params.m_sfnSf >> 4) << " subframe no. " << (0xF & params.m_sfnSf));
1953  // get the RNTI from vendor specific parameters
1954  uint16_t rnti = 0;
1955  NS_ASSERT (params.m_vendorSpecificList.size () > 0);
1956  for (uint16_t i = 0; i < params.m_vendorSpecificList.size (); i++)
1957  {
1958  if (params.m_vendorSpecificList.at (i).m_type == SRS_CQI_RNTI_VSP)
1959  {
1960  Ptr<SrsCqiRntiVsp> vsp = DynamicCast<SrsCqiRntiVsp> (params.m_vendorSpecificList.at (i).m_value);
1961  rnti = vsp->GetRnti ();
1962  }
1963  }
1964  std::map <uint16_t, std::vector <double> >::iterator itCqi;
1965  itCqi = m_ueCqi.find (rnti);
1966  if (itCqi == m_ueCqi.end ())
1967  {
1968  // create a new entry
1969  std::vector <double> newCqi;
1970  for (uint32_t j = 0; j < m_cschedCellConfig.m_ulBandwidth; j++)
1971  {
1972  double sinr = LteFfConverter::fpS11dot3toDouble (params.m_ulCqi.m_sinr.at (j));
1973  newCqi.push_back (sinr);
1974  NS_LOG_INFO (this << " RNTI " << rnti << " new SRS-CQI for RB " << j << " value " << sinr);
1975 
1976  }
1977  m_ueCqi.insert (std::pair <uint16_t, std::vector <double> > (rnti, newCqi));
1978  // generate correspondent timer
1979  m_ueCqiTimers.insert (std::pair <uint16_t, uint32_t > (rnti, m_cqiTimersThreshold));
1980  }
1981  else
1982  {
1983  // update the values
1984  for (uint32_t j = 0; j < m_cschedCellConfig.m_ulBandwidth; j++)
1985  {
1986  double sinr = LteFfConverter::fpS11dot3toDouble (params.m_ulCqi.m_sinr.at (j));
1987  (*itCqi).second.at (j) = sinr;
1988  NS_LOG_INFO (this << " RNTI " << rnti << " update SRS-CQI for RB " << j << " value " << sinr);
1989  }
1990  // update correspondent timer
1991  std::map <uint16_t, uint32_t>::iterator itTimers;
1992  itTimers = m_ueCqiTimers.find (rnti);
1993  (*itTimers).second = m_cqiTimersThreshold;
1994 
1995  }
1996 
1997 
1998  }
1999  break;
2000  case UlCqi_s::PUCCH_1:
2001  case UlCqi_s::PUCCH_2:
2002  case UlCqi_s::PRACH:
2003  {
2004  NS_FATAL_ERROR ("PfFfMacScheduler supports only PUSCH and SRS UL-CQIs");
2005  }
2006  break;
2007  default:
2008  NS_FATAL_ERROR ("Unknown type of UL-CQI");
2009  }
2010  return;
2011 }
2012 
2013 void
2015 {
2016  // refresh DL CQI P01 Map
2017  std::map <uint16_t,uint32_t>::iterator itP10 = m_p10CqiTimers.begin ();
2018  while (itP10 != m_p10CqiTimers.end ())
2019  {
2020  NS_LOG_INFO (this << " P10-CQI for user " << (*itP10).first << " is " << (uint32_t)(*itP10).second << " thr " << (uint32_t)m_cqiTimersThreshold);
2021  if ((*itP10).second == 0)
2022  {
2023  // delete correspondent entries
2024  std::map <uint16_t,uint8_t>::iterator itMap = m_p10CqiRxed.find ((*itP10).first);
2025  NS_ASSERT_MSG (itMap != m_p10CqiRxed.end (), " Does not find CQI report for user " << (*itP10).first);
2026  NS_LOG_INFO (this << " P10-CQI expired for user " << (*itP10).first);
2027  m_p10CqiRxed.erase (itMap);
2028  std::map <uint16_t,uint32_t>::iterator temp = itP10;
2029  itP10++;
2030  m_p10CqiTimers.erase (temp);
2031  }
2032  else
2033  {
2034  (*itP10).second--;
2035  itP10++;
2036  }
2037  }
2038 
2039  // refresh DL CQI A30 Map
2040  std::map <uint16_t,uint32_t>::iterator itA30 = m_a30CqiTimers.begin ();
2041  while (itA30 != m_a30CqiTimers.end ())
2042  {
2043  NS_LOG_INFO (this << " A30-CQI for user " << (*itA30).first << " is " << (uint32_t)(*itA30).second << " thr " << (uint32_t)m_cqiTimersThreshold);
2044  if ((*itA30).second == 0)
2045  {
2046  // delete correspondent entries
2047  std::map <uint16_t,SbMeasResult_s>::iterator itMap = m_a30CqiRxed.find ((*itA30).first);
2048  NS_ASSERT_MSG (itMap != m_a30CqiRxed.end (), " Does not find CQI report for user " << (*itA30).first);
2049  NS_LOG_INFO (this << " A30-CQI expired for user " << (*itA30).first);
2050  m_a30CqiRxed.erase (itMap);
2051  std::map <uint16_t,uint32_t>::iterator temp = itA30;
2052  itA30++;
2053  m_a30CqiTimers.erase (temp);
2054  }
2055  else
2056  {
2057  (*itA30).second--;
2058  itA30++;
2059  }
2060  }
2061 
2062  return;
2063 }
2064 
2065 
2066 void
2068 {
2069  // refresh UL CQI Map
2070  std::map <uint16_t,uint32_t>::iterator itUl = m_ueCqiTimers.begin ();
2071  while (itUl != m_ueCqiTimers.end ())
2072  {
2073  NS_LOG_INFO (this << " UL-CQI for user " << (*itUl).first << " is " << (uint32_t)(*itUl).second << " thr " << (uint32_t)m_cqiTimersThreshold);
2074  if ((*itUl).second == 0)
2075  {
2076  // delete correspondent entries
2077  std::map <uint16_t, std::vector <double> >::iterator itMap = m_ueCqi.find ((*itUl).first);
2078  NS_ASSERT_MSG (itMap != m_ueCqi.end (), " Does not find CQI report for user " << (*itUl).first);
2079  NS_LOG_INFO (this << " UL-CQI exired for user " << (*itUl).first);
2080  (*itMap).second.clear ();
2081  m_ueCqi.erase (itMap);
2082  std::map <uint16_t,uint32_t>::iterator temp = itUl;
2083  itUl++;
2084  m_ueCqiTimers.erase (temp);
2085  }
2086  else
2087  {
2088  (*itUl).second--;
2089  itUl++;
2090  }
2091  }
2092 
2093  return;
2094 }
2095 
2096 void
2097 PfFfMacScheduler::UpdateDlRlcBufferInfo (uint16_t rnti, uint8_t lcid, uint16_t size)
2098 {
2099  std::map<LteFlowId_t, FfMacSchedSapProvider::SchedDlRlcBufferReqParameters>::iterator it;
2100  LteFlowId_t flow (rnti, lcid);
2101  it = m_rlcBufferReq.find (flow);
2102  if (it != m_rlcBufferReq.end ())
2103  {
2104  NS_LOG_INFO (this << " UE " << rnti << " LC " << (uint16_t)lcid << " txqueue " << (*it).second.m_rlcTransmissionQueueSize << " retxqueue " << (*it).second.m_rlcRetransmissionQueueSize << " status " << (*it).second.m_rlcStatusPduSize << " decrease " << size);
2105  // Update queues: RLC tx order Status, ReTx, Tx
2106  // Update status queue
2107  if (((*it).second.m_rlcStatusPduSize > 0) && (size >= (*it).second.m_rlcStatusPduSize))
2108  {
2109  (*it).second.m_rlcStatusPduSize = 0;
2110  }
2111  else if (((*it).second.m_rlcRetransmissionQueueSize > 0) && (size >= (*it).second.m_rlcRetransmissionQueueSize))
2112  {
2113  (*it).second.m_rlcRetransmissionQueueSize = 0;
2114  }
2115  else if ((*it).second.m_rlcTransmissionQueueSize > 0)
2116  {
2117  uint32_t rlcOverhead;
2118  if (lcid == 1)
2119  {
2120  // for SRB1 (using RLC AM) it's better to
2121  // overestimate RLC overhead rather than
2122  // underestimate it and risk unneeded
2123  // segmentation which increases delay
2124  rlcOverhead = 4;
2125  }
2126  else
2127  {
2128  // minimum RLC overhead due to header
2129  rlcOverhead = 2;
2130  }
2131  // update transmission queue
2132  if ((*it).second.m_rlcTransmissionQueueSize <= size - rlcOverhead)
2133  {
2134  (*it).second.m_rlcTransmissionQueueSize = 0;
2135  }
2136  else
2137  {
2138  (*it).second.m_rlcTransmissionQueueSize -= size - rlcOverhead;
2139  }
2140  }
2141  }
2142  else
2143  {
2144  NS_LOG_ERROR (this << " Does not find DL RLC Buffer Report of UE " << rnti);
2145  }
2146 }
2147 
2148 void
2149 PfFfMacScheduler::UpdateUlRlcBufferInfo (uint16_t rnti, uint16_t size)
2150 {
2151 
2152  size = size - 2; // remove the minimum RLC overhead
2153  std::map <uint16_t,uint32_t>::iterator it = m_ceBsrRxed.find (rnti);
2154  if (it != m_ceBsrRxed.end ())
2155  {
2156  NS_LOG_INFO (this << " UE " << rnti << " size " << size << " BSR " << (*it).second);
2157  if ((*it).second >= size)
2158  {
2159  (*it).second -= size;
2160  }
2161  else
2162  {
2163  (*it).second = 0;
2164  }
2165  }
2166  else
2167  {
2168  NS_LOG_ERROR (this << " Does not find BSR report info of UE " << rnti);
2169  }
2170 
2171 }
2172 
2173 void
2175 {
2176  NS_LOG_FUNCTION (this << " RNTI " << rnti << " txMode " << (uint16_t)txMode);
2178  params.m_rnti = rnti;
2179  params.m_transmissionMode = txMode;
2181 }
2182 
2183 
2184 }
friend class PfSchedulerMemberCschedSapProvider
std::vector< struct UlInfoListElement_s > m_ulInfoList
See section 4.3.1 dlDciListElement.
Definition: ff-mac-common.h:88
void DoSchedUlCqiInfoReq(const struct FfMacSchedSapProvider::SchedUlCqiInfoReqParameters &params)
smart pointer class similar to boost::intrusive_ptr
Definition: ptr.h:60
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by "...
void DoSchedUlTriggerReq(const struct FfMacSchedSapProvider::SchedUlTriggerReqParameters &params)
#define HARQ_PERIOD
Definition: lte-common.h:30
Hold a bool native type.
Definition: boolean.h:38
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register the class in the ns-3 factory.
Definition: object-base.h:38
std::map< LteFlowId_t, FfMacSchedSapProvider::SchedDlRlcBufferReqParameters > m_rlcBufferReq
void DoSchedUlMacCtrlInfoReq(const struct FfMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters &params)
void DoSchedDlCqiInfoReq(const struct FfMacSchedSapProvider::SchedDlCqiInfoReqParameters &params)
Parameters of the CSCHED_UE_CONFIG_CNF primitive.
Parameters of the CSCHED_UE_RELEASE_REQ primitive.
enum ns3::UlCqi_s::Type_e m_type
std::map< uint16_t, pfsFlowPerf_t > m_flowStatsUl
Implements the SCHED SAP and CSCHED SAP for a Proportional Fair scheduler.
std::vector< UlDciListElement_s > UlHarqProcessesDciBuffer_t
std::map< uint16_t, std::vector< double > > m_ueCqi
virtual void SchedDlRachInfoReq(const struct SchedDlRachInfoReqParameters &params)
std::vector< struct LogicalChannelConfigListElement_s > m_logicalChannelConfigList
std::vector< uint16_t > m_sinr
std::vector< uint8_t > DlHarqProcessesTimer_t
virtual FfMacSchedSapProvider * GetFfMacSchedSapProvider()
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file...
Definition: assert.h:61
int LcActivePerFlow(uint16_t rnti)
uint8_t HarqProcessAvailability(uint16_t rnti)
Return the availability of free process for the RNTI specified.
virtual void SchedDlCqiInfoReq(const struct SchedDlCqiInfoReqParameters &params)
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:170
virtual void CschedCellConfigReq(const struct CschedCellConfigReqParameters &params)
CSCHED_CELL_CONFIG_REQ.
std::vector< uint8_t > m_mcs
Definition: ff-mac-common.h:95
See section 4.3.2 ulDciListElement.
std::map< uint16_t, UlHarqProcessesStatus_t > m_ulHarqProcessesStatus
Provides the CSCHED SAP.
std::map< uint16_t, pfsFlowPerf_t > m_flowStatsDl
std::vector< struct UlDciListElement_s > m_dciList
virtual ~PfFfMacScheduler()
Destructor.
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:223
#define NS_FATAL_ERROR(msg)
fatal error handling
Definition: fatal-error.h:95
See section 4.3.10 buildRARListElement.
Parameters of the CSCHED_UE_CONFIG_UPDATE_IND primitive.
virtual void SetFfMacSchedSapUser(FfMacSchedSapUser *s)
set the user part of the FfMacSchedSap that this Scheduler will interact with.
virtual void SchedUlTriggerReq(const struct SchedUlTriggerReqParameters &params)
Parameters of the CSCHED_LC_RELEASE_REQ primitive.
std::vector< std::vector< struct RlcPduListElement_s > > m_rlcPduList
Parameters of the SCHED_DL_TRIGGER_REQ primitive.
double EstimateUlSinr(uint16_t rnti, uint16_t rb)
void UpdateDlRlcBufferInfo(uint16_t rnti, uint8_t lcid, uint16_t size)
void TransmissionModeConfigurationUpdate(uint16_t rnti, uint8_t txMode)
unsigned int lastTtiBytesTrasmitted
virtual FfMacCschedSapProvider * GetFfMacCschedSapProvider()
std::vector< RlcPduList_t > DlHarqRlcPduListBuffer_t
Parameters of the SCHED_DL_MAC_BUFFER_REQ primitive.
std::map< uint16_t, uint32_t > m_a30CqiTimers
Parameters of the SCHED_DL_PAGING_BUFFER_REQ primitive.
static const int PfType0AllocationRbg[4]
virtual void CschedUeConfigUpdateInd(const struct CschedUeConfigUpdateIndParameters &params)=0
std::vector< struct VendorSpecificListElement_s > m_vendorSpecificList
void DoSchedUlNoiseInterferenceReq(const struct FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters &params)
void DoSchedDlMacBufferReq(const struct FfMacSchedSapProvider::SchedDlMacBufferReqParameters &params)
std::vector< struct RachListElement_s > m_rachList
FfMacSchedSapProvider * m_schedSapProvider
Parameters of the SCHED_UL_TRIGGER_REQ primitive.
Hold an unsigned integer type.
Definition: uinteger.h:46
virtual void SchedUlMacCtrlInfoReq(const struct SchedUlMacCtrlInfoReqParameters &params)
std::map< uint16_t, DlHarqProcessesTimer_t > m_dlHarqProcessesTimer
static uint8_t TxMode2LayerNum(uint8_t txMode)
Definition: lte-common.cc:170
Ptr< SampleEmitter > s
std::vector< uint8_t > m_ndi
Definition: ff-mac-common.h:96
int GetRbgSize(int dlbandwidth)
Provides the SCHED SAP.
std::map< uint16_t, uint32_t > m_ueCqiTimers
std::vector< DlInfoListElement_s > m_dlInfoListBuffered
virtual void CschedUeConfigCnf(const struct CschedUeConfigCnfParameters &params)=0
FfMacSchedSapUser * m_schedSapUser
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition: log.h:233
Parameters of the SCHED_UL_NOISE_INTERFERENCE_REQ primitive.
std::vector< struct CqiListElement_s > m_cqiList
virtual void DoDispose(void)
This method is called by Object::Dispose or by the object's destructor, whichever comes first...
std::map< uint16_t, SbMeasResult_s > m_a30CqiRxed
bool m_harqOn
m_harqOn when false inhibit te HARQ mechanisms (by default active)
std::map< uint16_t, DlHarqRlcPduListBuffer_t > m_dlHarqProcessesRlcPduListBuffer
std::vector< struct DlInfoListElement_s > m_dlInfoList
virtual void SchedDlPagingBufferReq(const struct SchedDlPagingBufferReqParameters &params)
std::map< uint16_t, DlHarqProcessesDciBuffer_t > m_dlHarqProcessesDciBuffer
std::map< uint16_t, uint8_t > m_p10CqiRxed
void DoCschedLcConfigReq(const struct FfMacCschedSapProvider::CschedLcConfigReqParameters &params)
virtual void SchedDlConfigInd(const struct SchedDlConfigIndParameters &params)=0
virtual void CschedLcReleaseReq(const struct CschedLcReleaseReqParameters &params)
void DoCschedUeReleaseReq(const struct FfMacCschedSapProvider::CschedUeReleaseReqParameters &params)
std::vector< uint16_t > m_tbsSize
Definition: ff-mac-common.h:94
See section 4.3.9 rlcPDU_ListElement.
FfMacCschedSapProvider::CschedCellConfigReqParameters m_cschedCellConfig
FfMacCschedSapUser * m_cschedSapUser
std::map< uint16_t, uint8_t > m_dlHarqCurrentProcessId
friend class PfSchedulerMemberSchedSapProvider
std::vector< DlDciListElement_s > DlHarqProcessesDciBuffer_t
virtual void SchedUlNoiseInterferenceReq(const struct SchedUlNoiseInterferenceReqParameters &params)
Parameters of the CSCHED_LC_CONFIG_REQ primitive.
void DoCschedCellConfigReq(const struct FfMacCschedSapProvider::CschedCellConfigReqParameters &params)
std::vector< uint8_t > m_rv
Definition: ff-mac-common.h:97
static TypeId GetTypeId(void)
void DoSchedUlSrInfoReq(const struct FfMacSchedSapProvider::SchedUlSrInfoReqParameters &params)
std::map< uint16_t, std::vector< uint16_t > > m_allocationMaps
void UpdateUlRlcBufferInfo(uint16_t rnti, uint16_t size)
std::map< uint16_t, uint32_t > m_p10CqiTimers
std::map< uint16_t, uint32_t > m_ceBsrRxed
virtual void SchedUlConfigInd(const struct SchedUlConfigIndParameters &params)=0
static Time Now(void)
Return the "current simulation time".
Definition: simulator.cc:180
void DoSchedDlRachInfoReq(const struct FfMacSchedSapProvider::SchedDlRachInfoReqParameters &params)
UlCqiFilter_t m_ulCqiFilter
std::map< uint16_t, uint8_t > m_ulHarqCurrentProcessId
#define SRS_CQI_RNTI_VSP
This abstract base class identifies the interface by means of which the helper object can plug on the...
void DoSchedDlTriggerReq(const struct FfMacSchedSapProvider::SchedDlTriggerReqParameters &params)
FfMacCschedSapProvider * m_cschedSapProvider
#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:84
virtual void SchedDlMacBufferReq(const struct SchedDlMacBufferReqParameters &params)
Parameters of the SCHED_DL_CQI_INFO_REQ primitive.
std::vector< struct MacCeListElement_s > m_macCeList
std::vector< uint16_t > m_rachAllocationMap
std::vector< struct RachListElement_s > m_rachList
static double fpS11dot3toDouble(uint16_t val)
Definition: lte-common.cc:114
void RefreshHarqProcesses()
Refresh HARQ processes according to the timers.
std::map< uint16_t, DlHarqProcessesStatus_t > m_dlHarqProcessesStatus
std::vector< uint8_t > UlHarqProcessesStatus_t
unsigned long totalBytesTransmitted
std::vector< uint8_t > DlHarqProcessesStatus_t
Parameters of the SCHED_UL_CQI_INFO_REQ primitive.
static uint32_t BsrId2BufferSize(uint8_t val)
Definition: lte-common.cc:142
Parameters of the SCHED_UL_MAC_CTRL_INFO_REQ primitive.
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:213
virtual void SchedUlCqiInfoReq(const struct SchedUlCqiInfoReqParameters &params)
std::map< uint16_t, UlHarqProcessesDciBuffer_t > m_ulHarqProcessesDciBuffer
virtual void SchedDlRlcBufferReq(const struct SchedDlRlcBufferReqParameters &params)
virtual void CschedUeConfigReq(const struct CschedUeConfigReqParameters &params)
Parameters of the SCHED_UL_SR_INFO_REQ primitive.
virtual void SchedUlSrInfoReq(const struct SchedUlSrInfoReqParameters &params)
void DoCschedLcReleaseReq(const struct FfMacCschedSapProvider::CschedLcReleaseReqParameters &params)
virtual void CschedUeReleaseReq(const struct CschedUeReleaseReqParameters &params)
#define NS_LOG_ERROR(msg)
Use NS_LOG to output a message of level LOG_ERROR.
Definition: log.h:193
Parameters of the SCHED_DL_RACH_INFO_REQ primitive.
virtual void CschedLcConfigReq(const struct CschedLcConfigReqParameters &params)
Parameters of the SCHED_UL_CONFIG_IND primitive.
virtual void SchedDlTriggerReq(const struct SchedDlTriggerReqParameters &params)
virtual void SetFfMacCschedSapUser(FfMacCschedSapUser *s)
set the user part of the FfMacCschedSap that this Scheduler will interact with.
Parameters of the CSCHED_UE_CONFIG_REQ primitive.
#define HARQ_DL_TIMEOUT
#define NO_SINR
struct DlDciListElement_s m_dci
std::vector< struct BuildRarListElement_s > m_buildRarList
void DoSchedDlPagingBufferReq(const struct FfMacSchedSapProvider::SchedDlPagingBufferReqParameters &params)
a unique identifier for an interface.
Definition: type-id.h:49
uint8_t UpdateHarqProcessId(uint16_t rnti)
Update and return a new process Id for the RNTI specified.
TypeId SetParent(TypeId tid)
Definition: type-id.cc:610
std::map< uint16_t, uint8_t > m_uesTxMode
#define HARQ_PROC_NUM
void DoCschedUeConfigReq(const struct FfMacCschedSapProvider::CschedUeConfigReqParameters &params)
void DoSchedDlRlcBufferReq(const struct FfMacSchedSapProvider::SchedDlRlcBufferReqParameters &params)
std::vector< struct BuildDataListElement_s > m_buildDataList
See section 4.3.8 builDataListElement.