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

network: Make Queue store QueueItem objects

Browse Source 
A QueueItem base class is introduced to represent the items stored
in a Queue. The base class only contains a Ptr<Packet>. Derived classes
can store additional information. DropTailQueue, RedQueue and CodelQueue,
along with their examples and testsuits, have been adapted. Objects using
such queues have been adapted too.
This commit is contained in:
Stefano Avallone
2016-03-08 10:44:03 -08:00
parent 5e677fd152
commit df2fa95970
17 changed files with 319 additions and 188 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
src/csma/model/csma-net-device.cc
View File

@@ -564,8 +564,9 @@ CsmaNetDevice::TransmitAbort (void)
}
else
{
m_currentPkt = m_queue->Dequeue ();
NS_ASSERT_MSG (m_currentPkt != 0, "CsmaNetDevice::TransmitAbort(): IsEmpty false but no Packet on queue?");
Ptr<QueueItem> item = m_queue->Dequeue ();
NS_ASSERT_MSG (item != 0, "CsmaNetDevice::TransmitAbort(): IsEmpty false but no Packet on queue?");
m_currentPkt = item->GetPacket ();
m_snifferTrace (m_currentPkt);
m_promiscSnifferTrace (m_currentPkt);
TransmitStart ();
@@ -632,8 +633,9 @@ CsmaNetDevice::TransmitReadyEvent (void)
}
else
{
m_currentPkt = m_queue->Dequeue ();
NS_ASSERT_MSG (m_currentPkt != 0, "CsmaNetDevice::TransmitReadyEvent(): IsEmpty false but no Packet on queue?");
Ptr<QueueItem> item = m_queue->Dequeue ();
NS_ASSERT_MSG (item != 0, "CsmaNetDevice::TransmitReadyEvent(): IsEmpty false but no Packet on queue?");
m_currentPkt = item->GetPacket ();
m_snifferTrace (m_currentPkt);
m_promiscSnifferTrace (m_currentPkt);
TransmitStart ();
@@ -968,7 +970,7 @@ CsmaNetDevice::SendFrom (Ptr<Packet> packet, const Address& src, const Address&
// Place the packet to be sent on the send queue. Note that the
// queue may fire a drop trace, but we will too.
//
if (m_queue->Enqueue (packet) == false)
if (m_queue->Enqueue (Create<QueueItem> (packet)) == false)
{
m_macTxDropTrace (packet);
return false;
@@ -983,8 +985,9 @@ CsmaNetDevice::SendFrom (Ptr<Packet> packet, const Address& src, const Address&
{
if (m_queue->IsEmpty () == false)
{
m_currentPkt = m_queue->Dequeue ();
NS_ASSERT_MSG (m_currentPkt != 0, "CsmaNetDevice::SendFrom(): IsEmpty false but no Packet on queue?");
Ptr<QueueItem> item = m_queue->Dequeue ();
NS_ASSERT_MSG (item != 0, "CsmaNetDevice::SendFrom(): IsEmpty false but no Packet on queue?");
m_currentPkt = item->GetPacket ();
m_promiscSnifferTrace (m_currentPkt);
m_snifferTrace (m_currentPkt);
TransmitStart ();

46
src/internet/model/codel-queue.cc
View File

@@ -276,9 +276,10 @@ CoDelQueue::GetMode (void)
}
bool
CoDelQueue::DoEnqueue (Ptr<Packet> p)
CoDelQueue::DoEnqueue (Ptr<QueueItem> item)
{
NS_LOG_FUNCTION (this << p);
NS_LOG_FUNCTION (this << item);
Ptr<Packet> p = item->GetPacket ();
if (m_mode == QUEUE_MODE_PACKETS && (m_packets.size () + 1 > m_maxPackets))
{
@@ -288,7 +289,7 @@ CoDelQueue::DoEnqueue (Ptr<Packet> p)
return false;
}
if (m_mode == QUEUE_MODE_BYTES && (m_bytesInQueue + p->GetSize () > m_maxBytes))
if (m_mode == QUEUE_MODE_BYTES && (m_bytesInQueue + item->GetPacketSize () > m_maxBytes))
{
NS_LOG_LOGIC ("Queue full (packet would exceed max bytes) -- droppping pkt");
Drop (p);
@@ -300,8 +301,8 @@ CoDelQueue::DoEnqueue (Ptr<Packet> p)
CoDelTimestampTag tag;
p->AddPacketTag (tag);
m_bytesInQueue += p->GetSize ();
m_packets.push (p);
m_bytesInQueue += item->GetPacketSize ();
m_packets.push (item);
NS_LOG_LOGIC ("Number packets " << m_packets.size ());
NS_LOG_LOGIC ("Number bytes " << m_bytesInQueue);
@@ -351,7 +352,7 @@ CoDelQueue::OkToDrop (Ptr<Packet> p, uint32_t now)
return okToDrop;
}
Ptr<Packet>
Ptr<QueueItem>
CoDelQueue::DoDequeue (void)
{
NS_LOG_FUNCTION (this);
@@ -365,11 +366,12 @@ CoDelQueue::DoDequeue (void)
return 0;
}
uint32_t now = CoDelGetTime ();
Ptr<Packet> p = m_packets.front ();
Ptr<QueueItem> item = m_packets.front ();
m_packets.pop ();
m_bytesInQueue -= p->GetSize ();
Ptr<Packet> p = item->GetPacket ();
m_bytesInQueue -= item->GetPacketSize ();
NS_LOG_LOGIC ("Popped " << p);
NS_LOG_LOGIC ("Popped " << item);
NS_LOG_LOGIC ("Number packets remaining " << m_packets.size ());
NS_LOG_LOGIC ("Number bytes remaining " << m_bytesInQueue);
@@ -403,7 +405,7 @@ CoDelQueue::DoDequeue (void)
// p was in queue, trace dequeue and update stats manually
m_traceDequeue (p);
m_nBytes -= p->GetSize ();
m_nBytes -= item->GetPacketSize ();
m_nPackets--;
++m_dropCount;
@@ -416,11 +418,12 @@ CoDelQueue::DoDequeue (void)
++m_states;
return 0;
}
p = m_packets.front ();
item = m_packets.front ();
m_packets.pop ();
m_bytesInQueue -= p->GetSize ();
p = item ->GetPacket ();
m_bytesInQueue -= item->GetPacketSize ();
NS_LOG_LOGIC ("Popped " << p);
NS_LOG_LOGIC ("Popped " << item);
NS_LOG_LOGIC ("Number packets remaining " << m_packets.size ());
NS_LOG_LOGIC ("Number bytes remaining " << m_bytesInQueue);
@@ -454,7 +457,7 @@ CoDelQueue::DoDequeue (void)
// p was in queue, trace the dequeue and update stats manually
m_traceDequeue (p);
m_nBytes -= p->GetSize ();
m_nBytes -= item->GetPacketSize ();
m_nPackets--;
if (m_packets.empty ())
@@ -466,11 +469,12 @@ CoDelQueue::DoDequeue (void)
}
else
{
p = m_packets.front ();
item = m_packets.front ();
m_packets.pop ();
m_bytesInQueue -= p->GetSize ();
p = item->GetPacket ();
m_bytesInQueue -= item->GetPacketSize ();
NS_LOG_LOGIC ("Popped " << p);
NS_LOG_LOGIC ("Popped " << item);
NS_LOG_LOGIC ("Number packets remaining " << m_packets.size ());
NS_LOG_LOGIC ("Number bytes remaining " << m_bytesInQueue);
@@ -501,7 +505,7 @@ CoDelQueue::DoDequeue (void)
}
}
++m_states;
return p;
return item;
}
uint32_t
@@ -552,7 +556,7 @@ CoDelQueue::GetDropNext (void)
return m_dropNext;
}
Ptr<const Packet>
Ptr<const QueueItem>
CoDelQueue::DoPeek (void) const
{
NS_LOG_FUNCTION (this);
@@ -563,12 +567,12 @@ CoDelQueue::DoPeek (void) const
return 0;
}
Ptr<Packet> p = m_packets.front ();
Ptr<QueueItem> item = m_packets.front ();
NS_LOG_LOGIC ("Number packets " << m_packets.size ());
NS_LOG_LOGIC ("Number bytes " << m_bytesInQueue);
return p;
return item;
}
bool

