23 #include "wimax-mac-queue.h"
24 #include "ns3/packet.h"
25 #include "ns3/trace-source-accessor.h"
26 #include "ns3/uinteger.h"
27 #include "ns3/simulator.h"
34 NS_OBJECT_ENSURE_REGISTERED (WimaxMacQueue);
36 WimaxMacQueue::QueueElement::QueueElement (
void)
37 : m_packet (Create<Packet> ()),
38 m_hdrType (MacHeaderType ()),
42 m_fragmentation (false),
48 WimaxMacQueue::QueueElement::QueueElement (Ptr<Packet> packet,
49 const MacHeaderType &hdrType,
50 const GenericMacHeader &hdr, Time timeStamp)
54 m_timeStamp (timeStamp),
55 m_fragmentation (false),
62 WimaxMacQueue::QueueElement::GetSize (
void)
const
69 if (m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
78 WimaxMacQueue::GetTypeId (
void)
80 static TypeId tid = TypeId (
"ns3::WimaxMacQueue")
88 MakeUintegerChecker<uint32_t> ())
89 .AddTraceSource (
"Enqueue",
92 .AddTraceSource (
"Dequeue",
95 .AddTraceSource (
"Drop",
102 WimaxMacQueue::WimaxMacQueue (
void)
106 m_nrRequestPackets (0)
110 WimaxMacQueue::WimaxMacQueue (uint32_t maxSize)
111 : m_maxSize (maxSize),
114 m_nrRequestPackets (0)
118 WimaxMacQueue::~WimaxMacQueue (
void)
139 if (m_queue.size () == m_maxSize)
142 m_traceDrop (packet);
146 m_traceEnqueue (packet);
148 m_queue.push_back (element);
150 if (hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
156 m_nrRequestPackets++;
159 m_bytes += element.GetSize ();
171 if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
175 "Can not enqueue more packets: no space left in the queue");
180 NS_LOG_INFO (
"Enqueued Packet IS A Request BW packet");
182 "Can not enqueue more packets: no space left in the queue");
183 m_nrRequestPackets--;
188 if (!element.m_fragmentation)
190 NS_LOG_INFO (
"FRAG_DEBUG: Enqueued Packet IS NOT a fragment" << std::endl);
194 m_bytes -= element.GetSize ();
195 if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
201 m_traceDequeue (packet);
210 NS_LOG_INFO (
"\t Enqueued Packet IS a fragment, add subhdr" << std::endl);
213 uint32_t fragmentOffset = element.m_fragmentOffset;
214 uint32_t fragmentSize = element.m_packet->
GetSize () - fragmentOffset;
217 "\n\t\t fragmentOffset=" << fragmentOffset <<
218 "\n\t\t packetSize=" << element.m_packet->
GetSize () <<
219 "\n\t\t fragmentSize=" << fragmentSize << std::endl);
225 fragmentSubhdr.SetFc (2);
226 fragmentSubhdr.SetFsn (element.m_fragmentNumber);
228 NS_LOG_INFO (
"\t FragmentSize=" << fragment->GetSize () << std::endl);
229 fragment->AddHeader (fragmentSubhdr);
234 if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
236 uint8_t tmpType = element.m_hdr.GetType ();
238 element.m_hdr.SetType (tmpType);
242 element.m_hdr.SetLen ((uint16_t)length);
244 fragment->AddHeader (element.m_hdr);
246 fragment->AddHeader (element.m_hdrType);
247 m_bytes -= fragmentSize;
249 m_traceDequeue (fragment);
261 NS_LOG_INFO (
"FRAG_DEBUG: Dequeue function" << std::endl);
268 uint32_t maxFragmentSize = availableByte - headerSize;
269 uint32_t fragmentOffset = element.m_fragmentOffset;
273 "\n\t\t availableByte=" << availableByte <<
274 "\n\t\t headerSize=" << headerSize <<
275 "\n\t\t maxFragmentSize=" << maxFragmentSize <<
""
276 "\n\t\t fragmentOffset=" << fragmentOffset <<
277 "\n\t\t payloadSize=" << packet->
GetSize ()
281 m_bytes -= maxFragmentSize;
284 if (!element.m_fragmentation)
287 SetFragmentation (packetType);
288 fragmentSubhdr.SetFc (1);
293 fragmentSubhdr.SetFc (3);
295 fragmentSubhdr.SetFsn (element.m_fragmentNumber);
296 NS_LOG_INFO (
"\t FragmentSize=" << fragment->GetSize () << std::endl);
297 fragment->AddHeader (fragmentSubhdr);
299 SetFragmentNumber (packetType);
300 SetFragmentOffset (packetType, maxFragmentSize);
305 if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
307 uint8_t tmpType = element.m_hdr.GetType ();
309 element.m_hdr.SetType (tmpType);
313 element.m_hdr.SetLen ((uint16_t)length);
315 fragment->AddHeader (element.m_hdr);
317 fragment->AddHeader (element.m_hdrType);
319 m_traceDequeue (fragment);
347 QueueElement element = m_queue.front ();
349 timeStamp = element.m_timeStamp;
371 if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
383 Time &timeStamp)
const
387 QueueElement element = Front (packetType);
388 timeStamp = element.m_timeStamp;
394 if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
405 WimaxMacQueue::GetSize (
void)
const
407 return m_queue.size ();
411 WimaxMacQueue::GetNBytes (
void)
const
416 uint32_t WimaxMacQueue::GetQueueLengthWithMACOverhead (
void)
418 uint32_t queueSize = GetNBytes ();
420 queueSize += GetSize () * 6;
429 WimaxMacQueue::QueueElement
432 QueueElement element;
434 for (std::deque<QueueElement>::const_iterator iter = m_queue.begin (); iter
435 != m_queue.end (); ++iter)
438 if (element.m_hdrType.GetType () == packetType)
450 QueueElement element;
452 for (std::deque<QueueElement>::iterator iter = m_queue.begin (); iter
453 != m_queue.end (); ++iter)
456 if (element.m_hdrType.GetType () == packetType)
458 m_queue.erase (iter);
465 WimaxMacQueue::IsEmpty (
void)
const
467 return m_queue.empty ();
473 if (packetType == MacHeaderType::HEADER_TYPE_GENERIC)
475 return m_nrDataPackets == 0;
479 return m_nrRequestPackets == 0;
485 const WimaxMacQueue::PacketQueue &
486 WimaxMacQueue::GetPacketQueue (
void)
const
495 for (std::deque<QueueElement>::const_iterator iter = m_queue.begin (); iter
496 != m_queue.end (); ++iter)
499 if (element.m_hdrType.GetType () == packetType)
505 if (element.m_fragmentation)
508 "\n\t\t m_fragmentation is true " << std::endl);
511 return element.m_fragmentation;
517 QueueElement element;
518 for (std::deque<QueueElement>::const_iterator iter = m_queue.begin (); iter
519 != m_queue.end (); ++iter)
522 if (element.m_hdrType.GetType () == packetType)
530 uint32_t hdrSize = 0;
531 if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
533 hdrSize += element.m_hdr.GetSerializedSize ();
535 element.m_hdr.GetSerializedSize ());
538 hdrSize += element.m_hdrType.GetSerializedSize ();
539 NS_LOG_INFO (
"\t\t\t m_hdrType.GetSerializedSize=" <<
540 element.m_hdrType.GetSerializedSize ());
556 QueueElement element;
557 for (std::deque<QueueElement>::const_iterator iter = m_queue.begin (); iter
558 != m_queue.end (); ++iter)
561 if (element.m_hdrType.GetType () == packetType)
571 NS_LOG_INFO (
"\t\t\t fullPayloadSize=" << element.m_packet->GetSize ()
572 <<
"\n\t\t\t fragmentOffset=" << element.m_fragmentOffset
573 <<
"\n\t\t\t (fragment)payloadSize=" <<
574 element.m_packet->GetSize () - element.m_fragmentOffset);
576 return element.m_packet->GetSize () - element.m_fragmentOffset;
579 element.m_packet->GetSize ());
581 return element.m_packet->GetSize ();
589 uint32_t requiredByte = GetFirstPacketPayloadSize (packetType) +
590 GetFirstPacketHdrSize (packetType);
592 NS_LOG_INFO (
"\t Required Bytes = " << requiredByte << std::endl);
600 for (std::deque<QueueElement>::iterator iter = m_queue.begin (); iter
601 != m_queue.end (); ++iter)
603 if (iter->m_hdrType.GetType () == packetType)
605 iter->SetFragmentation ();
614 for (std::deque<QueueElement>::iterator iter = m_queue.begin (); iter
615 != m_queue.end (); ++iter)
617 if (iter->m_hdrType.GetType () == packetType)
619 iter->SetFragmentNumber ();
628 for (std::deque<QueueElement>::iterator iter = m_queue.begin (); iter
629 != m_queue.end (); ++iter)
631 if (iter->m_hdrType.GetType () == packetType)
633 iter->SetFragmentOffset (offset);
640 WimaxMacQueue::QueueElement::SetFragmentation ()
642 m_fragmentation =
true;
646 WimaxMacQueue::QueueElement::SetFragmentNumber ()
652 WimaxMacQueue::QueueElement::SetFragmentOffset (uint32_t offset)
654 m_fragmentOffset += offset;
#define NS_LOG_COMPONENT_DEFINE(name)
uint32_t GetSize(void) const
Ptr< Packet > Peek(GenericMacHeader &hdr) const
Same as Dequeue but does not pop from queue.
Ptr< Packet > CreateFragment(uint32_t start, uint32_t length) const
bool CheckForFragmentation(MacHeaderType::HeaderType packetType)
Fragmentation utilities.
bool Enqueue(Ptr< Packet > packet, const MacHeaderType &hdrType, const GenericMacHeader &hdr)
Enqueue a packet.
Ptr< Packet > Copy(void) const
Ptr< const TraceSourceAccessor > MakeTraceSourceAccessor(T a)
uint32_t GetMaxSize(void) const
void SetMaxSize(uint32_t maxSize)
set the maximum queue size
#define NS_ASSERT_MSG(condition, message)
Time Seconds(double seconds)
create ns3::Time instances in units of seconds.
Ptr< Packet > Dequeue(MacHeaderType::HeaderType packetType)
Dequeue a packet of type packetType from the queue.
void AddHeader(const Header &header)