F5/unison
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

network: Convert Queue into a template class

Browse Source
This commit is contained in:
Stefano Avallone
2017-03-08 18:01:29 +01:00
parent 1cd0010e10
commit 6fef34be47
80 changed files with 1888 additions and 1374 deletions
Download Patch File Download Diff File Expand all files Collapse all files

281
src/network/utils/queue.cc
View File

@@ -16,7 +16,6 @@
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "ns3/log.h"
#include "ns3/abort.h"
#include "ns3/enum.h"
#include "ns3/uinteger.h"
@@ -27,206 +26,78 @@ namespace ns3 {
NS_LOG_COMPONENT_DEFINE ("Queue");
NS_OBJECT_ENSURE_REGISTERED (Queue);
NS_OBJECT_ENSURE_REGISTERED (QueueBase);
NS_OBJECT_TEMPLATE_CLASS_DEFINE (Queue,Packet);
TypeId
Queue::GetTypeId (void)
TypeId
QueueBase::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::Queue")
static TypeId tid = TypeId ("ns3::QueueBase")
.SetParent<Object> ()
.SetGroupName ("Network")
.AddAttribute ("Mode",
"Whether to use bytes (see MaxBytes) or packets (see MaxPackets) as the maximum queue size metric.",
EnumValue (QUEUE_MODE_PACKETS),
MakeEnumAccessor (&Queue::SetMode,
&Queue::GetMode),
MakeEnumAccessor (&QueueBase::SetMode,
&QueueBase::GetMode),
MakeEnumChecker (QUEUE_MODE_BYTES, "QUEUE_MODE_BYTES",
QUEUE_MODE_PACKETS, "QUEUE_MODE_PACKETS"))
.AddAttribute ("MaxPackets",
"The maximum number of packets accepted by this queue.",
UintegerValue (100),
MakeUintegerAccessor (&Queue::SetMaxPackets,
&Queue::GetMaxPackets),
MakeUintegerAccessor (&QueueBase::SetMaxPackets,
&QueueBase::GetMaxPackets),
MakeUintegerChecker<uint32_t> ())
.AddAttribute ("MaxBytes",
"The maximum number of bytes accepted by this queue.",
UintegerValue (100 * 65535),
MakeUintegerAccessor (&Queue::SetMaxBytes,
&Queue::GetMaxBytes),
MakeUintegerAccessor (&QueueBase::SetMaxBytes,
&QueueBase::GetMaxBytes),
MakeUintegerChecker<uint32_t> ())
.AddTraceSource ("Enqueue", "Enqueue a packet in the queue.",
MakeTraceSourceAccessor (&Queue::m_traceEnqueue),
"ns3::Packet::TracedCallback")
.AddTraceSource ("Dequeue", "Dequeue a packet from the queue.",
MakeTraceSourceAccessor (&Queue::m_traceDequeue),
"ns3::Packet::TracedCallback")
.AddTraceSource ("Drop", "Drop a packet (for whatever reason).",
MakeTraceSourceAccessor (&Queue::m_traceDrop),
"ns3::Packet::TracedCallback")
.AddTraceSource ("PacketsInQueue",
"Number of packets currently stored in the queue",
MakeTraceSourceAccessor (&Queue::m_nPackets),
MakeTraceSourceAccessor (&QueueBase::m_nPackets),
"ns3::TracedValueCallback::Uint32")
.AddTraceSource ("BytesInQueue",
"Number of bytes currently stored in the queue",
MakeTraceSourceAccessor (&Queue::m_nBytes),
MakeTraceSourceAccessor (&QueueBase::m_nBytes),
"ns3::TracedValueCallback::Uint32")
;
return tid;
}
Queue::Queue() :
QueueBase::QueueBase () :
m_nBytes (0),
m_nTotalReceivedBytes (0),
m_nPackets (0),
m_nTotalReceivedPackets (0),
m_nTotalDroppedBytes (0),
m_nTotalDroppedBytesBeforeEnqueue (0),
m_nTotalDroppedBytesAfterDequeue (0),
m_nTotalDroppedPackets (0),
m_nTotalDroppedPacketsBeforeEnqueue (0),
m_nTotalDroppedPacketsAfterDequeue (0),
m_mode (QUEUE_MODE_PACKETS)
{
NS_LOG_FUNCTION (this);
}
Queue::~Queue()
QueueBase::~QueueBase ()
{
NS_LOG_FUNCTION (this);
}
bool
Queue::Enqueue (Ptr<QueueItem> item)
{
NS_LOG_FUNCTION (this << item);
if (m_mode == QUEUE_MODE_PACKETS && (m_nPackets.Get () >= m_maxPackets))
{
NS_LOG_LOGIC ("Queue full (at max packets) -- dropping pkt");
Drop (item);
return false;
}
if (m_mode == QUEUE_MODE_BYTES && (m_nBytes.Get () + item->GetPacketSize () > m_maxBytes))
{
NS_LOG_LOGIC ("Queue full (packet would exceed max bytes) -- dropping pkt");
Drop (item);
return false;
}
//
// If DoEnqueue fails, Queue::Drop is called by the subclass
//
bool retval = DoEnqueue (item);
if (retval)
{
NS_LOG_LOGIC ("m_traceEnqueue (p)");
m_traceEnqueue (item->GetPacket ());
uint32_t size = item->GetPacketSize ();
m_nBytes += size;
m_nTotalReceivedBytes += size;
m_nPackets++;
m_nTotalReceivedPackets++;
}
return retval;
}
Ptr<QueueItem>
Queue::Dequeue (void)
{
NS_LOG_FUNCTION (this);
if (m_nPackets.Get () == 0)
{
NS_LOG_LOGIC ("Queue empty");
return 0;
}
Ptr<QueueItem> item = DoDequeue ();
if (item != 0)
{
NS_ASSERT (m_nBytes.Get () >= item->GetPacketSize ());
NS_ASSERT (m_nPackets.Get () > 0);
m_nBytes -= item->GetPacketSize ();
m_nPackets--;
NS_LOG_LOGIC ("m_traceDequeue (packet)");
m_traceDequeue (item->GetPacket ());
}
return item;
}
Ptr<QueueItem>
Queue::Remove (void)
{
NS_LOG_FUNCTION (this);
if (m_nPackets.Get () == 0)
{
NS_LOG_LOGIC ("Queue empty");
return 0;
}
Ptr<QueueItem> item = DoRemove ();
if (item != 0)
{
NS_ASSERT (m_nBytes.Get () >= item->GetPacketSize ());
NS_ASSERT (m_nPackets.Get () > 0);
m_nBytes -= item->GetPacketSize ();
m_nPackets--;
Drop (item);
}
return item;
}
void
Queue::DequeueAll (void)
QueueBase::AppendItemTypeIfNotPresent (std::string& typeId, const std::string& itemType)
{
NS_LOG_FUNCTION (this);
while (!IsEmpty ())
if (typeId.back () != '>')
{
Dequeue ();
typeId.append ("<" + itemType + ">");
}
}
Ptr<const QueueItem>
Queue::Peek (void) const
{
NS_LOG_FUNCTION (this);
if (m_nPackets.Get () == 0)
{
NS_LOG_LOGIC ("Queue empty");
return 0;
}
return DoPeek ();
}
uint32_t
Queue::GetNPackets (void) const
{
NS_LOG_FUNCTION (this);
NS_LOG_LOGIC ("returns " << m_nPackets);
return m_nPackets;
}
uint32_t
Queue::GetNBytes (void) const
{
NS_LOG_FUNCTION (this);
NS_LOG_LOGIC (" returns " << m_nBytes);
return m_nBytes;
}
bool
Queue::IsEmpty (void) const
QueueBase::IsEmpty (void) const
{
NS_LOG_FUNCTION (this);
NS_LOG_LOGIC ("returns " << (m_nPackets.Get () == 0));
@@ -234,7 +105,23 @@ Queue::IsEmpty (void) const
}
uint32_t
Queue::GetTotalReceivedBytes (void) const
QueueBase::GetNPackets (void) const
{
NS_LOG_FUNCTION (this);
NS_LOG_LOGIC ("returns " << m_nPackets);
return m_nPackets;
}
uint32_t
QueueBase::GetNBytes (void) const
{
NS_LOG_FUNCTION (this);
NS_LOG_LOGIC (" returns " << m_nBytes);
return m_nBytes;
}
uint32_t
QueueBase::GetTotalReceivedBytes (void) const
{
NS_LOG_FUNCTION (this);
NS_LOG_LOGIC ("returns " << m_nTotalReceivedBytes);
@@ -242,7 +129,7 @@ Queue::GetTotalReceivedBytes (void) const
}
uint32_t
Queue::GetTotalReceivedPackets (void) const
QueueBase::GetTotalReceivedPackets (void) const
{
NS_LOG_FUNCTION (this);
NS_LOG_LOGIC ("returns " << m_nTotalReceivedPackets);
@@ -250,7 +137,7 @@ Queue::GetTotalReceivedPackets (void) const
}
uint32_t
Queue:: GetTotalDroppedBytes (void) const
QueueBase:: GetTotalDroppedBytes (void) const
{
NS_LOG_FUNCTION (this);
NS_LOG_LOGIC ("returns " << m_nTotalDroppedBytes);
@@ -258,25 +145,61 @@ Queue:: GetTotalDroppedBytes (void) const
}
uint32_t
Queue::GetTotalDroppedPackets (void) const
QueueBase:: GetTotalDroppedBytesBeforeEnqueue (void) const
{
NS_LOG_FUNCTION (this);
NS_LOG_LOGIC ("returns " << m_nTotalDroppedBytesBeforeEnqueue);
return m_nTotalDroppedBytesBeforeEnqueue;
}
uint32_t
QueueBase:: GetTotalDroppedBytesAfterDequeue (void) const
{
NS_LOG_FUNCTION (this);
NS_LOG_LOGIC ("returns " << m_nTotalDroppedBytesAfterDequeue);
return m_nTotalDroppedBytesAfterDequeue;
}
uint32_t
QueueBase::GetTotalDroppedPackets (void) const
{
NS_LOG_FUNCTION (this);
NS_LOG_LOGIC ("returns " << m_nTotalDroppedPackets);
return m_nTotalDroppedPackets;
}
void
Queue::ResetStatistics (void)
uint32_t
QueueBase::GetTotalDroppedPacketsBeforeEnqueue (void) const
{
NS_LOG_FUNCTION (this);
NS_LOG_LOGIC ("returns " << m_nTotalDroppedPacketsBeforeEnqueue);
return m_nTotalDroppedPacketsBeforeEnqueue;
}
uint32_t
QueueBase::GetTotalDroppedPacketsAfterDequeue (void) const
{
NS_LOG_FUNCTION (this);
NS_LOG_LOGIC ("returns " << m_nTotalDroppedPacketsAfterDequeue);
return m_nTotalDroppedPacketsAfterDequeue;
}
void
QueueBase::ResetStatistics (void)
{
NS_LOG_FUNCTION (this);
m_nTotalReceivedBytes = 0;
m_nTotalReceivedPackets = 0;
m_nTotalDroppedBytes = 0;
m_nTotalDroppedBytesBeforeEnqueue = 0;
m_nTotalDroppedBytesAfterDequeue = 0;
m_nTotalDroppedPackets = 0;
m_nTotalDroppedPacketsBeforeEnqueue = 0;
m_nTotalDroppedPacketsAfterDequeue = 0;
}
void
Queue::SetMode (Queue::QueueMode mode)
QueueBase::SetMode (QueueBase::QueueMode mode)
{
NS_LOG_FUNCTION (this << mode);
@@ -294,15 +217,15 @@ Queue::SetMode (Queue::QueueMode mode)
m_mode = mode;
}
Queue::QueueMode
Queue::GetMode (void) const
QueueBase::QueueMode
QueueBase::GetMode (void) const
{
NS_LOG_FUNCTION (this);
return m_mode;
}
void
Queue::SetMaxPackets (uint32_t maxPackets)
QueueBase::SetMaxPackets (uint32_t maxPackets)
{
NS_LOG_FUNCTION (this << maxPackets);
@@ -316,14 +239,14 @@ Queue::SetMaxPackets (uint32_t maxPackets)
}
uint32_t
Queue::GetMaxPackets (void) const
QueueBase::GetMaxPackets (void) const
{
NS_LOG_FUNCTION (this);
return m_maxPackets;
}
void
Queue::SetMaxBytes (uint32_t maxBytes)
QueueBase::SetMaxBytes (uint32_t maxBytes)
{
NS_LOG_FUNCTION (this << maxBytes);
@@ -337,40 +260,16 @@ Queue::SetMaxBytes (uint32_t maxBytes)
}
uint32_t
Queue::GetMaxBytes (void) const
QueueBase::GetMaxBytes (void) const
{
NS_LOG_FUNCTION (this);
return m_maxBytes;
}
void
Queue::SetDropCallback (DropCallback cb)
QueueBase::DoNsLog (const enum LogLevel level, std::string str) const
{
m_dropCallback = cb;
}
void
Queue::NotifyDrop (Ptr<QueueItem> item)
{
NS_LOG_FUNCTION (this << item);
if (!m_dropCallback.IsNull ())
{
m_dropCallback (item);
}
}
void
Queue::Drop (Ptr<QueueItem> item)
{
NS_LOG_FUNCTION (this << item);
m_nTotalDroppedPackets++;
m_nTotalDroppedBytes += item->GetPacketSize ();
NS_LOG_LOGIC ("m_traceDrop (p)");
m_traceDrop (item->GetPacket ());
NotifyDrop (item);
NS_LOG (level, str);
}
} // namespace ns3