10
src/internet/model/codel-queue.h
View File

@@ -142,10 +142,10 @@ private:
/**
* \brief Add a packet to the queue
*
* \param p The packet to be added
* \param item The item to be added
* \returns True if the packet can be added, False if the packet is dropped due to full queue
*/
virtual bool DoEnqueue (Ptr<Packet> p);
virtual bool DoEnqueue (Ptr<QueueItem> item);
/**
* \brief Remove a packet from queue based on the current state
@@ -156,9 +156,9 @@ private:
*
* \returns The packet that is examined
*/
virtual Ptr<Packet> DoDequeue (void);
virtual Ptr<QueueItem> DoDequeue (void);
virtual Ptr<const Packet> DoPeek (void) const;
virtual Ptr<const QueueItem> DoPeek (void) const;
/**
* \brief Calculate the reciprocal square root of m_count by using Newton's method
@@ -223,7 +223,7 @@ private:
*/
uint32_t Time2CoDel (Time t);
std::queue<Ptr<Packet> > m_packets; //!< The packet queue
std::queue<Ptr<QueueItem> > m_packets; //!< The packet queue
uint32_t m_maxPackets; //!< Max # of packets accepted by the queue
uint32_t m_maxBytes; //!< Max # of bytes accepted by the queue
TracedValue<uint32_t> m_bytesInQueue; //!< The total number of bytes in queue

66
src/internet/test/codel-queue-test-suite.cc
View File

