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