A Discrete-Event Network Simulator
API
lte-rlc-am.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: Manuel Requena <manuel.requena@cttc.es>
19 * Nicola Baldo <nbaldo@cttc.es>
20 */
21
22#include "ns3/simulator.h"
23#include "ns3/log.h"
24
25#include "ns3/lte-rlc-am-header.h"
26#include "ns3/lte-rlc-am.h"
27#include "ns3/lte-rlc-sdu-status-tag.h"
28#include "ns3/lte-rlc-tag.h"
29
30
31namespace ns3 {
32
33NS_LOG_COMPONENT_DEFINE ("LteRlcAm");
34
35NS_OBJECT_ENSURE_REGISTERED (LteRlcAm);
36
37
38LteRlcAm::LteRlcAm ()
39{
40 NS_LOG_FUNCTION (this);
41
42 // Buffers
43 m_txonBufferSize = 0;
44 m_retxBuffer.resize (1024);
45 m_retxBufferSize = 0;
46 m_txedBuffer.resize (1024);
47 m_txedBufferSize = 0;
48
49 m_statusPduRequested = false;
50 m_statusPduBufferSize = 0;
51
52 // State variables: transmitting side
53 m_windowSize = 512;
54 m_vtA = 0;
55 m_vtMs = m_vtA + m_windowSize;
56 m_vtS = 0;
57 m_pollSn = 0;
58
59 // State variables: receiving side
60 m_vrR = 0;
61 m_vrMr = m_vrR + m_windowSize;
62 m_vrX = 0;
63 m_vrMs = 0;
64 m_vrH = 0;
65
66 // Counters
67 m_pduWithoutPoll = 0;
68 m_byteWithoutPoll = 0;
69
70 // Configurable parameters
71 m_maxRetxThreshold = 5;
72 m_pollPdu = 1;
73 m_pollByte = 50;
74
75 // SDU reassembling process
76 m_reassemblingState = WAITING_S0_FULL;
77 m_expectedSeqNumber = 0;
78
79 m_pollRetransmitTimerJustExpired = false;
80}
81
82LteRlcAm::~LteRlcAm ()
83{
84 NS_LOG_FUNCTION (this);
85}
86
87TypeId
88LteRlcAm::GetTypeId (void)
89{
90 static TypeId tid = TypeId ("ns3::LteRlcAm")
91 .SetParent<LteRlc> ()
92 .SetGroupName("Lte")
93 .AddConstructor<LteRlcAm> ()
94 .AddAttribute ("PollRetransmitTimer",
95 "Value of the t-PollRetransmit timer (See section 7.3 of 3GPP TS 36.322)",
96 TimeValue (MilliSeconds (20)),
97 MakeTimeAccessor (&LteRlcAm::m_pollRetransmitTimerValue),
98 MakeTimeChecker ())
99 .AddAttribute ("ReorderingTimer",
100 "Value of the t-Reordering timer (See section 7.3 of 3GPP TS 36.322)",
101 TimeValue (MilliSeconds (10)),
102 MakeTimeAccessor (&LteRlcAm::m_reorderingTimerValue),
103 MakeTimeChecker ())
104 .AddAttribute ("StatusProhibitTimer",
105 "Value of the t-StatusProhibit timer (See section 7.3 of 3GPP TS 36.322)",
106 TimeValue (MilliSeconds (10)),
107 MakeTimeAccessor (&LteRlcAm::m_statusProhibitTimerValue),
108 MakeTimeChecker ())
109 .AddAttribute ("ReportBufferStatusTimer",
110 "How much to wait to issue a new Report Buffer Status since the last time "
111 "a new SDU was received",
112 TimeValue (MilliSeconds (20)),
113 MakeTimeAccessor (&LteRlcAm::m_rbsTimerValue),
114 MakeTimeChecker ())
115 .AddAttribute ("TxOpportunityForRetxAlwaysBigEnough",
116 "If true, always pretend that the size of a TxOpportunity is big enough "
117 "for retransmission. If false (default and realistic behavior), no retx "
118 "is performed unless the corresponding TxOpportunity is big enough.",
119 BooleanValue (false),
120 MakeBooleanAccessor (&LteRlcAm::m_txOpportunityForRetxAlwaysBigEnough),
121 MakeBooleanChecker ())
122 .AddAttribute ("MaxTxBufferSize",
123 "Maximum Size of the Transmission Buffer (in Bytes). If zero is configured, the buffer is unlimited.",
124 UintegerValue (10 * 1024),
125 MakeUintegerAccessor (&LteRlcAm::m_maxTxBufferSize),
126 MakeUintegerChecker<uint32_t> ())
127 ;
128 return tid;
129}
130
131void
132LteRlcAm::DoDispose ()
133{
134 NS_LOG_FUNCTION (this);
135 m_pollRetransmitTimer.Cancel ();
136 m_reorderingTimer.Cancel ();
137 m_statusProhibitTimer.Cancel ();
138 m_rbsTimer.Cancel ();
139
140 m_maxTxBufferSize = 0;
141 m_txonBuffer.clear ();
142 m_txonBufferSize = 0;
143 m_txedBuffer.clear ();
144 m_txedBufferSize = 0;
145 m_retxBuffer.clear ();
146 m_retxBufferSize = 0;
147 m_rxonBuffer.clear ();
148 m_sdusBuffer.clear ();
149 m_keepS0 = 0;
150 m_controlPduBuffer = 0;
151
152 LteRlc::DoDispose ();
153}
154
155
160void
161LteRlcAm::DoTransmitPdcpPdu (Ptr<Packet> p)
162{
163 NS_LOG_FUNCTION (this << m_rnti << (uint32_t) m_lcid << p->GetSize ());
164
165 if (m_txonBufferSize + p->GetSize () <= m_maxTxBufferSize || (m_maxTxBufferSize == 0))
166 {
168 LteRlcSduStatusTag tag;
169 tag.SetStatus (LteRlcSduStatusTag::FULL_SDU);
170 p->AddPacketTag (tag);
171
172 NS_LOG_LOGIC ("Txon Buffer: New packet added");
173 m_txonBuffer.push_back (TxPdu (p, Simulator::Now ()));
174 m_txonBufferSize += p->GetSize ();
175 NS_LOG_LOGIC ("NumOfBuffers = " << m_txonBuffer.size() );
176 NS_LOG_LOGIC ("txonBufferSize = " << m_txonBufferSize);
177 }
178 else
179 {
180 // Discard full RLC SDU
181 NS_LOG_LOGIC ("TxonBuffer is full. RLC SDU discarded");
182 NS_LOG_LOGIC ("MaxTxBufferSize = " << m_maxTxBufferSize);
183 NS_LOG_LOGIC ("txonBufferSize = " << m_txonBufferSize);
184 NS_LOG_LOGIC ("packet size = " << p->GetSize ());
185 m_txDropTrace (p);
186 }
187
189 DoReportBufferStatus ();
190 m_rbsTimer.Cancel ();
191 m_rbsTimer = Simulator::Schedule (m_rbsTimerValue, &LteRlcAm::ExpireRbsTimer, this);
192}
193
194
199void
200LteRlcAm::DoNotifyTxOpportunity (LteMacSapUser::TxOpportunityParameters txOpParams)
201{
202 NS_LOG_FUNCTION (this << m_rnti << (uint32_t) m_lcid << txOpParams.bytes);
203
204 if (txOpParams.bytes < 4)
205 {
206 // Stingy MAC: In general, we need more bytes.
207 // There are a more restrictive test for each particular case
208 NS_LOG_LOGIC ("TxOpportunity (size = " << txOpParams.bytes << ") too small");
209 NS_ASSERT_MSG (false, "TxOpportunity (size = " << txOpParams.bytes << ") too small.\n"
210 << "Your MAC scheduler is assigned too few resource blocks.");
211 return;
212 }
213
214 if ( m_statusPduRequested && ! m_statusProhibitTimer.IsRunning () )
215 {
216 if (txOpParams.bytes < m_statusPduBufferSize)
217 {
218 // Stingy MAC: We need more bytes for the STATUS PDU
219 NS_LOG_LOGIC ("TxOpportunity (size = " << txOpParams.bytes << ") too small for the STATUS PDU (size = " << m_statusPduBufferSize << ")");
220 NS_ASSERT_MSG (false, "TxOpportunity (size = " << txOpParams.bytes << ") too small for the STATUS PDU (size = " << m_statusPduBufferSize << ")\n"
221 << "Your MAC scheduler is assigned too few resource blocks.");
222 return;
223 }
224
225 NS_LOG_LOGIC ("Sending STATUS PDU");
226
227 Ptr<Packet> packet = Create<Packet> ();
228 LteRlcAmHeader rlcAmHeader;
229 rlcAmHeader.SetControlPdu (LteRlcAmHeader::STATUS_PDU);
230
231 NS_LOG_LOGIC ("Check for SNs to NACK from " << m_vrR.GetValue() << " to " << m_vrMs.GetValue());
232 SequenceNumber10 sn;
233 sn.SetModulusBase (m_vrR);
234 std::map<uint16_t, PduBuffer>::iterator pduIt;
235 for (sn = m_vrR; sn < m_vrMs; sn++)
236 {
237 NS_LOG_LOGIC ("SN = " << sn);
238 if (!rlcAmHeader.OneMoreNackWouldFitIn (txOpParams.bytes))
239 {
240 NS_LOG_LOGIC ("Can't fit more NACKs in STATUS PDU");
241 break;
242 }
243 pduIt = m_rxonBuffer.find (sn.GetValue ());
244 if (pduIt == m_rxonBuffer.end () || (!(pduIt->second.m_pduComplete)))
245 {
246 NS_LOG_LOGIC ("adding NACK_SN " << sn.GetValue ());
247 rlcAmHeader.PushNack (sn.GetValue ());
248 }
249 }
250 NS_LOG_LOGIC ("SN at end of NACK loop = " << sn);
251 // 3GPP TS 36.322 section 6.2.2.1.4 ACK SN
252 // find the SN of the next not received RLC Data PDU
253 // which is not reported as missing in the STATUS PDU.
254 pduIt = m_rxonBuffer.find (sn.GetValue ());
255 while ((sn < m_vrMs) && (pduIt != m_rxonBuffer.end ()) && (pduIt->second.m_pduComplete))
256 {
257 NS_LOG_LOGIC ("SN = " << sn << " < " << m_vrMs << " = " << (sn < m_vrMs));
258 sn++;
259 NS_LOG_LOGIC ("SN = " << sn);
260 pduIt = m_rxonBuffer.find (sn.GetValue ());
261 }
262
263 NS_ASSERT_MSG (sn <= m_vrMs, "first SN not reported as missing = " << sn << ", VR(MS) = " << m_vrMs);
264 rlcAmHeader.SetAckSn (sn);
265
266
267 NS_LOG_LOGIC ("RLC header: " << rlcAmHeader);
268 packet->AddHeader (rlcAmHeader);
269
270 // Sender timestamp
271 RlcTag rlcTag (Simulator::Now ());
272 packet->AddByteTag (rlcTag, 1, rlcAmHeader.GetSerializedSize ());
273 m_txPdu (m_rnti, m_lcid, packet->GetSize ());
274
275 // Send RLC PDU to MAC layer
276 LteMacSapProvider::TransmitPduParameters params;
277 params.pdu = packet;
278 params.rnti = m_rnti;
279 params.lcid = m_lcid;
280 params.layer = txOpParams.layer;
281 params.harqProcessId = txOpParams.harqId;
282 params.componentCarrierId = txOpParams.componentCarrierId;
283
284 m_macSapProvider->TransmitPdu (params);
285
286 m_statusPduRequested = false;
287 m_statusPduBufferSize = 0;
288 m_statusProhibitTimer = Simulator::Schedule (m_statusProhibitTimerValue,
289 &LteRlcAm::ExpireStatusProhibitTimer, this);
290 return;
291 }
292 else if ( m_retxBufferSize > 0 )
293 {
294 NS_LOG_LOGIC ("retxBufferSize = " << m_retxBufferSize);
295 NS_LOG_LOGIC ("Sending data from Retransmission Buffer");
296 NS_ASSERT (m_vtA < m_vtS);
297 SequenceNumber10 sn;
298 sn.SetModulusBase (m_vtA);
299 for (sn = m_vtA; sn < m_vtS; sn++)
300 {
301 uint16_t seqNumberValue = sn.GetValue ();
302 NS_LOG_LOGIC ("SN = " << seqNumberValue << " m_pdu " << m_retxBuffer.at (seqNumberValue).m_pdu);
303
304 if (m_retxBuffer.at (seqNumberValue).m_pdu != 0)
305 {
306 Ptr<Packet> packet = m_retxBuffer.at (seqNumberValue).m_pdu->Copy ();
307
308 if (( packet->GetSize () <= txOpParams.bytes )
309 || m_txOpportunityForRetxAlwaysBigEnough)
310 {
311 // According to 5.2.1, the data field is left as is, but we rebuild the header
312 LteRlcAmHeader rlcAmHeader;
313 packet->RemoveHeader (rlcAmHeader);
314 NS_LOG_LOGIC ("old AM RLC header: " << rlcAmHeader);
315
316 // Calculate the Polling Bit (5.2.2.1)
317 rlcAmHeader.SetPollingBit (LteRlcAmHeader::STATUS_REPORT_NOT_REQUESTED);
318
319 NS_LOG_LOGIC ("polling conditions: m_txonBuffer.empty=" << m_txonBuffer.empty ()
320 << " retxBufferSize=" << m_retxBufferSize
321 << " packet->GetSize ()=" << packet->GetSize ());
322 if (((m_txonBuffer.empty ()) && (m_retxBufferSize == packet->GetSize () + rlcAmHeader.GetSerializedSize ()))
323 || (m_vtS >= m_vtMs)
324 || m_pollRetransmitTimerJustExpired)
325 {
326 m_pollRetransmitTimerJustExpired = false;
327 rlcAmHeader.SetPollingBit (LteRlcAmHeader::STATUS_REPORT_IS_REQUESTED);
328 m_pduWithoutPoll = 0;
329 m_byteWithoutPoll = 0;
330
331 m_pollSn = m_vtS - 1;
332 NS_LOG_LOGIC ("New POLL_SN = " << m_pollSn);
333
334 if (! m_pollRetransmitTimer.IsRunning () )
335 {
336 NS_LOG_LOGIC ("Start PollRetransmit timer");
337
338 m_pollRetransmitTimer = Simulator::Schedule (m_pollRetransmitTimerValue,
339 &LteRlcAm::ExpirePollRetransmitTimer, this);
340 }
341 else
342 {
343 NS_LOG_LOGIC ("Restart PollRetransmit timer");
344
345 m_pollRetransmitTimer.Cancel ();
346 m_pollRetransmitTimer = Simulator::Schedule (m_pollRetransmitTimerValue,
347 &LteRlcAm::ExpirePollRetransmitTimer, this);
348 }
349 }
350
351 packet->AddHeader (rlcAmHeader);
352
353 RlcTag rlcTag;
354 rlcTag.SetSenderTimestamp (Simulator::Now ());
355
356 packet->AddByteTag (rlcTag, 1, rlcAmHeader.GetSerializedSize ());
357
358 NS_LOG_LOGIC ("new AM RLC header: " << rlcAmHeader);
359
360 m_txPdu (m_rnti, m_lcid, packet->GetSize ());
361
362 // Send RLC PDU to MAC layer
363 LteMacSapProvider::TransmitPduParameters params;
364 params.pdu = packet;
365 params.rnti = m_rnti;
366 params.lcid = m_lcid;
367 params.layer = txOpParams.layer;
368 params.harqProcessId = txOpParams.harqId;
369 params.componentCarrierId = txOpParams.componentCarrierId;
370
371 m_macSapProvider->TransmitPdu (params);
372
373 m_retxBuffer.at (seqNumberValue).m_retxCount++;
374 m_retxBuffer.at (seqNumberValue).m_waitingSince = Simulator::Now ();
375 NS_LOG_INFO ("Incr RETX_COUNT for SN = " << seqNumberValue);
376 if (m_retxBuffer.at (seqNumberValue).m_retxCount >= m_maxRetxThreshold)
377 {
378 NS_LOG_INFO ("Max RETX_COUNT for SN = " << seqNumberValue);
379 }
380
381 NS_LOG_INFO ("Move SN = " << seqNumberValue << " back to txedBuffer");
382 m_txedBuffer.at (seqNumberValue).m_pdu = m_retxBuffer.at (seqNumberValue).m_pdu->Copy ();
383 m_txedBuffer.at (seqNumberValue).m_retxCount = m_retxBuffer.at (seqNumberValue).m_retxCount;
384 m_txedBuffer.at (seqNumberValue).m_waitingSince = m_retxBuffer.at (seqNumberValue).m_waitingSince;
385 m_txedBufferSize += m_txedBuffer.at (seqNumberValue).m_pdu->GetSize ();
386
387 m_retxBufferSize -= m_retxBuffer.at (seqNumberValue).m_pdu->GetSize ();
388 m_retxBuffer.at (seqNumberValue).m_pdu = 0;
389 m_retxBuffer.at (seqNumberValue).m_retxCount = 0;
390 m_retxBuffer.at (seqNumberValue).m_waitingSince = MilliSeconds (0);
391
392 NS_LOG_LOGIC ("retxBufferSize = " << m_retxBufferSize);
393
394 return;
395 }
396 else
397 {
398 NS_LOG_LOGIC ("TxOpportunity (size = " << txOpParams.bytes << ") too small for retransmission of the packet (size = " << packet->GetSize () << ")");
399 NS_LOG_LOGIC ("Waiting for bigger TxOpportunity");
400 return;
401 }
402 }
403 }
404 NS_ASSERT_MSG (false, "m_retxBufferSize > 0, but no PDU considered for retx found");
405 }
406 else if ( m_txonBufferSize > 0 )
407 {
408 if (txOpParams.bytes < 7)
409 {
410 // Stingy MAC: We need more bytes for new DATA PDUs.
411 NS_LOG_LOGIC ("TxOpportunity (size = " << txOpParams.bytes << ") too small for DATA PDU");
412 NS_ASSERT_MSG (false, "TxOpportunity (size = " << txOpParams.bytes << ") too small for DATA PDU\n"
413 << "Your MAC scheduler is assigned too few resource blocks.");
414 return;
415 }
416
417 NS_ASSERT (m_vtS <= m_vtMs);
418 if (m_vtS == m_vtMs)
419 {
420 NS_LOG_INFO ("cannot transmit new RLC PDU due to window stalling");
421 return;
422 }
423
424 NS_LOG_LOGIC ("Sending data from Transmission Buffer");
425 }
426 else
427 {
428 NS_LOG_LOGIC ("No data pending");
429 return;
430 }
431
432 //
433 //
434 // Build new PDU
435 //
436 //
437
438 Ptr<Packet> packet = Create<Packet> ();
439 LteRlcAmHeader rlcAmHeader;
440 rlcAmHeader.SetDataPdu ();
441
442 // Build Data field
443 uint32_t nextSegmentSize = txOpParams.bytes - 4;
444 uint32_t nextSegmentId = 1;
445 uint32_t dataFieldAddedSize = 0;
446 std::vector < Ptr<Packet> > dataField;
447
448 // Remove the first packet from the transmission buffer.
449 // If only a segment of the packet is taken, then the remaining is given back later
450 if ( m_txonBuffer.size () == 0 )
451 {
452 NS_LOG_LOGIC ("No data pending");
453 return;
454 }
455
456 NS_LOG_LOGIC ("SDUs in TxonBuffer = " << m_txonBuffer.size ());
457 NS_LOG_LOGIC ("First SDU buffer = " << m_txonBuffer.begin ()->m_pdu);
458 NS_LOG_LOGIC ("First SDU size = " << m_txonBuffer.begin ()->m_pdu->GetSize ());
459 NS_LOG_LOGIC ("Next segment size = " << nextSegmentSize);
460 NS_LOG_LOGIC ("Remove SDU from TxBuffer");
461 Time firstSegmentTime = m_txonBuffer.begin ()->m_waitingSince;
462 Ptr<Packet> firstSegment = m_txonBuffer.begin ()->m_pdu->Copy ();
463 m_txonBufferSize -= m_txonBuffer.begin ()->m_pdu->GetSize ();
464 NS_LOG_LOGIC ("txBufferSize = " << m_txonBufferSize );
465 m_txonBuffer.erase (m_txonBuffer.begin ());
466
467 while ( firstSegment && (firstSegment->GetSize () > 0) && (nextSegmentSize > 0) )
468 {
469 NS_LOG_LOGIC ("WHILE ( firstSegment && firstSegment->GetSize > 0 && nextSegmentSize > 0 )");
470 NS_LOG_LOGIC (" firstSegment size = " << firstSegment->GetSize ());
471 NS_LOG_LOGIC (" nextSegmentSize = " << nextSegmentSize);
472 if ( (firstSegment->GetSize () > nextSegmentSize) ||
473 // Segment larger than 2047 octets can only be mapped to the end of the Data field
474 (firstSegment->GetSize () > 2047)
475 )
476 {
477 // Take the minimum size, due to the 2047-bytes 3GPP exception
478 // This exception is due to the length of the LI field (just 11 bits)
479 uint32_t currSegmentSize = std::min (firstSegment->GetSize (), nextSegmentSize);
480
481 NS_LOG_LOGIC (" IF ( firstSegment > nextSegmentSize ||");
482 NS_LOG_LOGIC (" firstSegment > 2047 )");
483
484 // Segment txBuffer.FirstBuffer and
485 // Give back the remaining segment to the transmission buffer
486 Ptr<Packet> newSegment = firstSegment->CreateFragment (0, currSegmentSize);
487 NS_LOG_LOGIC (" newSegment size = " << newSegment->GetSize ());
488
489 // Status tag of the new and remaining segments
490 // Note: This is the only place where a PDU is segmented and
491 // therefore its status can change
492 LteRlcSduStatusTag oldTag, newTag;
493 firstSegment->RemovePacketTag (oldTag);
494 newSegment->RemovePacketTag (newTag);
495 if (oldTag.GetStatus () == LteRlcSduStatusTag::FULL_SDU)
496 {
497 newTag.SetStatus (LteRlcSduStatusTag::FIRST_SEGMENT);
498 oldTag.SetStatus (LteRlcSduStatusTag::LAST_SEGMENT);
499 }
500 else if (oldTag.GetStatus () == LteRlcSduStatusTag::LAST_SEGMENT)
501 {
502 newTag.SetStatus (LteRlcSduStatusTag::MIDDLE_SEGMENT);
503 //oldTag.SetStatus (LteRlcSduStatusTag::LAST_SEGMENT);
504 }
505
506 // Give back the remaining segment to the transmission buffer
507 firstSegment->RemoveAtStart (currSegmentSize);
508 NS_LOG_LOGIC (" firstSegment size (after RemoveAtStart) = " << firstSegment->GetSize ());
509 if (firstSegment->GetSize () > 0)
510 {
511 firstSegment->AddPacketTag (oldTag);
512
513 m_txonBuffer.insert (m_txonBuffer.begin (), TxPdu (firstSegment, firstSegmentTime));
514 m_txonBufferSize += m_txonBuffer.begin ()->m_pdu->GetSize ();
515
516 NS_LOG_LOGIC (" Txon buffer: Give back the remaining segment");
517 NS_LOG_LOGIC (" Txon buffers = " << m_txonBuffer.size ());
518 NS_LOG_LOGIC (" Front buffer size = " << m_txonBuffer.begin ()->m_pdu->GetSize ());
519 NS_LOG_LOGIC (" txonBufferSize = " << m_txonBufferSize );
520 }
521 else
522 {
523 // Whole segment was taken, so adjust tag
524 if (newTag.GetStatus () == LteRlcSduStatusTag::FIRST_SEGMENT)
525 {
526 newTag.SetStatus (LteRlcSduStatusTag::FULL_SDU);
527 }
528 else if (newTag.GetStatus () == LteRlcSduStatusTag::MIDDLE_SEGMENT)
529 {
530 newTag.SetStatus (LteRlcSduStatusTag::LAST_SEGMENT);
531 }
532 }
533 // Segment is completely taken or
534 // the remaining segment is given back to the transmission buffer
535 firstSegment = 0;
536
537 // Put status tag once it has been adjusted
538 newSegment->AddPacketTag (newTag);
539
540 // Add Segment to Data field
541 dataFieldAddedSize = newSegment->GetSize ();
542 dataField.push_back (newSegment);
543 newSegment = 0;
544
545 // ExtensionBit (Next_Segment - 1) = 0
546 rlcAmHeader.PushExtensionBit (LteRlcAmHeader::DATA_FIELD_FOLLOWS);
547
548 // no LengthIndicator for the last one
549
550 nextSegmentSize -= dataFieldAddedSize;
551 nextSegmentId++;
552
553 // nextSegmentSize MUST be zero (only if segment is smaller or equal to 2047)
554
555 // (NO more segments) ? exit
556 // break;
557 }
558 else if ( (nextSegmentSize - firstSegment->GetSize () <= 2) || (m_txonBuffer.size () == 0) )
559 {
560 NS_LOG_LOGIC (" IF nextSegmentSize - firstSegment->GetSize () <= 2 || txonBuffer.size == 0");
561
562 // Add txBuffer.FirstBuffer to DataField
563 dataFieldAddedSize = firstSegment->GetSize ();
564 dataField.push_back (firstSegment);
565 firstSegment = 0;
566
567 // ExtensionBit (Next_Segment - 1) = 0
568 rlcAmHeader.PushExtensionBit (LteRlcAmHeader::DATA_FIELD_FOLLOWS);
569
570 // no LengthIndicator for the last one
571
572 nextSegmentSize -= dataFieldAddedSize;
573 nextSegmentId++;
574
575 NS_LOG_LOGIC (" SDUs in TxBuffer = " << m_txonBuffer.size ());
576 if (m_txonBuffer.size () > 0)
577 {
578 NS_LOG_LOGIC (" First SDU buffer = " << m_txonBuffer.begin ()->m_pdu);
579 NS_LOG_LOGIC (" First SDU size = " << m_txonBuffer.begin ()->m_pdu->GetSize ());
580 }
581 NS_LOG_LOGIC (" Next segment size = " << nextSegmentSize);
582
583 // nextSegmentSize <= 2 (only if txBuffer is not empty)
584
585 // (NO more segments) ? exit
586 // break;
587 }
588 else // (firstSegment->GetSize () < m_nextSegmentSize) && (m_txBuffer.size () > 0)
589 {
590 NS_LOG_LOGIC (" IF firstSegment < NextSegmentSize && txonBuffer.size > 0");
591 // Add txBuffer.FirstBuffer to DataField
592 dataFieldAddedSize = firstSegment->GetSize ();
593 dataField.push_back (firstSegment);
594
595 // ExtensionBit (Next_Segment - 1) = 1
596 rlcAmHeader.PushExtensionBit (LteRlcAmHeader::E_LI_FIELDS_FOLLOWS);
597
598 // LengthIndicator (Next_Segment) = txBuffer.FirstBuffer.length()
599 rlcAmHeader.PushLengthIndicator (firstSegment->GetSize ());
600
601 nextSegmentSize -= ((nextSegmentId % 2) ? (2) : (1)) + dataFieldAddedSize;
602 nextSegmentId++;
603
604 NS_LOG_LOGIC (" SDUs in TxBuffer = " << m_txonBuffer.size ());
605 if (m_txonBuffer.size () > 0)
606 {
607 NS_LOG_LOGIC (" First SDU buffer = " << m_txonBuffer.begin ()->m_pdu);
608 NS_LOG_LOGIC (" First SDU size = " << m_txonBuffer.begin ()->m_pdu->GetSize ());
609 }
610 NS_LOG_LOGIC (" Next segment size = " << nextSegmentSize);
611 NS_LOG_LOGIC (" Remove SDU from TxBuffer");
612
613 // (more segments)
614 firstSegment = m_txonBuffer.begin ()->m_pdu->Copy ();
615 firstSegmentTime = m_txonBuffer.begin ()->m_waitingSince;
616 m_txonBufferSize -= m_txonBuffer.begin ()->m_pdu->GetSize ();
617 m_txonBuffer.erase (m_txonBuffer.begin ());
618 NS_LOG_LOGIC (" txBufferSize = " << m_txonBufferSize );
619 }
620
621 }
622
623 //
624 // Build RLC header
625 //
626
627 rlcAmHeader.SetSequenceNumber ( m_vtS++ );
628 rlcAmHeader.SetResegmentationFlag (LteRlcAmHeader::PDU);
629 rlcAmHeader.SetLastSegmentFlag (LteRlcAmHeader::LAST_PDU_SEGMENT);
630 rlcAmHeader.SetSegmentOffset (0);
631
632 NS_ASSERT_MSG(rlcAmHeader.GetSequenceNumber () < m_vtMs, "SN above TX window");
633 NS_ASSERT_MSG(rlcAmHeader.GetSequenceNumber () >= m_vtA, "SN below TX window");
634
635 // Calculate FramingInfo flag according the status of the SDUs in the DataField
636 uint8_t framingInfo = 0;
637 std::vector< Ptr<Packet> >::iterator it;
638 it = dataField.begin ();
639
640 // FIRST SEGMENT
641 LteRlcSduStatusTag tag;
642 NS_ASSERT_MSG ((*it)->PeekPacketTag (tag), "LteRlcSduStatusTag is missing");
643 (*it)->PeekPacketTag (tag);
644 if ( (tag.GetStatus () == LteRlcSduStatusTag::FULL_SDU) ||
645 (tag.GetStatus () == LteRlcSduStatusTag::FIRST_SEGMENT)
646 )
647 {
648 framingInfo |= LteRlcAmHeader::FIRST_BYTE;
649 }
650 else
651 {
652 framingInfo |= LteRlcAmHeader::NO_FIRST_BYTE;
653 }
654
655 // Add all SDUs (in DataField) to the Packet
656 while (it < dataField.end ())
657 {
658 NS_LOG_LOGIC ("Adding SDU/segment to packet, length = " << (*it)->GetSize ());
659
660 NS_ASSERT_MSG ((*it)->PeekPacketTag (tag), "LteRlcSduStatusTag is missing");
661 (*it)->RemovePacketTag (tag);
662 if (packet->GetSize () > 0)
663 {
664 packet->AddAtEnd (*it);
665 }
666 else
667 {
668 packet = (*it);
669 }
670 it++;
671 }
672
673 // LAST SEGMENT (Note: There could be only one and be the first one)
674 it--;
675 if ( (tag.GetStatus () == LteRlcSduStatusTag::FULL_SDU) ||
676 (tag.GetStatus () == LteRlcSduStatusTag::LAST_SEGMENT) )
677 {
678 framingInfo |= LteRlcAmHeader::LAST_BYTE;
679 }
680 else
681 {
682 framingInfo |= LteRlcAmHeader::NO_LAST_BYTE;
683 }
684
685 // Set the FramingInfo flag after the calculation
686 rlcAmHeader.SetFramingInfo (framingInfo);
687
688
689 // Calculate the Polling Bit (5.2.2.1)
690 rlcAmHeader.SetPollingBit (LteRlcAmHeader::STATUS_REPORT_NOT_REQUESTED);
691
692 m_pduWithoutPoll++;
693 NS_LOG_LOGIC ("PDU_WITHOUT_POLL = " << m_pduWithoutPoll);
694 m_byteWithoutPoll += packet->GetSize ();
695 NS_LOG_LOGIC ("BYTE_WITHOUT_POLL = " << m_byteWithoutPoll);
696
697 if ( (m_pduWithoutPoll >= m_pollPdu) || (m_byteWithoutPoll >= m_pollByte) ||
698 ( (m_txonBuffer.empty ()) && (m_retxBufferSize == 0) ) ||
699 (m_vtS >= m_vtMs)
700 || m_pollRetransmitTimerJustExpired
701 )
702 {
703 m_pollRetransmitTimerJustExpired = false;
704 rlcAmHeader.SetPollingBit (LteRlcAmHeader::STATUS_REPORT_IS_REQUESTED);
705 m_pduWithoutPoll = 0;
706 m_byteWithoutPoll = 0;
707
708 m_pollSn = m_vtS - 1;
709 NS_LOG_LOGIC ("New POLL_SN = " << m_pollSn);
710
711 if (! m_pollRetransmitTimer.IsRunning () )
712 {
713 NS_LOG_LOGIC ("Start PollRetransmit timer");
714
715 m_pollRetransmitTimer = Simulator::Schedule (m_pollRetransmitTimerValue,
716 &LteRlcAm::ExpirePollRetransmitTimer, this);
717 }
718 else
719 {
720 NS_LOG_LOGIC ("Restart PollRetransmit timer");
721
722 m_pollRetransmitTimer.Cancel ();
723 m_pollRetransmitTimer = Simulator::Schedule (m_pollRetransmitTimerValue,
724 &LteRlcAm::ExpirePollRetransmitTimer, this);
725 }
726 }
727
728
729 // Build RLC PDU with DataField and Header
730 NS_LOG_LOGIC ("AM RLC header: " << rlcAmHeader);
731
732 RlcTag rlcTag;
733 rlcTag.SetSenderTimestamp (Simulator::Now ());
734
735 packet->AddHeader (rlcAmHeader);
736 packet->AddByteTag (rlcTag, 1, rlcAmHeader.GetSerializedSize ());
737
738 // Store new PDU into the Transmitted PDU Buffer
739 NS_LOG_LOGIC ("Put transmitted PDU in the txedBuffer");
740 m_txedBufferSize += packet->GetSize ();
741 m_txedBuffer.at ( rlcAmHeader.GetSequenceNumber ().GetValue () ).m_pdu = packet->Copy ();
742 m_txedBuffer.at ( rlcAmHeader.GetSequenceNumber ().GetValue () ).m_retxCount = 0;
743 m_txedBuffer.at ( rlcAmHeader.GetSequenceNumber ().GetValue () ).m_waitingSince = Simulator::Now ();
744
745 m_txPdu (m_rnti, m_lcid, packet->GetSize ());
746
747 // Send RLC PDU to MAC layer
748 LteMacSapProvider::TransmitPduParameters params;
749 params.pdu = packet;
750 params.rnti = m_rnti;
751 params.lcid = m_lcid;
752 params.layer = txOpParams.layer;
753 params.harqProcessId = txOpParams.harqId;
754 params.componentCarrierId = txOpParams.componentCarrierId;
755
756 m_macSapProvider->TransmitPdu (params);
757}
758
759void
760LteRlcAm::DoNotifyHarqDeliveryFailure ()
761{
762 NS_LOG_FUNCTION (this);
763}
764
765
766void
767LteRlcAm::DoReceivePdu (LteMacSapUser::ReceivePduParameters rxPduParams)
768{
769 NS_LOG_FUNCTION (this << m_rnti << (uint32_t) m_lcid << rxPduParams.p->GetSize ());
770
771 // Get RLC header parameters
772 LteRlcAmHeader rlcAmHeader;
773 rxPduParams.p->PeekHeader (rlcAmHeader);
774 NS_LOG_LOGIC ("RLC header: " << rlcAmHeader);
775
776 // Receiver timestamp
777 Time delay;
778 RlcTag rlcTag;
779
780 bool ret = rxPduParams.p->FindFirstMatchingByteTag (rlcTag);
781 NS_ASSERT_MSG(ret, "RlcTag not found in RLC Header. The packet went into a real network?");
782
783 delay = Simulator::Now () - rlcTag.GetSenderTimestamp ();
784
785 m_rxPdu (m_rnti, m_lcid, rxPduParams.p->GetSize (), delay.GetNanoSeconds ());
786
787 if ( rlcAmHeader.IsDataPdu () )
788 {
789
790 // 5.1.3.1 Transmit operations
791
792 // 5.1.3.1.1 General
793 //
794 // The transmitting side of an AM RLC entity shall prioritize transmission of RLC control PDUs
795 // over RLC data PDUs. The transmitting side of an AM RLC entity shall prioritize retransmission
796 // of RLC data PDUs over transmission of new AMD PDUs.
797 //
798 // The transmitting side of an AM RLC entity shall maintain a transmitting window according to
799 // state variables VT(A) and VT(MS) as follows:
800 // - a SN falls within the transmitting window if VT(A) <= SN < VT(MS);
801 // - a SN falls outside of the transmitting window otherwise.
802 //
803 // The transmitting side of an AM RLC entity shall not deliver to lower layer any RLC data PDU
804 // whose SN falls outside of the transmitting window.
805 //
806 // When delivering a new AMD PDU to lower layer, the transmitting side of an AM RLC entity shall:
807 // - set the SN of the AMD PDU to VT(S), and then increment VT(S) by one.
808 //
809 // The transmitting side of an AM RLC entity can receive a positive acknowledgement (confirmation
810 // of successful reception by its peer AM RLC entity) for a RLC data PDU by the following:
811 // - STATUS PDU from its peer AM RLC entity.
812 //
813 // When receiving a positive acknowledgement for an AMD PDU with SN = VT(A), the transmitting
814 // side of an AM RLC entity shall:
815 // - set VT(A) equal to the SN of the AMD PDU with the smallest SN, whose SN falls within the
816 // range VT(A) <= SN <= VT(S) and for which a positive acknowledgment has not been received yet.
817 // - if positive acknowledgements have been received for all AMD PDUs associated with
818 // a transmitted RLC SDU:
819 // - send an indication to the upper layers of successful delivery of the RLC SDU.
820
821
822 // 5.1.3.2 Receive operations
823 //
824 // 5.1.3.2.1 General
825 //
826 // The receiving side of an AM RLC entity shall maintain a receiving window according to state
827 // variables VR(R) and VR(MR) as follows:
828 // - a SN falls within the receiving window if VR(R) <= SN < VR(MR);
829 // - a SN falls outside of the receiving window otherwise.
830 //
831 // When receiving a RLC data PDU from lower layer, the receiving side of an AM RLC entity shall:
832 // - either discard the received RLC data PDU or place it in the reception buffer (see sub clause 5.1.3.2.2);
833 // - if the received RLC data PDU was placed in the reception buffer:
834 // - update state variables, reassemble and deliver RLC SDUs to upper layer and start/stop t-Reordering as needed (see sub clause 5.1.3.2.3).
835 //
836 // When t-Reordering expires, the receiving side of an AM RLC entity shall:
837 // - update state variables and start t-Reordering as needed (see sub clause 5.1.3.2.4).
838
839
840 SequenceNumber10 seqNumber = rlcAmHeader.GetSequenceNumber ();
841 seqNumber.SetModulusBase (m_vrR);
842
843 if ( rlcAmHeader.GetResegmentationFlag () == LteRlcAmHeader::SEGMENT )
844 {
845 NS_LOG_LOGIC ("PDU segment received ( SN = " << seqNumber << " )");
846 }
847 else if ( rlcAmHeader.GetResegmentationFlag () == LteRlcAmHeader::PDU )
848 {
849 NS_LOG_LOGIC ("PDU received ( SN = " << seqNumber << " )");
850 }
851 else
852 {
853 NS_ASSERT_MSG (false, "Neither a PDU segment nor a PDU received");
854 return ;
855 }
856
857 // STATUS PDU is requested
858 if ( rlcAmHeader.GetPollingBit () == LteRlcAmHeader::STATUS_REPORT_IS_REQUESTED )
859 {
860 m_statusPduRequested = true;
861 m_statusPduBufferSize = 4;
862
863 if (! m_statusProhibitTimer.IsRunning ())
864 {
865 DoReportBufferStatus ();
866 }
867 }
868
869 // 5.1.3.2.2 Actions when a RLC data PDU is received from lower layer
870 //
871 // When a RLC data PDU is received from lower layer, where the RLC data PDU contains
872 // byte segment numbers y to z of an AMD PDU with SN = x, the receiving side of an AM RLC entity shall:
873 // - if x falls outside of the receiving window; or
874 // - if byte segment numbers y to z of the AMD PDU with SN = x have been received before:
875 // - discard the received RLC data PDU;
876 // - else:
877 // - place the received RLC data PDU in the reception buffer;
878 // - if some byte segments of the AMD PDU contained in the RLC data PDU have been received before:
879 // - discard the duplicate byte segments.
880
881 NS_LOG_LOGIC ("VR(R) = " << m_vrR);
882 NS_LOG_LOGIC ("VR(MR) = " << m_vrMr);
883 NS_LOG_LOGIC ("VR(X) = " << m_vrX);
884 NS_LOG_LOGIC ("VR(MS) = " << m_vrMs);
885 NS_LOG_LOGIC ("VR(H) = " << m_vrH);
886
887 // - if x falls outside of the receiving window; or
888 // - if byte segment numbers y to z of the AMD PDU with SN = x have been received before:
889 if ( ! IsInsideReceivingWindow (seqNumber) )
890 {
891 NS_LOG_LOGIC ("PDU discarded");
892 return;
893 }
894 else
895 {
896 // - if some byte segments of the AMD PDU contained in the RLC data PDU have been received before:
897 // - discard the duplicate byte segments.
898 // note: re-segmentation of AMD PDU is currently not supported,
899 // so we just check that the segment was not received before
900 std::map <uint16_t, PduBuffer>::iterator it = m_rxonBuffer.find (seqNumber.GetValue ());
901 if (it != m_rxonBuffer.end () )
902 {
903 NS_ASSERT (it->second.m_byteSegments.size () > 0);
904 NS_ASSERT_MSG (it->second.m_byteSegments.size () == 1, "re-segmentation not supported");
905 NS_LOG_LOGIC ("PDU segment already received, discarded");
906 }
907 else
908 {
909 NS_LOG_LOGIC ("Place PDU in the reception buffer ( SN = " << seqNumber << " )");
910 m_rxonBuffer[ seqNumber.GetValue () ].m_byteSegments.push_back (rxPduParams.p);
911 m_rxonBuffer[ seqNumber.GetValue () ].m_pduComplete = true;
912 }
913
914
915 }
916
917 // 5.1.3.2.3 Actions when a RLC data PDU is placed in the reception buffer
918 // When a RLC data PDU with SN = x is placed in the reception buffer,
919 // the receiving side of an AM RLC entity shall:
920
921 // - if x >= VR(H)
922 // - update VR(H) to x+ 1;
923
924 if ( seqNumber >= m_vrH )
925 {
926 m_vrH = seqNumber + 1;
927 NS_LOG_LOGIC ("New VR(H) = " << m_vrH);
928 }
929
930 // - if all byte segments of the AMD PDU with SN = VR(MS) are received:
931 // - update VR(MS) to the SN of the first AMD PDU with SN > current VR(MS) for
932 // which not all byte segments have been received;
933
934 std::map <uint16_t, PduBuffer>::iterator it = m_rxonBuffer.find (m_vrMs.GetValue ());
935 if ( it != m_rxonBuffer.end () &&
936 it->second.m_pduComplete )
937 {
938 int firstVrMs = m_vrMs.GetValue ();
939 while ( it != m_rxonBuffer.end () &&
940 it->second.m_pduComplete )
941 {
942 m_vrMs++;
943 it = m_rxonBuffer.find (m_vrMs.GetValue ());
944 NS_LOG_LOGIC ("Incr VR(MS) = " << m_vrMs);
945
946 NS_ASSERT_MSG (firstVrMs != m_vrMs.GetValue (), "Infinite loop in RxonBuffer");
947 }
948 NS_LOG_LOGIC ("New VR(MS) = " << m_vrMs);
949 }
950
951 // - if x = VR(R):
952 // - if all byte segments of the AMD PDU with SN = VR(R) are received:
953 // - update VR(R) to the SN of the first AMD PDU with SN > current VR(R) for which not all byte segments have been received;
954 // - update VR(MR) to the updated VR(R) + AM_Window_Size;
955 // - reassemble RLC SDUs from any byte segments of AMD PDUs with SN that falls outside of the receiving window and in-sequence byte segments of the AMD PDU with SN = VR(R), remove RLC headers when doing so and deliver the reassembled RLC SDUs to upper layer in sequence if not delivered before;
956
957 if ( seqNumber == m_vrR )
958 {
959 std::map <uint16_t, PduBuffer>::iterator it = m_rxonBuffer.find (seqNumber.GetValue ());
960 if ( it != m_rxonBuffer.end () &&
961 it->second.m_pduComplete )
962 {
963 it = m_rxonBuffer.find (m_vrR.GetValue ());
964 int firstVrR = m_vrR.GetValue ();
965 while ( it != m_rxonBuffer.end () &&
966 it->second.m_pduComplete )
967 {
968 NS_LOG_LOGIC ("Reassemble and Deliver ( SN = " << m_vrR << " )");
969 NS_ASSERT_MSG (it->second.m_byteSegments.size () == 1,
970 "Too many segments. PDU Reassembly process didn't work");
971 ReassembleAndDeliver (it->second.m_byteSegments.front ());
972 m_rxonBuffer.erase (m_vrR.GetValue ());
973
974 m_vrR++;
975 m_vrR.SetModulusBase (m_vrR);
976 m_vrX.SetModulusBase (m_vrR);
977 m_vrMs.SetModulusBase (m_vrR);
978 m_vrH.SetModulusBase (m_vrR);
979 it = m_rxonBuffer.find (m_vrR.GetValue ());
980
981 NS_ASSERT_MSG (firstVrR != m_vrR.GetValue (), "Infinite loop in RxonBuffer");
982 }
983 NS_LOG_LOGIC ("New VR(R) = " << m_vrR);
984 m_vrMr = m_vrR + m_windowSize;
985
986 NS_LOG_LOGIC ("New VR(MR) = " << m_vrMr);
987 }
988
989 }
990
991 // - if t-Reordering is running:
992 // - if VR(X) = VR(R); or
993 // - if VR(X) falls outside of the receiving window and VR(X) is not equal to VR(MR):
994 // - stop and reset t-Reordering;
995
996 if ( m_reorderingTimer.IsRunning () )
997 {
998 NS_LOG_LOGIC ("Reordering timer is running");
999 if ( (m_vrX == m_vrR) ||
1000 ( (! IsInsideReceivingWindow (m_vrX)) && (m_vrX != m_vrMr) )
1001 )
1002 {
1004 NS_LOG_LOGIC ("Stop reordering timer");
1005 m_reorderingTimer.Cancel ();
1006 }
1007 }
1008
1009 // - if t-Reordering is not running (includes the case t-Reordering is stopped due to actions above):
1010 // - if VR (H) > VR(R):
1011 // - start t-Reordering;
1012 // - set VR(X) to VR(H).
1013
1014 if ( ! m_reorderingTimer.IsRunning () )
1015 {
1016 NS_LOG_LOGIC ("Reordering timer is not running");
1017 if ( m_vrH > m_vrR )
1018 {
1019 NS_LOG_LOGIC ("Start reordering timer");
1020 m_reorderingTimer = Simulator::Schedule (m_reorderingTimerValue,
1021 &LteRlcAm::ExpireReorderingTimer ,this);
1022 m_vrX = m_vrH;
1023 NS_LOG_LOGIC ("New VR(X) = " << m_vrX);
1024 }
1025 }
1026 }
1027 else if ( rlcAmHeader.IsControlPdu () )
1028 {
1029 NS_LOG_INFO ("Control AM RLC PDU");
1030
1031 SequenceNumber10 ackSn = rlcAmHeader.GetAckSn ();
1032 SequenceNumber10 sn;
1033
1034 NS_LOG_INFO ("ackSn = " << ackSn);
1035 NS_LOG_INFO ("VT(A) = " << m_vtA);
1036 NS_LOG_INFO ("VT(S) = " << m_vtS);
1037 NS_LOG_LOGIC ("retxBufferSize = " << m_retxBufferSize);
1038 NS_LOG_LOGIC ("txedBufferSize = " << m_txedBufferSize);
1039
1040 m_vtA.SetModulusBase (m_vtA);
1041 m_vtS.SetModulusBase (m_vtA);
1042 m_vtMs.SetModulusBase (m_vtA);
1043 ackSn.SetModulusBase (m_vtA);
1044 sn.SetModulusBase (m_vtA);
1045
1046 bool incrementVtA = true;
1047
1048 for (sn = m_vtA; sn < ackSn && sn < m_vtS; sn++)
1049 {
1050 NS_LOG_LOGIC ("sn = " << sn);
1051
1052 uint16_t seqNumberValue = sn.GetValue ();
1053
1054 if (m_pollRetransmitTimer.IsRunning ()
1055 && (seqNumberValue == m_pollSn.GetValue ()))
1056 {
1057 m_pollRetransmitTimer.Cancel ();
1058 }
1059
1060 if (rlcAmHeader.IsNackPresent (sn))
1061 {
1062 NS_LOG_LOGIC ("sn " << sn << " is NACKed");
1063
1064 incrementVtA = false;
1065
1066 if (m_txedBuffer.at (seqNumberValue).m_pdu != 0)
1067 {
1068 NS_LOG_INFO ("Move SN = " << seqNumberValue << " to retxBuffer");
1069 m_retxBuffer.at (seqNumberValue).m_pdu = m_txedBuffer.at (seqNumberValue).m_pdu->Copy ();
1070 m_retxBuffer.at (seqNumberValue).m_retxCount = m_txedBuffer.at (seqNumberValue).m_retxCount;
1071 m_retxBuffer.at (seqNumberValue).m_waitingSince = m_txedBuffer.at (seqNumberValue).m_waitingSince;
1072 m_retxBufferSize += m_retxBuffer.at (seqNumberValue).m_pdu->GetSize ();
1073
1074 m_txedBufferSize -= m_txedBuffer.at (seqNumberValue).m_pdu->GetSize ();
1075 m_txedBuffer.at (seqNumberValue).m_pdu = 0;
1076 m_txedBuffer.at (seqNumberValue).m_retxCount = 0;
1077 m_txedBuffer.at (seqNumberValue).m_waitingSince = MilliSeconds (0);
1078 }
1079
1080 NS_ASSERT (m_retxBuffer.at (seqNumberValue).m_pdu != 0);
1081
1082 }
1083 else
1084 {
1085 NS_LOG_LOGIC ("sn " << sn << " is ACKed");
1086
1087 if (m_txedBuffer.at (seqNumberValue).m_pdu)
1088 {
1089 NS_LOG_INFO ("ACKed SN = " << seqNumberValue << " from txedBuffer");
1090 // NS_LOG_INFO ("m_txedBuffer( " << m_vtA << " )->GetSize = " << m_txedBuffer.at (m_vtA.GetValue ())->GetSize ());
1091 m_txedBufferSize -= m_txedBuffer.at (seqNumberValue).m_pdu->GetSize ();
1092 m_txedBuffer.at (seqNumberValue).m_pdu = 0;
1093 m_txedBuffer.at (seqNumberValue).m_waitingSince = MilliSeconds (0);
1094 NS_ASSERT (m_retxBuffer.at (seqNumberValue).m_pdu == 0);
1095 }
1096
1097 if (m_retxBuffer.at (seqNumberValue).m_pdu)
1098 {
1099 NS_LOG_INFO ("ACKed SN = " << seqNumberValue << " from retxBuffer");
1100 m_retxBufferSize -= m_retxBuffer.at (seqNumberValue).m_pdu->GetSize ();
1101 m_retxBuffer.at (seqNumberValue).m_pdu = 0;
1102 m_retxBuffer.at (seqNumberValue).m_retxCount = 0;
1103 m_retxBuffer.at (seqNumberValue).m_waitingSince = MilliSeconds (0);
1104 }
1105
1106 }
1107
1108 NS_LOG_LOGIC ("retxBufferSize = " << m_retxBufferSize);
1109 NS_LOG_LOGIC ("txedBufferSize = " << m_txedBufferSize);
1110
1111 if (incrementVtA)
1112 {
1113 m_vtA++;
1114 m_vtMs = m_vtA + m_windowSize;
1115 NS_LOG_INFO ("New VT(A) = " << m_vtA);
1116 m_vtA.SetModulusBase (m_vtA);
1117 m_vtMs.SetModulusBase (m_vtA);
1118 m_vtS.SetModulusBase (m_vtA);
1119 ackSn.SetModulusBase (m_vtA);
1120 sn.SetModulusBase (m_vtA);
1121 }
1122
1123 } // loop over SN : VT(A) <= SN < ACK SN
1124
1125 return;
1126
1127 }
1128 else
1129 {
1130 NS_LOG_WARN ("Wrong AM RLC PDU type");
1131 return;
1132 }
1133
1134}
1135
1136
1137bool
1138LteRlcAm::IsInsideReceivingWindow (SequenceNumber10 seqNumber)
1139{
1140 NS_LOG_FUNCTION (this << seqNumber);
1141 NS_LOG_LOGIC ("Receiving Window: " <<
1142 m_vrR << " <= " << seqNumber << " <= " << m_vrMr);
1143
1144 m_vrR.SetModulusBase (m_vrR);
1145 m_vrMr.SetModulusBase (m_vrR);
1146 seqNumber.SetModulusBase (m_vrR);
1147
1148 if ( (m_vrR <= seqNumber) && (seqNumber < m_vrMr ) )
1149 {
1150 NS_LOG_LOGIC (seqNumber << " is INSIDE the receiving window");
1151 return true;
1152 }
1153 else
1154 {
1155 NS_LOG_LOGIC (seqNumber << " is OUTSIDE the receiving window");
1156 return false;
1157 }
1158}
1159
1160
1161void
1162LteRlcAm::ReassembleAndDeliver (Ptr<Packet> packet)
1163{
1164 LteRlcAmHeader rlcAmHeader;
1165 RlcTag rlcTag;
1166 bool ret = packet->FindFirstMatchingByteTag (rlcTag);
1167 NS_ASSERT(ret);
1168 packet->RemoveHeader (rlcAmHeader);
1169 ret = packet->FindFirstMatchingByteTag (rlcTag);
1170 NS_ASSERT(!ret);
1171 uint8_t framingInfo = rlcAmHeader.GetFramingInfo ();
1172 SequenceNumber10 currSeqNumber = rlcAmHeader.GetSequenceNumber ();
1173 bool expectedSnLost;
1174
1175 if ( currSeqNumber != m_expectedSeqNumber )
1176 {
1177 expectedSnLost = true;
1178 NS_LOG_LOGIC ("There are losses. Expected SN = " << m_expectedSeqNumber << ". Current SN = " << currSeqNumber);
1179 m_expectedSeqNumber = currSeqNumber + 1;
1180 }
1181 else
1182 {
1183 expectedSnLost = false;
1184 NS_LOG_LOGIC ("No losses. Expected SN = " << m_expectedSeqNumber << ". Current SN = " << currSeqNumber);
1185 m_expectedSeqNumber = m_expectedSeqNumber + 1;
1186 }
1187
1188 // Build list of SDUs
1189 uint8_t extensionBit;
1190 uint16_t lengthIndicator;
1191 do
1192 {
1193 extensionBit = rlcAmHeader.PopExtensionBit ();
1194 NS_LOG_LOGIC ("E = " << (uint16_t)extensionBit);
1195
1196 if ( extensionBit == 0 )
1197 {
1198 m_sdusBuffer.push_back (packet);
1199 }
1200 else // extensionBit == 1
1201 {
1202 lengthIndicator = rlcAmHeader.PopLengthIndicator ();
1203 NS_LOG_LOGIC ("LI = " << lengthIndicator);
1204
1205 // Check if there is enough data in the packet
1206 if ( lengthIndicator >= packet->GetSize () )
1207 {
1208 NS_LOG_LOGIC ("INTERNAL ERROR: Not enough data in the packet (" << packet->GetSize () << "). Needed LI=" << lengthIndicator);
1210 }
1211
1212 // Split packet in two fragments
1213 Ptr<Packet> data_field = packet->CreateFragment (0, lengthIndicator);
1214 packet->RemoveAtStart (lengthIndicator);
1215
1216 m_sdusBuffer.push_back (data_field);
1217 }
1218 }
1219 while ( extensionBit == 1 );
1220
1221 std::list < Ptr<Packet> >::iterator it;
1222
1223 // Current reassembling state
1224 if (m_reassemblingState == WAITING_S0_FULL) NS_LOG_LOGIC ("Reassembling State = 'WAITING_S0_FULL'");
1225 else if (m_reassemblingState == WAITING_SI_SF) NS_LOG_LOGIC ("Reassembling State = 'WAITING_SI_SF'");
1226 else NS_LOG_LOGIC ("Reassembling State = Unknown state");
1227
1228
1229 // Received framing Info
1230 NS_LOG_LOGIC ("Framing Info = " << (uint16_t)framingInfo);
1231 NS_LOG_LOGIC ("m_sdusBuffer = " << m_sdusBuffer.size ());
1232
1233 // Reassemble the list of SDUs (when there is no losses)
1234 if (!expectedSnLost)
1235 {
1236 switch (m_reassemblingState)
1237 {
1238 case WAITING_S0_FULL:
1239 switch (framingInfo)
1240 {
1241 case (LteRlcAmHeader::FIRST_BYTE | LteRlcAmHeader::LAST_BYTE):
1242 m_reassemblingState = WAITING_S0_FULL;
1243
1247 for ( it = m_sdusBuffer.begin () ; it != m_sdusBuffer.end () ; it++ )
1248 {
1249 m_rlcSapUser->ReceivePdcpPdu (*it);
1250 }
1251 m_sdusBuffer.clear ();
1252 break;
1253
1254 case (LteRlcAmHeader::FIRST_BYTE | LteRlcAmHeader::NO_LAST_BYTE):
1255 m_reassemblingState = WAITING_SI_SF;
1256
1260 while ( m_sdusBuffer.size () > 1 )
1261 {
1262 m_rlcSapUser->ReceivePdcpPdu (m_sdusBuffer.front ());
1263 m_sdusBuffer.pop_front ();
1264 }
1265
1269 m_keepS0 = m_sdusBuffer.front ();
1270 m_sdusBuffer.pop_front ();
1271 break;
1272
1273 case (LteRlcAmHeader::NO_FIRST_BYTE | LteRlcAmHeader::LAST_BYTE):
1274 case (LteRlcAmHeader::NO_FIRST_BYTE | LteRlcAmHeader::NO_LAST_BYTE):
1275 default:
1279 NS_LOG_LOGIC ("INTERNAL ERROR: Transition not possible. FI = " << (uint32_t) framingInfo);
1280 break;
1281 }
1282 break;
1283
1284 case WAITING_SI_SF:
1285 switch (framingInfo)
1286 {
1287 case (LteRlcAmHeader::NO_FIRST_BYTE | LteRlcAmHeader::LAST_BYTE):
1288 m_reassemblingState = WAITING_S0_FULL;
1289
1293 m_keepS0->AddAtEnd (m_sdusBuffer.front ());
1294 m_sdusBuffer.pop_front ();
1295 m_rlcSapUser->ReceivePdcpPdu (m_keepS0);
1296
1300 while ( ! m_sdusBuffer.empty () )
1301 {
1302 m_rlcSapUser->ReceivePdcpPdu (m_sdusBuffer.front ());
1303 m_sdusBuffer.pop_front ();
1304 }
1305 break;
1306
1307 case (LteRlcAmHeader::NO_FIRST_BYTE | LteRlcAmHeader::NO_LAST_BYTE):
1308 m_reassemblingState = WAITING_SI_SF;
1309
1313 if ( m_sdusBuffer.size () == 1 )
1314 {
1315 m_keepS0->AddAtEnd (m_sdusBuffer.front ());
1316 m_sdusBuffer.pop_front ();
1317 }
1318 else // m_sdusBuffer.size () > 1
1319 {
1323 m_keepS0->AddAtEnd (m_sdusBuffer.front ());
1324 m_sdusBuffer.pop_front ();
1325 m_rlcSapUser->ReceivePdcpPdu (m_keepS0);
1326
1330 while ( m_sdusBuffer.size () > 1 )
1331 {
1332 m_rlcSapUser->ReceivePdcpPdu (m_sdusBuffer.front ());
1333 m_sdusBuffer.pop_front ();
1334 }
1335
1339 m_keepS0 = m_sdusBuffer.front ();
1340 m_sdusBuffer.pop_front ();
1341 }
1342 break;
1343
1344 case (LteRlcAmHeader::FIRST_BYTE | LteRlcAmHeader::LAST_BYTE):
1345 case (LteRlcAmHeader::FIRST_BYTE | LteRlcAmHeader::NO_LAST_BYTE):
1346 default:
1350 NS_LOG_LOGIC ("INTERNAL ERROR: Transition not possible. FI = " << (uint32_t) framingInfo);
1351 break;
1352 }
1353 break;
1354
1355 default:
1356 NS_LOG_LOGIC ("INTERNAL ERROR: Wrong reassembling state = " << (uint32_t) m_reassemblingState);
1357 break;
1358 }
1359 }
1360 else // Reassemble the list of SDUs (when there are losses, i.e. the received SN is not the expected one)
1361 {
1362 switch (m_reassemblingState)
1363 {
1364 case WAITING_S0_FULL:
1365 switch (framingInfo)
1366 {
1367 case (LteRlcAmHeader::FIRST_BYTE | LteRlcAmHeader::LAST_BYTE):
1368 m_reassemblingState = WAITING_S0_FULL;
1369
1373 for ( it = m_sdusBuffer.begin () ; it != m_sdusBuffer.end () ; it++ )
1374 {
1375 m_rlcSapUser->ReceivePdcpPdu (*it);
1376 }
1377 m_sdusBuffer.clear ();
1378 break;
1379
1380 case (LteRlcAmHeader::FIRST_BYTE | LteRlcAmHeader::NO_LAST_BYTE):
1381 m_reassemblingState = WAITING_SI_SF;
1382
1386 while ( m_sdusBuffer.size () > 1 )
1387 {
1388 m_rlcSapUser->ReceivePdcpPdu (m_sdusBuffer.front ());
1389 m_sdusBuffer.pop_front ();
1390 }
1391
1395 m_keepS0 = m_sdusBuffer.front ();
1396 m_sdusBuffer.pop_front ();
1397 break;
1398
1399 case (LteRlcAmHeader::NO_FIRST_BYTE | LteRlcAmHeader::LAST_BYTE):
1400 m_reassemblingState = WAITING_S0_FULL;
1401
1405 m_sdusBuffer.pop_front ();
1406
1410 while ( ! m_sdusBuffer.empty () )
1411 {
1412 m_rlcSapUser->ReceivePdcpPdu (m_sdusBuffer.front ());
1413 m_sdusBuffer.pop_front ();
1414 }
1415 break;
1416
1417 case (LteRlcAmHeader::NO_FIRST_BYTE | LteRlcAmHeader::NO_LAST_BYTE):
1418 if ( m_sdusBuffer.size () == 1 )
1419 {
1420 m_reassemblingState = WAITING_S0_FULL;
1421 }
1422 else
1423 {
1424 m_reassemblingState = WAITING_SI_SF;
1425 }
1426
1430 m_sdusBuffer.pop_front ();
1431
1432 if ( m_sdusBuffer.size () > 0 )
1433 {
1437 while ( m_sdusBuffer.size () > 1 )
1438 {
1439 m_rlcSapUser->ReceivePdcpPdu (m_sdusBuffer.front ());
1440 m_sdusBuffer.pop_front ();
1441 }
1442
1446 m_keepS0 = m_sdusBuffer.front ();
1447 m_sdusBuffer.pop_front ();
1448 }
1449 break;
1450
1451 default:
1455 NS_LOG_LOGIC ("INTERNAL ERROR: Transition not possible. FI = " << (uint32_t) framingInfo);
1456 break;
1457 }
1458 break;
1459
1460 case WAITING_SI_SF:
1461 switch (framingInfo)
1462 {
1463 case (LteRlcAmHeader::FIRST_BYTE | LteRlcAmHeader::LAST_BYTE):
1464 m_reassemblingState = WAITING_S0_FULL;
1465
1469 m_keepS0 = 0;
1470
1474 while ( ! m_sdusBuffer.empty () )
1475 {
1476 m_rlcSapUser->ReceivePdcpPdu (m_sdusBuffer.front ());
1477 m_sdusBuffer.pop_front ();
1478 }
1479 break;
1480
1481 case (LteRlcAmHeader::FIRST_BYTE | LteRlcAmHeader::NO_LAST_BYTE):
1482 m_reassemblingState = WAITING_SI_SF;
1483
1487 m_keepS0 = 0;
1488
1492 while ( m_sdusBuffer.size () > 1 )
1493 {
1494 m_rlcSapUser->ReceivePdcpPdu (m_sdusBuffer.front ());
1495 m_sdusBuffer.pop_front ();
1496 }
1497
1501 m_keepS0 = m_sdusBuffer.front ();
1502 m_sdusBuffer.pop_front ();
1503
1504 break;
1505
1506 case (LteRlcAmHeader::NO_FIRST_BYTE | LteRlcAmHeader::LAST_BYTE):
1507 m_reassemblingState = WAITING_S0_FULL;
1508
1512 m_keepS0 = 0;
1513
1517 m_sdusBuffer.pop_front ();
1518
1522 while ( ! m_sdusBuffer.empty () )
1523 {
1524 m_rlcSapUser->ReceivePdcpPdu (m_sdusBuffer.front ());
1525 m_sdusBuffer.pop_front ();
1526 }
1527 break;
1528
1529 case (LteRlcAmHeader::NO_FIRST_BYTE | LteRlcAmHeader::NO_LAST_BYTE):
1530 if ( m_sdusBuffer.size () == 1 )
1531 {
1532 m_reassemblingState = WAITING_S0_FULL;
1533 }
1534 else
1535 {
1536 m_reassemblingState = WAITING_SI_SF;
1537 }
1538
1542 m_keepS0 = 0;
1543
1547 m_sdusBuffer.pop_front ();
1548
1549 if ( m_sdusBuffer.size () > 0 )
1550 {
1554 while ( m_sdusBuffer.size () > 1 )
1555 {
1556 m_rlcSapUser->ReceivePdcpPdu (m_sdusBuffer.front ());
1557 m_sdusBuffer.pop_front ();
1558 }
1559
1563 m_keepS0 = m_sdusBuffer.front ();
1564 m_sdusBuffer.pop_front ();
1565 }
1566 break;
1567
1568 default:
1572 NS_LOG_LOGIC ("INTERNAL ERROR: Transition not possible. FI = " << (uint32_t) framingInfo);
1573 break;
1574 }
1575 break;
1576
1577 default:
1578 NS_LOG_LOGIC ("INTERNAL ERROR: Wrong reassembling state = " << (uint32_t) m_reassemblingState);
1579 break;
1580 }
1581 }
1582
1583}
1584
1585void
1586LteRlcAm::DoReportBufferStatus (void)
1587{
1588 NS_LOG_FUNCTION (this);
1589
1590 Time now = Simulator::Now ();
1591
1592 NS_LOG_LOGIC ("txonBufferSize = " << m_txonBufferSize);
1593 NS_LOG_LOGIC ("retxBufferSize = " << m_retxBufferSize);
1594 NS_LOG_LOGIC ("txedBufferSize = " << m_txedBufferSize);
1595 NS_LOG_LOGIC ("VT(A) = " << m_vtA);
1596 NS_LOG_LOGIC ("VT(S) = " << m_vtS);
1597
1598 // Transmission Queue HOL time
1599 Time txonQueueHolDelay (0);
1600 if ( m_txonBufferSize > 0 )
1601 {
1602 txonQueueHolDelay = now - m_txonBuffer.front ().m_waitingSince;
1603 }
1604
1605 // Retransmission Queue HOL time
1606 Time retxQueueHolDelay;
1607 if ( m_retxBufferSize > 0 )
1608 {
1609 Time senderTimestamp;
1610 if (m_retxBuffer.at (m_vtA.GetValue ()).m_pdu != 0)
1611 {
1612 senderTimestamp = m_retxBuffer.at (m_vtA.GetValue ()).m_waitingSince;
1613 }
1614 else
1615 {
1616 senderTimestamp = m_txedBuffer.at (m_vtA.GetValue ()).m_waitingSince;
1617 }
1618 retxQueueHolDelay = now - senderTimestamp;
1619 }
1620 else
1621 {
1622 retxQueueHolDelay = Seconds (0);
1623 }
1624
1625 LteMacSapProvider::ReportBufferStatusParameters r;
1626 r.rnti = m_rnti;
1627 r.lcid = m_lcid;
1628 r.txQueueSize = m_txonBufferSize;
1629 r.txQueueHolDelay = txonQueueHolDelay.GetMilliSeconds ();
1630 r.retxQueueSize = m_retxBufferSize + m_txedBufferSize;
1631 r.retxQueueHolDelay = retxQueueHolDelay.GetMilliSeconds ();
1632
1633 if ( m_statusPduRequested && ! m_statusProhibitTimer.IsRunning () )
1634 {
1635 r.statusPduSize = m_statusPduBufferSize;
1636 }
1637 else
1638 {
1639 r.statusPduSize = 0;
1640 }
1641
1642 if ( r.txQueueSize != 0 || r.retxQueueSize != 0 || r.statusPduSize != 0 )
1643 {
1644 NS_LOG_INFO ("Send ReportBufferStatus: " << r.txQueueSize << ", " << r.txQueueHolDelay << ", "
1645 << r.retxQueueSize << ", " << r.retxQueueHolDelay << ", "
1646 << r.statusPduSize);
1647 m_macSapProvider->ReportBufferStatus (r);
1648 }
1649 else
1650 {
1651 NS_LOG_INFO ("ReportBufferStatus don't needed");
1652 }
1653}
1654
1655
1656void
1657LteRlcAm::ExpireReorderingTimer (void)
1658{
1659 NS_LOG_FUNCTION (this);
1660 NS_LOG_LOGIC ("Reordering Timer has expired");
1661
1662 // 5.1.3.2.4 Actions when t-Reordering expires
1663 // When t-Reordering expires, the receiving side of an AM RLC entity shall:
1664 // - update VR(MS) to the SN of the first AMD PDU with SN >= VR(X) for which not all byte segments
1665 // have been received;
1666 // - if VR(H) > VR(MS):
1667 // - start t-Reordering;
1668 // - set VR(X) to VR(H).
1669
1670 m_vrMs = m_vrX;
1671 int firstVrMs = m_vrMs.GetValue ();
1672 std::map <uint16_t, PduBuffer>::iterator it = m_rxonBuffer.find (m_vrMs.GetValue ());
1673 while ( it != m_rxonBuffer.end () &&
1674 it->second.m_pduComplete )
1675 {
1676 m_vrMs++;
1677 it = m_rxonBuffer.find (m_vrMs.GetValue ());
1678
1679 NS_ASSERT_MSG (firstVrMs != m_vrMs.GetValue (), "Infinite loop in ExpireReorderingTimer");
1680 }
1681 NS_LOG_LOGIC ("New VR(MS) = " << m_vrMs);
1682
1683 if ( m_vrH > m_vrMs )
1684 {
1685 NS_LOG_LOGIC ("Start reordering timer");
1686 m_reorderingTimer = Simulator::Schedule (m_reorderingTimerValue,
1687 &LteRlcAm::ExpireReorderingTimer ,this);
1688 m_vrX = m_vrH;
1689 NS_LOG_LOGIC ("New VR(MS) = " << m_vrMs);
1690 }
1691
1692 // Section 5.2.3 Status Reporting:
1693 // - The receiving side of an AM RLC entity shall trigger a
1694 // STATUS report when T_reordering expires.
1695 m_statusPduRequested = true;
1696}
1697
1698void
1699LteRlcAm::ExpirePollRetransmitTimer (void)
1700{
1701 NS_LOG_FUNCTION (this);
1702 NS_LOG_LOGIC ("PollRetransmit Timer has expired");
1703
1704 NS_LOG_LOGIC ("txonBufferSize = " << m_txonBufferSize);
1705 NS_LOG_LOGIC ("retxBufferSize = " << m_retxBufferSize);
1706 NS_LOG_LOGIC ("txedBufferSize = " << m_txedBufferSize);
1707 NS_LOG_LOGIC ("statusPduRequested = " << m_statusPduRequested);
1708
1709 m_pollRetransmitTimerJustExpired = true;
1710
1711 // see section 5.2.2.3
1712 // note the difference between Rel 8 and Rel 11 specs; we follow Rel 11 here
1713 NS_ASSERT (m_vtS <= m_vtMs);
1714 if ((m_txonBufferSize == 0 && m_retxBufferSize == 0)
1715 || (m_vtS == m_vtMs))
1716 {
1717 NS_LOG_INFO ("txonBuffer and retxBuffer empty. Move PDUs up to = " << m_vtS.GetValue () - 1 << " to retxBuffer");
1718 for (SequenceNumber10 sn = m_vtA; sn < m_vtS; sn++)
1719 {
1720 bool pduAvailable = m_txedBuffer.at (sn.GetValue ()).m_pdu != 0;
1721
1722 if ( pduAvailable )
1723 {
1724 uint16_t snValue = sn.GetValue ();
1725 NS_LOG_INFO ("Move PDU " << sn << " from txedBuffer to retxBuffer");
1726 m_retxBuffer.at (snValue).m_pdu = m_txedBuffer.at (snValue).m_pdu->Copy ();
1727 m_retxBuffer.at (snValue).m_retxCount = m_txedBuffer.at (snValue).m_retxCount;
1728 m_retxBuffer.at (snValue).m_waitingSince = m_txedBuffer.at (snValue).m_waitingSince;
1729 m_retxBufferSize += m_retxBuffer.at (snValue).m_pdu->GetSize ();
1730
1731 m_txedBufferSize -= m_txedBuffer.at (snValue).m_pdu->GetSize ();
1732 m_txedBuffer.at (snValue).m_pdu = 0;
1733 m_txedBuffer.at (snValue).m_retxCount = 0;
1734 m_txedBuffer.at (snValue).m_waitingSince = MilliSeconds (0);
1735 }
1736 }
1737 }
1738
1739 DoReportBufferStatus ();
1740}
1741
1742
1743void
1744LteRlcAm::ExpireStatusProhibitTimer (void)
1745{
1746 NS_LOG_FUNCTION (this);
1747}
1748
1749void
1750LteRlcAm::ExpireRbsTimer (void)
1751{
1752 NS_LOG_LOGIC ("RBS Timer expires");
1753
1754 if (m_txonBufferSize + m_txedBufferSize + m_retxBufferSize > 0)
1755 {
1756 DoReportBufferStatus ();
1757 m_rbsTimer = Simulator::Schedule (m_rbsTimerValue, &LteRlcAm::ExpireRbsTimer, this);
1758 }
1759}
1760
1761} // namespace ns3
min
#define min(a, b)
Definition: 80211b.c:42
ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition: boolean.h:37
ns3::EventId::IsRunning
bool IsRunning(void) const
This method is syntactic sugar for !IsExpired().
Definition: event-id.cc:71
ns3::EventId::Cancel
void Cancel(void)
This method is syntactic sugar for the ns3::Simulator::Cancel method.
Definition: event-id.cc:53
ns3::LteMacSapProvider::TransmitPdu
virtual void TransmitPdu(TransmitPduParameters params)=0
send an RLC PDU to the MAC for transmission.
ns3::LteMacSapProvider::ReportBufferStatus
virtual void ReportBufferStatus(ReportBufferStatusParameters params)=0
Report the RLC buffer status to the MAC.
ns3::LteRlcAmHeader
The packet header for the AM Radio Link Control (RLC) protocol packets.
Definition: lte-rlc-am-header.h:40
ns3::LteRlcAmHeader::GetPollingBit
uint8_t GetPollingBit() const
Get polling bit function.
Definition: lte-rlc-am-header.cc:171
ns3::LteRlcAmHeader::SetSegmentOffset
void SetSegmentOffset(uint16_t segmentOffset)
Set segment offset function.
Definition: lte-rlc-am-header.cc:191
ns3::LteRlcAmHeader::PushExtensionBit
void PushExtensionBit(uint8_t extensionBit)
Push extension bit function.
Definition: lte-rlc-am-header.cc:109
ns3::LteRlcAmHeader::GetAckSn
SequenceNumber10 GetAckSn() const
Get ack sn function.
Definition: lte-rlc-am-header.cc:286
ns3::LteRlcAmHeader::SetPollingBit
void SetPollingBit(uint8_t pollingBit)
Set polling bit function.
Definition: lte-rlc-am-header.cc:165
ns3::LteRlcAmHeader::OneMoreNackWouldFitIn
bool OneMoreNackWouldFitIn(uint16_t bytes)
Definition: lte-rlc-am-header.cc:216
ns3::LteRlcAmHeader::SetLastSegmentFlag
void SetLastSegmentFlag(uint8_t lsf)
Set last segment flag function.
Definition: lte-rlc-am-header.cc:178
ns3::LteRlcAmHeader::PopExtensionBit
uint8_t PopExtensionBit(void)
Pop extension bit function.
Definition: lte-rlc-am-header.cc:133
ns3::LteRlcAmHeader::PushNack
void PushNack(int nack)
Add one more NACK to the CONTROL PDU.
Definition: lte-rlc-am-header.cc:232
ns3::LteRlcAmHeader::IsControlPdu
bool IsControlPdu(void) const
Is control PDU function.
Definition: lte-rlc-am-header.cc:78
ns3::LteRlcAmHeader::SetDataPdu
void SetDataPdu(void)
Set data PDU function.
Definition: lte-rlc-am-header.cc:60
ns3::LteRlcAmHeader::SetFramingInfo
void SetFramingInfo(uint8_t framingInfo)
Set sequence number.
Definition: lte-rlc-am-header.cc:84
ns3::LteRlcAmHeader::GetSerializedSize
virtual uint32_t GetSerializedSize(void) const
Definition: lte-rlc-am-header.cc:364
ns3::LteRlcAmHeader::IsDataPdu
bool IsDataPdu(void) const
Is data PDU function.
Definition: lte-rlc-am-header.cc:73
ns3::LteRlcAmHeader::PopLengthIndicator
uint16_t PopLengthIndicator(void)
Pop length indicator function.
Definition: lte-rlc-am-header.cc:142
ns3::LteRlcAmHeader::SetAckSn
void SetAckSn(SequenceNumber10 ackSn)
Set ack sn function.
Definition: lte-rlc-am-header.cc:210
ns3::LteRlcAmHeader::PushLengthIndicator
void PushLengthIndicator(uint16_t lengthIndicator)
Push length indicator function.
Definition: lte-rlc-am-header.cc:126
ns3::LteRlcAmHeader::GetResegmentationFlag
uint8_t GetResegmentationFlag() const
Get resegmentation flag function.
Definition: lte-rlc-am-header.cc:158
ns3::LteRlcAmHeader::SetResegmentationFlag
void SetResegmentationFlag(uint8_t resegFlag)
Pop extension bit function.
Definition: lte-rlc-am-header.cc:152
ns3::LteRlcAmHeader::IsNackPresent
bool IsNackPresent(SequenceNumber10 nack)
Definition: lte-rlc-am-header.cc:250
ns3::LteRlcAmHeader::GetFramingInfo
uint8_t GetFramingInfo() const
Get framing info.
Definition: lte-rlc-am-header.cc:96
ns3::LteRlcAmHeader::GetSequenceNumber
SequenceNumber10 GetSequenceNumber() const
Get sequence number.
Definition: lte-rlc-am-header.cc:102
ns3::LteRlcAmHeader::SetControlPdu
void SetControlPdu(uint8_t controlPduType)
Set control PDU function.
Definition: lte-rlc-am-header.cc:66
ns3::LteRlcAmHeader::SetSequenceNumber
void SetSequenceNumber(SequenceNumber10 sequenceNumber)
Set sequence number.
Definition: lte-rlc-am-header.cc:90
ns3::LteRlcAm
LTE RLC Acknowledged Mode (AM), see 3GPP TS 36.322.
Definition: lte-rlc-am.h:37
ns3::LteRlcAm::DoTransmitPdcpPdu
virtual void DoTransmitPdcpPdu(Ptr< Packet > p)
RLC SAP.
Definition: lte-rlc-am.cc:161
ns3::LteRlcAm::m_reassemblingState
ReassemblingState_t m_reassemblingState
reassembling state
Definition: lte-rlc-am.h:227
ns3::LteRlcAm::m_txonBuffer
std::vector< TxPdu > m_txonBuffer
Transmission buffer.
Definition: lte-rlc-am.h:131
ns3::LteRlcAm::m_vrMr
SequenceNumber10 m_vrMr
VR(MR)
Definition: lte-rlc-am.h:183
ns3::LteRlcAm::m_statusProhibitTimerValue
Time m_statusProhibitTimerValue
status prohibit timer value
Definition: lte-rlc-am.h:207
ns3::LteRlcAm::DoNotifyHarqDeliveryFailure
virtual void DoNotifyHarqDeliveryFailure()
Notify HARQ delivery failure.
Definition: lte-rlc-am.cc:760
ns3::LteRlcAm::ExpirePollRetransmitTimer
void ExpirePollRetransmitTimer(void)
Expire poll retransmitter.
Definition: lte-rlc-am.cc:1699
ns3::LteRlcAm::IsInsideReceivingWindow
bool IsInsideReceivingWindow(SequenceNumber10 seqNumber)
method called when the T_status_prohibit timer expires
Definition: lte-rlc-am.cc:1138
ns3::LteRlcAm::GetTypeId
static TypeId GetTypeId(void)
Get the type ID.
Definition: lte-rlc-am.cc:88
ns3::LteRlcAm::m_windowSize
uint16_t m_windowSize
Constants.
Definition: lte-rlc-am.h:197
ns3::LteRlcAm::m_keepS0
Ptr< Packet > m_keepS0
keep S0
Definition: lte-rlc-am.h:228
ns3::LteRlcAm::m_vrH
SequenceNumber10 m_vrH
VR(H)
Definition: lte-rlc-am.h:186
ns3::LteRlcAm::m_txonBufferSize
uint32_t m_txonBufferSize
transmit on buffer size
Definition: lte-rlc-am.h:147
ns3::LteRlcAm::m_vrMs
SequenceNumber10 m_vrMs
VR(MS)
Definition: lte-rlc-am.h:185
ns3::LteRlcAm::m_pollByte
uint16_t m_pollByte
poll byte
Definition: lte-rlc-am.h:216
ns3::LteRlcAm::m_vtS
SequenceNumber10 m_vtS
VT(S)
Definition: lte-rlc-am.h:178
ns3::LteRlcAm::DoDispose
virtual void DoDispose()
Destructor implementation.
Definition: lte-rlc-am.cc:132
ns3::LteRlcAm::m_pollSn
SequenceNumber10 m_pollSn
POLL_SN.
Definition: lte-rlc-am.h:179
ns3::LteRlcAm::DoNotifyTxOpportunity
virtual void DoNotifyTxOpportunity(LteMacSapUser::TxOpportunityParameters txOpParams)
MAC SAP.
Definition: lte-rlc-am.cc:200
ns3::LteRlcAm::m_vtA
SequenceNumber10 m_vtA
State variables.
Definition: lte-rlc-am.h:176
ns3::LteRlcAm::ExpireReorderingTimer
void ExpireReorderingTimer(void)
This method will schedule a timeout at WaitReplyTimeout interval in the future, unless a timer is alr...
Definition: lte-rlc-am.cc:1657
ns3::LteRlcAm::m_vtMs
SequenceNumber10 m_vtMs
VT(MS)
Definition: lte-rlc-am.h:177
ns3::LteRlcAm::m_rbsTimer
EventId m_rbsTimer
RBS timer.
Definition: lte-rlc-am.h:208
ns3::LteRlcAm::m_statusPduBufferSize
uint32_t m_statusPduBufferSize
status PDU buffer size
Definition: lte-rlc-am.h:152
ns3::LteRlcAm::m_controlPduBuffer
Ptr< Packet > m_controlPduBuffer
Control PDU buffer (just one PDU)
Definition: lte-rlc-am.h:165
ns3::LteRlcAm::m_rxonBuffer
std::map< uint16_t, PduBuffer > m_rxonBuffer
Reception buffer.
Definition: lte-rlc-am.h:163
ns3::LteRlcAm::m_txOpportunityForRetxAlwaysBigEnough
bool m_txOpportunityForRetxAlwaysBigEnough
transmit opportunity for retransmit?
Definition: lte-rlc-am.h:218
ns3::LteRlcAm::m_pollRetransmitTimerJustExpired
bool m_pollRetransmitTimerJustExpired
poll retransmit timer just expired?
Definition: lte-rlc-am.h:219
ns3::LteRlcAm::ExpireStatusProhibitTimer
void ExpireStatusProhibitTimer(void)
method called when the T_status_prohibit timer expires
Definition: lte-rlc-am.cc:1744
ns3::LteRlcAm::m_reorderingTimerValue
Time m_reorderingTimerValue
reordering timer value
Definition: lte-rlc-am.h:205
ns3::LteRlcAm::m_maxTxBufferSize
uint32_t m_maxTxBufferSize
maximum transmission buffer size
Definition: lte-rlc-am.h:146
ns3::LteRlcAm::m_pollRetransmitTimer
EventId m_pollRetransmitTimer
Timers.
Definition: lte-rlc-am.h:202
ns3::LteRlcAm::m_maxRetxThreshold
uint16_t m_maxRetxThreshold
Configurable parameters.
Definition: lte-rlc-am.h:214
ns3::LteRlcAm::m_vrX
SequenceNumber10 m_vrX
VR(X)
Definition: lte-rlc-am.h:184
ns3::LteRlcAm::ExpireRbsTimer
void ExpireRbsTimer(void)
Expire RBS timer.
Definition: lte-rlc-am.cc:1750
ns3::LteRlcAm::m_retxBuffer
std::vector< RetxPdu > m_retxBuffer
Buffer for PDUs considered for retransmission.
Definition: lte-rlc-am.h:144
ns3::LteRlcAm::m_byteWithoutPoll
uint32_t m_byteWithoutPoll
byte without poll
Definition: lte-rlc-am.h:192
ns3::LteRlcAm::m_sdusBuffer
std::list< Ptr< Packet > > m_sdusBuffer
List of SDUs in a packet (PDU)
Definition: lte-rlc-am.h:170
ns3::LteRlcAm::m_pduWithoutPoll
uint32_t m_pduWithoutPoll
Counters.
Definition: lte-rlc-am.h:191
ns3::LteRlcAm::~LteRlcAm
virtual ~LteRlcAm()
Definition: lte-rlc-am.cc:82
ns3::LteRlcAm::m_pollRetransmitTimerValue
Time m_pollRetransmitTimerValue
poll retransmit time value
Definition: lte-rlc-am.h:203
ns3::LteRlcAm::DoReportBufferStatus
void DoReportBufferStatus()
Report buffer status.
Definition: lte-rlc-am.cc:1586
ns3::LteRlcAm::ReassembleAndDeliver
void ReassembleAndDeliver(Ptr< Packet > packet)
Reassemble and deliver.
Definition: lte-rlc-am.cc:1162
ns3::LteRlcAm::m_txedBufferSize
uint32_t m_txedBufferSize
transmit ed buffer size
Definition: lte-rlc-am.h:149
ns3::LteRlcAm::m_pollPdu
uint16_t m_pollPdu
poll PDU
Definition: lte-rlc-am.h:215
ns3::LteRlcAm::DoReceivePdu
virtual void DoReceivePdu(LteMacSapUser::ReceivePduParameters rxPduParams)
Receive PDU function.
Definition: lte-rlc-am.cc:767
ns3::LteRlcAm::m_reorderingTimer
EventId m_reorderingTimer
reordering timer
Definition: lte-rlc-am.h:204
ns3::LteRlcAm::m_vrR
SequenceNumber10 m_vrR
VR(R)
Definition: lte-rlc-am.h:182
ns3::LteRlcAm::m_expectedSeqNumber
SequenceNumber10 m_expectedSeqNumber
Expected Sequence Number.
Definition: lte-rlc-am.h:233
ns3::LteRlcAm::m_retxBufferSize
uint32_t m_retxBufferSize
retransmit buffer size
Definition: lte-rlc-am.h:148
ns3::LteRlcAm::m_statusProhibitTimer
EventId m_statusProhibitTimer
status prohibit timer
Definition: lte-rlc-am.h:206
ns3::LteRlcAm::m_txedBuffer
std::vector< RetxPdu > m_txedBuffer
Buffer for transmitted and retransmitted PDUs that have not been acked but are not considered for ret...
Definition: lte-rlc-am.h:141
ns3::LteRlcAm::m_statusPduRequested
bool m_statusPduRequested
status PDU requested
Definition: lte-rlc-am.h:151
ns3::LteRlcAm::m_rbsTimerValue
Time m_rbsTimerValue
RBS timer value.
Definition: lte-rlc-am.h:209
ns3::LteRlc
This abstract base class defines the API to interact with the Radio Link Control (LTE_RLC) in LTE,...
Definition: lte-rlc.h:51
ns3::LteRlc::m_rlcSapUser
LteRlcSapUser * m_rlcSapUser
RLC SAP user.
Definition: lte-rlc.h:144
ns3::LteRlc::m_lcid
uint8_t m_lcid
LCID.
Definition: lte-rlc.h:169
ns3::LteRlc::m_txDropTrace
TracedCallback< Ptr< const Packet > > m_txDropTrace
The trace source fired when the RLC drops a packet before transmission.
Definition: lte-rlc.h:183
ns3::LteRlc::m_rnti
uint16_t m_rnti
RNTI.
Definition: lte-rlc.h:168
ns3::LteRlc::m_rxPdu
TracedCallback< uint16_t, uint8_t, uint32_t, uint64_t > m_rxPdu
Used to inform of a PDU reception from the MAC SAP user.
Definition: lte-rlc.h:178
ns3::LteRlc::m_macSapProvider
LteMacSapProvider * m_macSapProvider
MAC SAP provider.
Definition: lte-rlc.h:166
ns3::LteRlc::DoDispose
virtual void DoDispose()
Destructor implementation.
Definition: lte-rlc.cc:125
ns3::LteRlc::m_txPdu
TracedCallback< uint16_t, uint8_t, uint32_t > m_txPdu
Used to inform of a PDU delivery to the MAC SAP provider.
Definition: lte-rlc.h:174
ns3::LteRlcSapUser::ReceivePdcpPdu
virtual void ReceivePdcpPdu(Ptr< Packet > p)=0
Called by the RLC entity to notify the PDCP entity of the reception of a new PDCP PDU.
ns3::LteRlcSduStatusTag
This class implements a tag that carries the status of a RLC SDU for the fragmentation process Status...
Definition: lte-rlc-sdu-status-tag.h:35
ns3::LteRlcSduStatusTag::SetStatus
void SetStatus(uint8_t status)
Set status function.
Definition: lte-rlc-sdu-status-tag.cc:32
ns3::LteRlcSduStatusTag::GetStatus
uint8_t GetStatus(void) const
Get status function.
Definition: lte-rlc-sdu-status-tag.cc:38
ns3::Packet::RemovePacketTag
bool RemovePacketTag(Tag &tag)
Remove a packet tag.
Definition: packet.cc:963
ns3::Packet::RemoveHeader
uint32_t RemoveHeader(Header &header)
Deserialize and remove the header from the internal buffer.
Definition: packet.cc:280
ns3::Packet::AddAtEnd
void AddAtEnd(Ptr< const Packet > packet)
Concatenate the input packet at the end of the current packet.
Definition: packet.cc:335
ns3::Packet::AddHeader
void AddHeader(const Header &header)
Add header to this packet.
Definition: packet.cc:256
ns3::Packet::RemoveAtStart
void RemoveAtStart(uint32_t size)
Remove size bytes from the start of the current packet.
Definition: packet.cc:362
ns3::Packet::FindFirstMatchingByteTag
bool FindFirstMatchingByteTag(Tag &tag) const
Finds the first tag matching the parameter Tag type.
Definition: packet.cc:939
ns3::Packet::AddPacketTag
void AddPacketTag(const Tag &tag) const
Add a packet tag.
Definition: packet.cc:956
ns3::Packet::PeekHeader
uint32_t PeekHeader(Header &header) const
Deserialize but does not remove the header from the internal buffer.
Definition: packet.cc:290
ns3::Packet::CreateFragment
Ptr< Packet > CreateFragment(uint32_t start, uint32_t length) const
Create a new packet which contains a fragment of the original packet.
Definition: packet.cc:227
ns3::Packet::AddByteTag
void AddByteTag(const Tag &tag) const
Tag each byte included in this packet with a new byte tag.
Definition: packet.cc:912
ns3::Packet::Copy
Ptr< Packet > Copy(void) const
performs a COW copy of the packet.
Definition: packet.cc:121
ns3::Packet::GetSize
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:856
ns3::RlcTag
Tag to calculate the per-PDU delay from eNb RLC to UE RLC.
Definition: lte-rlc-tag.h:37
ns3::RlcTag::SetSenderTimestamp
void SetSenderTimestamp(Time senderTimestamp)
Set the sender timestamp.
Definition: lte-rlc-tag.h:74
ns3::RlcTag::GetSenderTimestamp
Time GetSenderTimestamp(void) const
Get the instant when the RLC delivers the PDU to the MAC SAP provider.
Definition: lte-rlc-tag.h:65
ns3::SequenceNumber10
SequenceNumber10 class.
Definition: lte-rlc-sequence-number.h:37
ns3::SequenceNumber10::GetValue
uint16_t GetValue() const
Extracts the numeric value of the sequence number.
Definition: lte-rlc-sequence-number.h:81
ns3::SequenceNumber10::SetModulusBase
void SetModulusBase(SequenceNumber10 modulusBase)
Set modulus base.
Definition: lte-rlc-sequence-number.h:90
ns3::Simulator::Schedule
static EventId Schedule(Time const &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition: simulator.h:556
ns3::Simulator::Now
static Time Now(void)
Return the current simulation virtual time.
Definition: simulator.cc:195
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:103
ns3::Time::GetMilliSeconds
int64_t GetMilliSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:383
ns3::Time::GetNanoSeconds
int64_t GetNanoSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:391
ns3::TimeValue
AttributeValue implementation for Time.
Definition: nstime.h:1308
ns3::TypeId
a unique identifier for an interface.
Definition: type-id.h:59
ns3::TypeId::SetParent
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:922
ns3::UintegerValue
Hold an unsigned integer type.
Definition: uinteger.h:44
uint32_t
NS_ASSERT
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:67
NS_ASSERT_MSG
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:88
ns3::MakeBooleanChecker
Ptr< const AttributeChecker > MakeBooleanChecker(void)
Definition: boolean.cc:121
ns3::MakeBooleanAccessor
Ptr< const AttributeAccessor > MakeBooleanAccessor(T1 a1)
Definition: boolean.h:85
ns3::MakeTimeAccessor
Ptr< const AttributeAccessor > MakeTimeAccessor(T1 a1)
Definition: nstime.h:1309
ns3::MakeUintegerAccessor
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Definition: uinteger.h:45
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
NS_LOG_LOGIC
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition: log.h:289
NS_LOG_FUNCTION
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
Definition: log-macros-enabled.h:244
NS_LOG_WARN
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition: log.h:265
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
NS_OBJECT_ENSURE_REGISTERED
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:45
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1244
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1252
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::MakeTimeChecker
Ptr< const AttributeChecker > MakeTimeChecker(const Time min, const Time max)
Helper to make a Time checker with bounded range.
Definition: time.cc:536
ns3::LteMacSapProvider::ReportBufferStatusParameters
Parameters for LteMacSapProvider::ReportBufferStatus.
Definition: lte-mac-sap.h:68
ns3::LteMacSapProvider::ReportBufferStatusParameters::txQueueSize
uint32_t txQueueSize
the current size of the RLC transmission queue
Definition: lte-mac-sap.h:71
ns3::LteMacSapProvider::ReportBufferStatusParameters::retxQueueHolDelay
uint16_t retxQueueHolDelay
the Head Of Line delay of the retransmission queue
Definition: lte-mac-sap.h:74
ns3::LteMacSapProvider::ReportBufferStatusParameters::txQueueHolDelay
uint16_t txQueueHolDelay
the Head Of Line delay of the transmission queue
Definition: lte-mac-sap.h:72
ns3::LteMacSapProvider::ReportBufferStatusParameters::retxQueueSize
uint32_t retxQueueSize
the current size of the RLC retransmission queue in bytes
Definition: lte-mac-sap.h:73
ns3::LteMacSapProvider::ReportBufferStatusParameters::lcid
uint8_t lcid
the logical channel id corresponding to the sending RLC instance
Definition: lte-mac-sap.h:70
ns3::LteMacSapProvider::ReportBufferStatusParameters::rnti
uint16_t rnti
the C-RNTI identifying the UE
Definition: lte-mac-sap.h:69
ns3::LteMacSapProvider::ReportBufferStatusParameters::statusPduSize
uint16_t statusPduSize
the current size of the pending STATUS RLC PDU message in bytes
Definition: lte-mac-sap.h:75
ns3::LteMacSapProvider::TransmitPduParameters
Parameters for LteMacSapProvider::TransmitPdu.
Definition: lte-mac-sap.h:46
ns3::LteMacSapProvider::TransmitPduParameters::rnti
uint16_t rnti
the C-RNTI identifying the UE
Definition: lte-mac-sap.h:48
ns3::LteMacSapProvider::TransmitPduParameters::lcid
uint8_t lcid
the logical channel id corresponding to the sending RLC instance
Definition: lte-mac-sap.h:49
ns3::LteMacSapProvider::TransmitPduParameters::componentCarrierId
uint8_t componentCarrierId
the component carrier id corresponding to the sending Mac istance
Definition: lte-mac-sap.h:52
ns3::LteMacSapProvider::TransmitPduParameters::harqProcessId
uint8_t harqProcessId
the HARQ process id that was passed by the MAC in the call to NotifyTxOpportunity that generated this...
Definition: lte-mac-sap.h:51
ns3::LteMacSapProvider::TransmitPduParameters::layer
uint8_t layer
the layer value that was passed by the MAC in the call to NotifyTxOpportunity that generated this PDU
Definition: lte-mac-sap.h:50
ns3::LteMacSapUser::ReceivePduParameters
Parameters for LteMacSapUser::ReceivePdu.
Definition: lte-mac-sap.h:157
ns3::LteMacSapUser::ReceivePduParameters::p
Ptr< Packet > p
the RLC PDU to be received
Definition: lte-mac-sap.h:175
ns3::LteMacSapUser::TxOpportunityParameters
Parameters for LteMacSapUser::NotifyTxOpportunity.
Definition: lte-mac-sap.h:104
ns3::LteMacSapUser::TxOpportunityParameters::bytes
uint32_t bytes
the number of bytes to transmit
Definition: lte-mac-sap.h:129
ns3::LteMacSapUser::TxOpportunityParameters::componentCarrierId
uint8_t componentCarrierId
the component carrier id
Definition: lte-mac-sap.h:132
ns3::LteMacSapUser::TxOpportunityParameters::layer
uint8_t layer
the layer of transmission (MIMO)
Definition: lte-mac-sap.h:130
ns3::LteRlcAm::TxPdu
Store an incoming (from layer above us) PDU, waiting to transmit it.
Definition: lte-rlc-am.h:114