@@ -125,55 +125,55 @@ CoDelQueueBasicEnqueueDequeue::DoRun (void)
p6 = Create<Packet> (pktSize);
QueueTestSize (queue, 0 * modeSize, "There should be no packets in queue");
queue->Enqueue (p1);
queue->Enqueue (Create<QueueItem> (p1));
QueueTestSize (queue, 1 * modeSize, "There should be one packet in queue");
queue->Enqueue (p2);
queue->Enqueue (Create<QueueItem> (p2));
QueueTestSize (queue, 2 * modeSize, "There should be two packets in queue");
queue->Enqueue (p3);
queue->Enqueue (Create<QueueItem> (p3));
QueueTestSize (queue, 3 * modeSize, "There should be three packets in queue");
queue->Enqueue (p4);
queue->Enqueue (Create<QueueItem> (p4));
QueueTestSize (queue, 4 * modeSize, "There should be four packets in queue");
queue->Enqueue (p5);
queue->Enqueue (Create<QueueItem> (p5));
QueueTestSize (queue, 5 * modeSize, "There should be five packets in queue");
queue->Enqueue (p6);
queue->Enqueue (Create<QueueItem> (p6));
QueueTestSize (queue, 6 * modeSize, "There should be six packets in queue");
NS_TEST_EXPECT_MSG_EQ (queue->GetDropOverLimit (), 0, "There should be no packets being dropped due to full queue");
Ptr<Packet> p;
Ptr<QueueItem> item;
p = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((p != 0), true, "I want to remove the first packet");
item = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((item != 0), true, "I want to remove the first packet");
QueueTestSize (queue, 5 * modeSize, "There should be five packets in queue");
NS_TEST_EXPECT_MSG_EQ (p->GetUid (), p1->GetUid (), "was this the first packet ?");
NS_TEST_EXPECT_MSG_EQ (item->GetPacket ()->GetUid (), p1->GetUid (), "was this the first packet ?");
p = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((p != 0), true, "I want to remove the second packet");
item = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((item != 0), true, "I want to remove the second packet");
QueueTestSize (queue, 4 * modeSize, "There should be four packets in queue");
NS_TEST_EXPECT_MSG_EQ (p->GetUid (), p2->GetUid (), "Was this the second packet ?");
NS_TEST_EXPECT_MSG_EQ (item->GetPacket ()->GetUid (), p2->GetUid (), "Was this the second packet ?");
p = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((p != 0), true, "I want to remove the third packet");
item = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((item != 0), true, "I want to remove the third packet");
QueueTestSize (queue, 3 * modeSize, "There should be three packets in queue");
NS_TEST_EXPECT_MSG_EQ (p->GetUid (), p3->GetUid (), "Was this the third packet ?");
NS_TEST_EXPECT_MSG_EQ (item->GetPacket ()->GetUid (), p3->GetUid (), "Was this the third packet ?");
p = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((p != 0), true, "I want to remove the forth packet");
item = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((item != 0), true, "I want to remove the forth packet");
QueueTestSize (queue, 2 * modeSize, "There should be two packets in queue");
NS_TEST_EXPECT_MSG_EQ (p->GetUid (), p4->GetUid (), "Was this the fourth packet ?");
NS_TEST_EXPECT_MSG_EQ (item->GetPacket ()->GetUid (), p4->GetUid (), "Was this the fourth packet ?");
p = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((p != 0), true, "I want to remove the fifth packet");
item = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((item != 0), true, "I want to remove the fifth packet");
QueueTestSize (queue, 1 * modeSize, "There should be one packet in queue");
NS_TEST_EXPECT_MSG_EQ (p->GetUid (), p5->GetUid (), "Was this the fifth packet ?");
NS_TEST_EXPECT_MSG_EQ (item->GetPacket ()->GetUid (), p5->GetUid (), "Was this the fifth packet ?");
p = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((p != 0), true, "I want to remove the last packet");
item = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((item != 0), true, "I want to remove the last packet");
QueueTestSize (queue, 0 * modeSize, "There should be zero packet in queue");
NS_TEST_EXPECT_MSG_EQ (p->GetUid (), p6->GetUid (), "Was this the sixth packet ?");
NS_TEST_EXPECT_MSG_EQ (item->GetPacket ()->GetUid (), p6->GetUid (), "Was this the sixth packet ?");
p = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((p == 0), true, "There are really no packets in queue");
item = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((item == 0), true, "There are really no packets in queue");
NS_TEST_EXPECT_MSG_EQ (queue->GetDropCount (), 0, "There should be no packet drops according to CoDel algorithm");
}
@@ -242,9 +242,9 @@ CoDelQueueBasicOverflow::DoRun (void)
"Verify that we can actually set the attribute MinBytes");
Enqueue (queue, pktSize, 500);
queue->Enqueue (p1);
queue->Enqueue (p2);
queue->Enqueue (p3);
queue->Enqueue (Create<QueueItem> (p1));
queue->Enqueue (Create<QueueItem> (p2));
queue->Enqueue (Create<QueueItem> (p3));
QueueTestSize (queue, 500 * modeSize, "There should be 500 packets in queue");
NS_TEST_EXPECT_MSG_EQ (queue->GetDropOverLimit (), 3, "There should be three packets being dropped due to full queue");
@@ -255,7 +255,7 @@ CoDelQueueBasicOverflow::Enqueue (Ptr<CoDelQueue> queue, uint32_t size, uint32_t
{
for (uint32_t i = 0; i < nPkt; i++)
{
queue->Enqueue (Create<Packet> (size));
queue->Enqueue (Create<QueueItem> (Create<Packet> (size)));
}
}
@@ -435,7 +435,7 @@ CoDelQueueBasicDrop::Enqueue (Ptr<CoDelQueue> queue, uint32_t size, uint32_t nPk
{
for (uint32_t i = 0; i < nPkt; i++)
{
queue->Enqueue (Create<Packet> (size));
queue->Enqueue (Create<QueueItem> (Create<Packet> (size)));
}
}
@@ -455,7 +455,7 @@ CoDelQueueBasicDrop::Dequeue (Ptr<CoDelQueue> queue, uint32_t modeSize)
if (initialQSize != 0)
{
Ptr<Packet> p = queue->Dequeue ();
Ptr<QueueItem> item = queue->Dequeue ();
if (initialDropCount == 0 && currentTime > queue->GetTarget ())
{
if (currentTime < queue->GetInterval ())

38
src/network/model/net-device.cc
View File

@@ -22,11 +22,49 @@
#include "ns3/log.h"
#include "ns3/uinteger.h"
#include "net-device.h"
#include "packet.h"
namespace ns3 {
NS_LOG_COMPONENT_DEFINE ("NetDevice");
QueueItem::QueueItem (Ptr<Packet> p)
{
m_packet = p;
}
QueueItem::~QueueItem()
{
NS_LOG_FUNCTION (this);
m_packet = 0;
}
Ptr<Packet>
QueueItem::GetPacket (void) const
{
return m_packet;
}
uint32_t
QueueItem::GetPacketSize (void) const
{
NS_ASSERT (m_packet != 0);
return m_packet->GetSize ();
}
void
QueueItem::Print (std::ostream& os) const
{
os << GetPacket();
}
std::ostream & operator << (std::ostream &os, const QueueItem &item)
{
item.Print (os);
return os;
}
NS_OBJECT_ENSURE_REGISTERED (NetDevice);
TypeId NetDevice::GetTypeId (void)

82
src/network/model/net-device.h
View File

@@ -40,6 +40,88 @@ class Packet;
* \ingroup network
* \defgroup netdevice Network Device
*/
/**
* \ingroup netdevice
* \brief Base class to represent items of packet Queues
*
* An item stored in an ns-3 packet Queue contains a packet and possibly other
* information. An item of the base class only contains a packet. Subclasses
* can be derived from this base class to allow items to contain additional
* information.
*/
class QueueItem : public SimpleRefCount<QueueItem>
{
public:
/**
* \brief Create a queue item containing a packet.
* \param p the packet included in the created item.
*/
QueueItem (Ptr<Packet> p);
virtual ~QueueItem ();
/**
* \return the packet included in this item.
*/
Ptr<Packet> GetPacket (void) const;
/**
* \brief Use this method (instead of GetPacket ()->GetSize ()) to get the packet size
*
* Subclasses may keep header and payload separate to allow manipulating the header,
* so using this method ensures that the correct packet size is returned.
*
* \return the size of the packet included in this item.
*/
virtual uint32_t GetPacketSize (void) const;
/**
* \brief Print the item contents.
* \param os output stream in which the data should be printed.
*/
virtual void Print (std::ostream &os) const;
/**
* TracedCallback signature for Ptr<QueueItem>
*
* \param [in] item The queue item.
*/
typedef void (* TracedCallback) (Ptr<const QueueItem> item);
private:
/**
* \brief Default constructor
*
* Defined and unimplemented to avoid misuse
*/
QueueItem ();
/**
* \brief Copy constructor
*
* Defined and unimplemented to avoid misuse
*/
QueueItem (const QueueItem &);
/**
* \brief Assignment operator
*
* Defined and unimplemented to avoid misuse
* \returns
*/
QueueItem &operator = (const QueueItem &);
Ptr<Packet> m_packet;
};
/**
* \brief Stream insertion operator.
*
* \param os the stream
* \param item the item
* \returns a reference to the stream
*/
std::ostream& operator<< (std::ostream& os, const QueueItem &item);
/**
* \ingroup netdevice
*

32
src/network/test/drop-tail-queue-test-suite.cc
View File

@@ -47,34 +47,34 @@ DropTailQueueTestCase::DoRun (void)
p4 = Create<Packet> ();
NS_TEST_EXPECT_MSG_EQ (queue->GetNPackets (), 0, "There should be no packets in there");
queue->Enqueue (p1);
queue->Enqueue (Create<QueueItem> (p1));
NS_TEST_EXPECT_MSG_EQ (queue->GetNPackets (), 1, "There should be one packet in there");
queue->Enqueue (p2);
queue->Enqueue (Create<QueueItem> (p2));
NS_TEST_EXPECT_MSG_EQ (queue->GetNPackets (), 2, "There should be two packets in there");
queue->Enqueue (p3);
queue->Enqueue (Create<QueueItem> (p3));
NS_TEST_EXPECT_MSG_EQ (queue->GetNPackets (), 3, "There should be three packets in there");
queue->Enqueue (p4); // will be dropped
queue->Enqueue (Create<QueueItem> (p4)); // will be dropped
NS_TEST_EXPECT_MSG_EQ (queue->GetNPackets (), 3, "There should be still three packets in there");
Ptr<Packet> p;
Ptr<QueueItem> item;
p = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((p != 0), true, "I want to remove the first packet");
item = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((item != 0), true, "I want to remove the first packet");
NS_TEST_EXPECT_MSG_EQ (queue->GetNPackets (), 2, "There should be two packets in there");
NS_TEST_EXPECT_MSG_EQ (p->GetUid (), p1->GetUid (), "was this the first packet ?");
NS_TEST_EXPECT_MSG_EQ (item->GetPacket ()->GetUid (), p1->GetUid (), "was this the first packet ?");
p = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((p != 0), true, "I want to remove the second packet");
item = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((item != 0), true, "I want to remove the second packet");
NS_TEST_EXPECT_MSG_EQ (queue->GetNPackets (), 1, "There should be one packet in there");
NS_TEST_EXPECT_MSG_EQ (p->GetUid (), p2->GetUid (), "Was this the second packet ?");
NS_TEST_EXPECT_MSG_EQ (item->GetPacket ()->GetUid (), p2->GetUid (), "Was this the second packet ?");
p = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((p != 0), true, "I want to remove the third packet");
item = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((item != 0), true, "I want to remove the third packet");
NS_TEST_EXPECT_MSG_EQ (queue->GetNPackets (), 0, "There should be no packets in there");
NS_TEST_EXPECT_MSG_EQ (p->GetUid (), p3->GetUid (), "Was this the third packet ?");
NS_TEST_EXPECT_MSG_EQ (item->GetPacket ()->GetUid (), p3->GetUid (), "Was this the third packet ?");
p = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((p == 0), true, "There are really no packets in there");
item = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((item == 0), true, "There are really no packets in there");
}
static class DropTailQueueTestSuite : public TestSuite

52
src/network/test/red-queue-test-suite.cc
View File

@@ -86,43 +86,43 @@ RedQueueTestCase::RunRedTest (StringValue mode)
p8 = Create<Packet> (pktSize);
NS_TEST_EXPECT_MSG_EQ (queue->GetQueueSize (), 0 * modeSize, "There should be no packets in there");
queue->Enqueue (p1);
queue->Enqueue (Create<QueueItem> (p1));
NS_TEST_EXPECT_MSG_EQ (queue->GetQueueSize (), 1 * modeSize, "There should be one packet in there");
queue->Enqueue (p2);
queue->Enqueue (Create<QueueItem> (p2));
NS_TEST_EXPECT_MSG_EQ (queue->GetQueueSize (), 2 * modeSize, "There should be two packets in there");
queue->Enqueue (p3);
queue->Enqueue (p4);
queue->Enqueue (p5);
queue->Enqueue (p6);
queue->Enqueue (p7);
queue->Enqueue (p8);
queue->Enqueue (Create<QueueItem> (p3));
queue->Enqueue (Create<QueueItem> (p4));
queue->Enqueue (Create<QueueItem> (p5));
queue->Enqueue (Create<QueueItem> (p6));
queue->Enqueue (Create<QueueItem> (p7));
queue->Enqueue (Create<QueueItem> (p8));
NS_TEST_EXPECT_MSG_EQ (queue->GetQueueSize (), 8 * modeSize, "There should be eight packets in there");
Ptr<Packet> p;
Ptr<QueueItem> item;
p = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((p != 0), true, "I want to remove the first packet");
item = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((item != 0), true, "I want to remove the first packet");
NS_TEST_EXPECT_MSG_EQ (queue->GetQueueSize (), 7 * modeSize, "There should be seven packets in there");
NS_TEST_EXPECT_MSG_EQ (p->GetUid (), p1->GetUid (), "was this the first packet ?");
NS_TEST_EXPECT_MSG_EQ (item->GetPacket ()->GetUid (), p1->GetUid (), "was this the first packet ?");
p = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((p != 0), true, "I want to remove the second packet");
item = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((item != 0), true, "I want to remove the second packet");
NS_TEST_EXPECT_MSG_EQ (queue->GetQueueSize (), 6 * modeSize, "There should be six packet in there");
NS_TEST_EXPECT_MSG_EQ (p->GetUid (), p2->GetUid (), "Was this the second packet ?");
NS_TEST_EXPECT_MSG_EQ (item->GetPacket ()->GetUid (), p2->GetUid (), "Was this the second packet ?");
p = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((p != 0), true, "I want to remove the third packet");
item = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((item != 0), true, "I want to remove the third packet");
NS_TEST_EXPECT_MSG_EQ (queue->GetQueueSize (), 5 * modeSize, "There should be five packets in there");
NS_TEST_EXPECT_MSG_EQ (p->GetUid (), p3->GetUid (), "Was this the third packet ?");
NS_TEST_EXPECT_MSG_EQ (item->GetPacket ()->GetUid (), p3->GetUid (), "Was this the third packet ?");
p = queue->Dequeue ();
p = queue->Dequeue ();
p = queue->Dequeue ();
p = queue->Dequeue ();
p = queue->Dequeue ();
item = queue->Dequeue ();
item = queue->Dequeue ();
item = queue->Dequeue ();
item = queue->Dequeue ();
item = queue->Dequeue ();
p = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((p == 0), true, "There are really no packets in there");
item = queue->Dequeue ();
NS_TEST_EXPECT_MSG_EQ ((item == 0), true, "There are really no packets in there");
// test 2: more data, but with no drops
@@ -257,7 +257,7 @@ RedQueueTestCase::Enqueue (Ptr<RedQueue> queue, uint32_t size, uint32_t nPkt)
{
for (uint32_t i = 0; i < nPkt; i++)
{
queue->Enqueue (Create<Packet> (size));
queue->Enqueue (Create<QueueItem> (Create<Packet> (size)));
}
}

27
src/network/utils/drop-tail-queue.cc
View File

@@ -83,9 +83,10 @@ DropTailQueue::GetMode (void) const
}
bool
DropTailQueue::DoEnqueue (Ptr<Packet> p)
DropTailQueue::DoEnqueue (Ptr<QueueItem> item)
{
NS_LOG_FUNCTION (this << p);
NS_LOG_FUNCTION (this << item);
Ptr<Packet> p = item->GetPacket ();
if (m_mode == QUEUE_MODE_PACKETS && (m_packets.size () >= m_maxPackets))
{
@@ -94,15 +95,15 @@ DropTailQueue::DoEnqueue (Ptr<Packet> p)
return false;
}
if (m_mode == QUEUE_MODE_BYTES && (m_bytesInQueue + p->GetSize () >= m_maxBytes))
if (m_mode == QUEUE_MODE_BYTES && (m_bytesInQueue + item->GetPacketSize () >= m_maxBytes))
{
NS_LOG_LOGIC ("Queue full (packet would exceed max bytes) -- droppping pkt");
Drop (p);
return false;
}
m_bytesInQueue += p->GetSize ();
m_packets.push (p);
m_bytesInQueue += item->GetPacketSize ();
m_packets.push (item);
NS_LOG_LOGIC ("Number packets " << m_packets.size ());
NS_LOG_LOGIC ("Number bytes " << m_bytesInQueue);
@@ -110,7 +111,7 @@ DropTailQueue::DoEnqueue (Ptr<Packet> p)
return true;
}
Ptr<Packet>
Ptr<QueueItem>
DropTailQueue::DoDequeue (void)
{
NS_LOG_FUNCTION (this);
@@ -121,19 +122,19 @@ DropTailQueue::DoDequeue (void)
return 0;
}
Ptr<Packet> p = m_packets.front ();
Ptr<QueueItem> item = m_packets.front ();
m_packets.pop ();
m_bytesInQueue -= p->GetSize ();
m_bytesInQueue -= item->GetPacketSize ();
NS_LOG_LOGIC ("Popped " << p);
NS_LOG_LOGIC ("Popped " << item);
NS_LOG_LOGIC ("Number packets " << m_packets.size ());
NS_LOG_LOGIC ("Number bytes " << m_bytesInQueue);
return p;
return item;
}
Ptr<const Packet>
Ptr<const QueueItem>
DropTailQueue::DoPeek (void) const
{
NS_LOG_FUNCTION (this);
@@ -144,12 +145,12 @@ DropTailQueue::DoPeek (void) const
return 0;
}
Ptr<Packet> p = m_packets.front ();
Ptr<QueueItem> item = m_packets.front ();
NS_LOG_LOGIC ("Number packets " << m_packets.size ());
NS_LOG_LOGIC ("Number bytes " << m_bytesInQueue);
return p;
return item;
}
} // namespace ns3

8
src/network/utils/drop-tail-queue.h
View File

@@ -64,11 +64,11 @@ public:
DropTailQueue::QueueMode GetMode (void) const;
private:
virtual bool DoEnqueue (Ptr<Packet> p);
virtual Ptr<Packet> DoDequeue (void);
virtual Ptr<const Packet> DoPeek (void) const;
virtual bool DoEnqueue (Ptr<QueueItem> item);
virtual Ptr<QueueItem> DoDequeue (void);
virtual Ptr<const QueueItem> DoPeek (void) const;
std::queue<Ptr<Packet> > m_packets; //!< the packets in the queue
std::queue<Ptr<QueueItem> > m_packets; //!< the items in the queue
uint32_t m_maxPackets; //!< max packets in the queue
uint32_t m_maxBytes; //!< max bytes in the queue
uint32_t m_bytesInQueue; //!< actual bytes in the queue

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

@@ -63,20 +63,20 @@ Queue::~Queue()
bool
Queue::Enqueue (Ptr<Packet> p)
Queue::Enqueue (Ptr<QueueItem> item)
{
NS_LOG_FUNCTION (this << p);
NS_LOG_FUNCTION (this << item);
//
// If DoEnqueue fails, Queue::Drop is called by the subclass
//
bool retval = DoEnqueue (p);
bool retval = DoEnqueue (item);
if (retval)
{
NS_LOG_LOGIC ("m_traceEnqueue (p)");
m_traceEnqueue (p);
m_traceEnqueue (item->GetPacket ());
uint32_t size = p->GetSize ();
uint32_t size = item->GetPacketSize ();
m_nBytes += size;
m_nTotalReceivedBytes += size;
@@ -86,25 +86,26 @@ Queue::Enqueue (Ptr<Packet> p)
return retval;
}
Ptr<Packet>
Ptr<QueueItem>
Queue::Dequeue (void)
{
NS_LOG_FUNCTION (this);
Ptr<Packet> packet = DoDequeue ();
Ptr<QueueItem> item = DoDequeue ();
if (packet != 0)
if (item != 0)
{
NS_ASSERT (m_nBytes >= packet->GetSize ());
Ptr<Packet> packet = item->GetPacket ();
NS_ASSERT (m_nBytes >= item->GetPacketSize ());
NS_ASSERT (m_nPackets > 0);
m_nBytes -= packet->GetSize ();
m_nBytes -= item->GetPacketSize ();
m_nPackets--;
NS_LOG_LOGIC ("m_traceDequeue (packet)");
m_traceDequeue (packet);
}
return packet;
return item;
}
void
@@ -117,7 +118,7 @@ Queue::DequeueAll (void)
}
}
Ptr<const Packet>
Ptr<const QueueItem>
Queue::Peek (void) const
{
NS_LOG_FUNCTION (this);

43
src/network/utils/queue.h
View File

@@ -24,11 +24,10 @@
#ifndef QUEUE_H
#define QUEUE_H
#include <string>
#include <list>
#include "ns3/packet.h"
#include "ns3/object.h"
#include "ns3/traced-callback.h"
#include "ns3/net-device.h"
namespace ns3 {
@@ -59,21 +58,21 @@ public:
*/
bool IsEmpty (void) const;
/**
* Place a packet into the rear of the Queue
* \param p packet to enqueue
* Place a queue item into the rear of the Queue
* \param item item to enqueue
* \return True if the operation was successful; false otherwise
*/
bool Enqueue (Ptr<Packet> p);
bool Enqueue (Ptr<QueueItem> item);
/**
* Remove a packet from the front of the Queue
* \return 0 if the operation was not successful; the packet otherwise.
* Remove an item from the front of the Queue
* \return 0 if the operation was not successful; the item otherwise.
*/
Ptr<Packet> Dequeue (void);
Ptr<QueueItem> Dequeue (void);
/**
* Get a copy of the item at the front of the queue without removing it
* \return 0 if the operation was not successful; the packet otherwise.
* \return 0 if the operation was not successful; the item otherwise.
*/
Ptr<const Packet> Peek (void) const;
Ptr<const QueueItem> Peek (void) const;
/**
* Flush the queue.
@@ -156,29 +155,29 @@ public:
private:
/**
* Push a packet in the queue
* \param p the packet to enqueue
* Push an item in the queue
* \param item the item to enqueue
* \return true if success, false if the packet has been dropped.
*/
virtual bool DoEnqueue (Ptr<Packet> p) = 0;
virtual bool DoEnqueue (Ptr<QueueItem> item) = 0;
/**
* Pull a packet from the queue
* \return the packet.
* Pull an item from the queue
* \return the item.
*/
virtual Ptr<Packet> DoDequeue (void) = 0;
virtual Ptr<QueueItem> DoDequeue (void) = 0;
/**
* Peek the front packet in the queue
* \return the packet.
* Peek the front item in the queue
* \return the item.
*/
virtual Ptr<const Packet> DoPeek (void) const = 0;
virtual Ptr<const QueueItem> DoPeek (void) const = 0;
protected:
/**
* \brief Drop a packet
* \param packet packet that was dropped
* \brief Drop a packet
* \param p packet that was dropped
* This method is called by subclasses to notify parent (this class) of packet drops.
*/
void Drop (Ptr<Packet> packet);
void Drop (Ptr<Packet> p);
/// Traced callback: fired when a packet is enqueued
TracedCallback<Ptr<const Packet> > m_traceEnqueue;

29
src/network/utils/red-queue.cc
View File

@@ -209,9 +209,10 @@ RedQueue::AssignStreams (int64_t stream)
}
bool
RedQueue::DoEnqueue (Ptr<Packet> p)
RedQueue::DoEnqueue (Ptr<QueueItem> item)
{
NS_LOG_FUNCTION (this << p);
NS_LOG_FUNCTION (this << item);
Ptr<Packet> p = item->GetPacket ();
if (!m_hasRedStarted )
{
@@ -260,7 +261,7 @@ RedQueue::DoEnqueue (Ptr<Packet> p)
NS_LOG_DEBUG ("\t packetsInQueue " << m_packets.size () << "\tQavg " << m_qAvg);
m_count++;
m_countBytes += p->GetSize ();
m_countBytes += item->GetPacketSize ();
uint32_t dropType = DTYPE_NONE;
if (m_qAvg >= m_minTh && nQueued > 1)
@@ -280,7 +281,7 @@ RedQueue::DoEnqueue (Ptr<Packet> p)
* above "minthresh" with a nonempty queue.
*/
m_count = 1;
m_countBytes = p->GetSize ();
m_countBytes = item->GetPacketSize ();
m_old = 1;
}
else if (DropEarly (p, nQueued))
@@ -323,8 +324,8 @@ RedQueue::DoEnqueue (Ptr<Packet> p)
return false;
}
m_bytesInQueue += p->GetSize ();
m_packets.push_back (p);
m_bytesInQueue += item->GetPacketSize ();
m_packets.push_back (item);
NS_LOG_LOGIC ("Number packets " << m_packets.size ());
NS_LOG_LOGIC ("Number bytes " << m_bytesInQueue);
@@ -603,7 +604,7 @@ RedQueue::GetQueueSize (void)
}
}
Ptr<Packet>
Ptr<QueueItem>
RedQueue::DoDequeue (void)
{
NS_LOG_FUNCTION (this);
@@ -619,20 +620,20 @@ RedQueue::DoDequeue (void)
else
{
m_idle = 0;
Ptr<Packet> p = m_packets.front ();
Ptr<QueueItem> item = m_packets.front ();
m_packets.pop_front ();
m_bytesInQueue -= p->GetSize ();
m_bytesInQueue -= item->GetPacketSize ();
NS_LOG_LOGIC ("Popped " << p);
NS_LOG_LOGIC ("Popped " << item);
NS_LOG_LOGIC ("Number packets " << m_packets.size ());
NS_LOG_LOGIC ("Number bytes " << m_bytesInQueue);
return p;
return item;
}
}
Ptr<const Packet>
Ptr<const QueueItem>
RedQueue::DoPeek (void) const
{
NS_LOG_FUNCTION (this);
@@ -642,12 +643,12 @@ RedQueue::DoPeek (void) const
return 0;
}
Ptr<Packet> p = m_packets.front ();
Ptr<QueueItem> item = m_packets.front ();
NS_LOG_LOGIC ("Number packets " << m_packets.size ());
NS_LOG_LOGIC ("Number bytes " << m_bytesInQueue);
return p;
return item;
}
} // namespace ns3

8
src/network/utils/red-queue.h
View File

@@ -177,9 +177,9 @@ public:
int64_t AssignStreams (int64_t stream);
private:
virtual bool DoEnqueue (Ptr<Packet> p);
virtual Ptr<Packet> DoDequeue (void);
virtual Ptr<const Packet> DoPeek (void) const;
virtual bool DoEnqueue (Ptr<QueueItem> item);
virtual Ptr<QueueItem> DoDequeue (void);
virtual Ptr<const QueueItem> DoPeek (void) const;
/**
* \brief Initialize the queue parameters.
@@ -233,7 +233,7 @@ private:
double ModifyP (double p, uint32_t count, uint32_t countBytes,
uint32_t meanPktSize, bool wait, uint32_t size);
std::list<Ptr<Packet> > m_packets; //!< packets in the queue
std::list<Ptr<QueueItem> > m_packets; //!< packets in the queue
uint32_t m_bytesInQueue; //!< bytes in the queue
bool m_hasRedStarted; //!< True if RED has started

6
src/network/utils/simple-net-device.cc
View File

@@ -444,11 +444,11 @@ SimpleNetDevice::SendFrom (Ptr<Packet> p, const Address& source, const Address&
p->AddPacketTag (tag);
if (m_queue->Enqueue (p))
if (m_queue->Enqueue (Create<QueueItem> (p)))
{
if (m_queue->GetNPackets () == 1 && !TransmitCompleteEvent.IsRunning ())
{
p = m_queue->Dequeue ();
p = m_queue->Dequeue ()->GetPacket ();
p->RemovePacketTag (tag);
Time txTime = Time (0);
if (m_bps > DataRate (0))
@@ -477,7 +477,7 @@ SimpleNetDevice::TransmitComplete ()
return;
}
Ptr<Packet> packet = m_queue->Dequeue ();
Ptr<Packet> packet = m_queue->Dequeue ()->GetPacket ();
SimpleTag tag;
packet->RemovePacketTag (tag);

9
src/point-to-point/model/point-to-point-net-device.cc
View File

@@ -280,8 +280,8 @@ PointToPointNetDevice::TransmitComplete (void)
m_phyTxEndTrace (m_currentPkt);
m_currentPkt = 0;
Ptr<Packet> p = m_queue->Dequeue ();
if (p == 0)
Ptr<QueueItem> item = m_queue->Dequeue ();
if (item == 0)
{
//
// No packet was on the queue, so we just exit.
@@ -292,6 +292,7 @@ PointToPointNetDevice::TransmitComplete (void)
//
// Got another packet off of the queue, so start the transmit process agin.
//
Ptr<Packet> p = item->GetPacket ();
m_snifferTrace (p);
m_promiscSnifferTrace (p);
TransmitStart (p);
@@ -535,14 +536,14 @@ PointToPointNetDevice::Send (
//
// We should enqueue and dequeue the packet to hit the tracing hooks.
//
if (m_queue->Enqueue (packet))
if (m_queue->Enqueue (Create<QueueItem> (packet)))
{
//
// If the channel is ready for transition we send the packet right now
//
if (m_txMachineState == READY)
{
packet = m_queue->Dequeue ();
packet = m_queue->Dequeue ()->GetPacket ();
m_snifferTrace (packet);
m_promiscSnifferTrace (packet);
return TransmitStart (packet);

9
src/spectrum/model/aloha-noack-net-device.cc
View File

@@ -378,7 +378,7 @@ AlohaNoackNetDevice::SendFrom (Ptr<Packet> packet, const Address& src, const Add
else
{
NS_LOG_LOGIC ("enqueueing new packet");
if (m_queue->Enqueue (packet) == false)
if (m_queue->Enqueue (Create<QueueItem> (packet)) == false)
{
m_macTxDropTrace (packet);
sendOk = false;
@@ -389,7 +389,7 @@ AlohaNoackNetDevice::SendFrom (Ptr<Packet> packet, const Address& src, const Add
{
NS_LOG_LOGIC ("deferring TX, enqueueing new packet");
NS_ASSERT (m_queue);
if (m_queue->Enqueue (packet) == false)
if (m_queue->Enqueue (Create<QueueItem> (packet)) == false)
{
m_macTxDropTrace (packet);
sendOk = false;
@@ -434,8 +434,9 @@ AlohaNoackNetDevice::NotifyTransmissionEnd (Ptr<const Packet>)
NS_ASSERT (m_queue);
if (m_queue->IsEmpty () == false)
{
m_currentPkt = m_queue->Dequeue ();
NS_ASSERT (m_currentPkt);
Ptr<QueueItem> item = m_queue->Dequeue ();
NS_ASSERT (item);
m_currentPkt = item->GetPacket ();
NS_LOG_LOGIC ("scheduling transmission now");
Simulator::ScheduleNow (&AlohaNoackNetDevice::StartTransmission, this);
}