A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
wifi-mac-queue-container.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2021 Universita' degli Studi di Napoli Federico II
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 * Author: Stefano Avallone <stavallo@unina.it>
7 */
8
10
11#include "ctrl-headers.h"
12#include "wifi-mpdu.h"
13
14#include "ns3/mac48-address.h"
15#include "ns3/simulator.h"
16
17#include <vector>
18
19namespace ns3
20{
21
22void
24{
25 m_queues.clear();
26 m_expiredQueue.clear();
27 m_nBytesPerQueue.clear();
28}
29
32{
33 WifiContainerQueueId queueId = GetQueueId(item);
34
35 NS_ABORT_MSG_UNLESS(pos == m_queues[queueId].cend() || GetQueueId(pos->mpdu) == queueId,
36 "pos iterator does not point to the correct container queue");
37 NS_ABORT_MSG_IF(!item->IsOriginal(), "Only the original copy of an MPDU can be inserted");
38
39 auto [it, ret] = m_nBytesPerQueue.insert({queueId, 0});
40 it->second += item->GetSize();
41
42 return m_queues[queueId].emplace(pos, item);
43}
44
47{
48 if (pos->expired)
49 {
50 return m_expiredQueue.erase(pos);
51 }
52
53 WifiContainerQueueId queueId = GetQueueId(pos->mpdu);
54 auto it = m_nBytesPerQueue.find(queueId);
55 NS_ASSERT(it != m_nBytesPerQueue.end());
56 NS_ASSERT(it->second >= pos->mpdu->GetSize());
57 it->second -= pos->mpdu->GetSize();
58
59 return m_queues[queueId].erase(pos);
60}
61
64{
65 return it->mpdu;
66}
67
70{
71 const WifiMacHeader& hdr = mpdu->GetHeader();
72
73 auto addrType = hdr.GetAddr1().IsGroup() ? WIFI_BROADCAST : WIFI_UNICAST;
74 auto address = hdr.GetAddr1().IsGroup() ? hdr.GetAddr2() : hdr.GetAddr1();
75
76 if (hdr.IsCtl())
77 {
78 return {WIFI_CTL_QUEUE, addrType, address, std::nullopt};
79 }
80 if (hdr.IsMgt())
81 {
82 return {WIFI_MGT_QUEUE, addrType, address, std::nullopt};
83 }
84 if (hdr.IsQosData())
85 {
86 return {WIFI_QOSDATA_QUEUE, addrType, address, hdr.GetQosTid()};
87 }
88 return {WIFI_DATA_QUEUE, addrType, address, std::nullopt};
89}
90
93{
94 return m_queues[queueId];
95}
96
99{
100 if (auto it = m_queues.find(queueId); it == m_queues.end() || it->second.empty())
101 {
102 return 0;
103 }
104 return m_nBytesPerQueue.at(queueId);
105}
106
107std::pair<WifiMacQueueContainer::iterator, WifiMacQueueContainer::iterator>
112
113std::pair<WifiMacQueueContainer::iterator, WifiMacQueueContainer::iterator>
115{
116 std::optional<std::pair<WifiMacQueueContainer::iterator, WifiMacQueueContainer::iterator>> ret;
117 auto firstExpiredIt = queue.begin();
118 auto lastExpiredIt = firstExpiredIt;
119 Time now = Simulator::Now();
120
121 do
122 {
123 // advance firstExpiredIt and lastExpiredIt to skip all inflight MPDUs
124 for (firstExpiredIt = lastExpiredIt;
125 firstExpiredIt != queue.end() && !firstExpiredIt->inflights.empty();
126 ++firstExpiredIt, ++lastExpiredIt)
127 {
128 }
129
130 if (!ret)
131 {
132 // we get here in the first iteration only
133 ret = std::make_pair(firstExpiredIt, lastExpiredIt);
134 }
135
136 // advance lastExpiredIt as we encounter MPDUs with expired lifetime that are not inflight
137 while (lastExpiredIt != queue.end() && lastExpiredIt->expiryTime <= now &&
138 lastExpiredIt->inflights.empty())
139 {
140 lastExpiredIt->expired = true;
141 // this MPDU is no longer queued
142 lastExpiredIt->ac = AC_UNDEF;
143 lastExpiredIt->deleter(lastExpiredIt->mpdu);
144
145 WifiContainerQueueId queueId = GetQueueId(lastExpiredIt->mpdu);
146 auto it = m_nBytesPerQueue.find(queueId);
147 NS_ASSERT(it != m_nBytesPerQueue.end());
148 NS_ASSERT(it->second >= lastExpiredIt->mpdu->GetSize());
149 it->second -= lastExpiredIt->mpdu->GetSize();
150
151 ++lastExpiredIt;
152 }
153
154 if (lastExpiredIt != firstExpiredIt)
155 {
156 // transfer non-inflight MPDUs with expired lifetime to the tail of m_expiredQueue
157 m_expiredQueue.splice(m_expiredQueue.end(), queue, firstExpiredIt, lastExpiredIt);
158 ret->second = m_expiredQueue.end();
159 }
160
161 } while (lastExpiredIt != firstExpiredIt);
162
163 return *ret;
164}
165
166std::pair<WifiMacQueueContainer::iterator, WifiMacQueueContainer::iterator>
168{
169 std::optional<WifiMacQueueContainer::iterator> firstExpiredIt;
170
171 for (auto& queue : m_queues)
172 {
173 auto [firstIt, lastIt] = DoExtractExpiredMpdus(queue.second);
174
175 if (firstIt != lastIt && !firstExpiredIt)
176 {
177 // this is the first queue with MPDUs with expired lifetime
178 firstExpiredIt = firstIt;
179 }
180 }
181 return std::make_pair(firstExpiredIt ? *firstExpiredIt : m_expiredQueue.end(),
182 m_expiredQueue.end());
183}
184
185std::pair<WifiMacQueueContainer::iterator, WifiMacQueueContainer::iterator>
187{
188 return {m_expiredQueue.begin(), m_expiredQueue.end()};
189}
190
191} // namespace ns3
192
193/****************************************************
194 * Global Functions (outside namespace ns3)
195 ***************************************************/
196
197std::size_t
198std::hash<ns3::WifiContainerQueueId>::operator()(ns3::WifiContainerQueueId queueId) const
199{
200 auto [type, addrType, address, tid] = queueId;
201 const std::size_t size = tid.has_value() ? 8 : 7;
202
203 std::vector<uint8_t> buffer(size);
204 buffer[0] = type;
205 address.CopyTo(&buffer[1]);
206 if (tid.has_value())
207 {
208 buffer[7] = *tid;
209 }
210
211 std::string s(buffer.begin(), buffer.end());
212 return std::hash<std::string>{}(s);
213}
bool IsGroup() const
Smart pointer class similar to boost::intrusive_ptr.
static Time Now()
Return the current simulation virtual time.
Definition simulator.cc:197
Simulation virtual time values and global simulation resolution.
Definition nstime.h:94
Implements the IEEE 802.11 MAC header.
uint8_t GetQosTid() const
Return the Traffic ID of a QoS header.
Mac48Address GetAddr1() const
Return the address in the Address 1 field.
bool IsMgt() const
Return true if the Type is Management.
bool IsCtl() const
Return true if the Type is Control.
Mac48Address GetAddr2() const
Return the address in the Address 2 field.
bool IsQosData() const
Return true if the Type is DATA and Subtype is one of the possible values for QoS Data.
const ContainerQueue & GetQueue(const WifiContainerQueueId &queueId) const
Get a const reference to the container queue identified by the given QueueId.
void clear()
Erase all elements from the container.
static WifiContainerQueueId GetQueueId(Ptr< const WifiMpdu > mpdu)
Return the QueueId identifying the container queue in which the given MPDU is (or is to be) enqueued.
ContainerQueue::iterator iterator
iterator over elements in a container queue
std::unordered_map< WifiContainerQueueId, uint32_t > m_nBytesPerQueue
size in bytes of the container queues
uint32_t GetNBytes(const WifiContainerQueueId &queueId) const
Get the total size of the MPDUs stored in the queue identified by the given QueueId.
Ptr< WifiMpdu > GetItem(const const_iterator it) const
Return the WifiMpdu included in the element pointed to by the given iterator.
std::pair< iterator, iterator > ExtractAllExpiredMpdus() const
Transfer non-inflight MPDUs with expired lifetime in all the container queues to the container queue ...
iterator insert(const_iterator pos, Ptr< WifiMpdu > item)
Insert the given item at the specified location in the container.
std::unordered_map< WifiContainerQueueId, ContainerQueue > m_queues
the container queues
std::list< WifiMacQueueElem > ContainerQueue
Type of a queue held by the container.
iterator erase(const_iterator pos)
Erase the specified elements from the container.
std::pair< iterator, iterator > GetAllExpiredMpdus() const
Get the range [first, last) of iterators pointing to all the MPDUs queued in the container queue stor...
ContainerQueue::const_iterator const_iterator
const iterator over elements in a container queue
ContainerQueue m_expiredQueue
queue storing MPDUs with expired lifetime
std::pair< iterator, iterator > ExtractExpiredMpdus(const WifiContainerQueueId &queueId) const
Transfer non-inflight MPDUs with expired lifetime in the container queue identified by the given Queu...
std::pair< iterator, iterator > DoExtractExpiredMpdus(ContainerQueue &queue) const
Transfer non-inflight MPDUs with expired lifetime in the given container queue to the container queue...
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition assert.h:55
#define NS_ABORT_MSG_UNLESS(cond, msg)
Abnormal program termination if a condition is false, with a message.
Definition abort.h:133
#define NS_ABORT_MSG_IF(cond, msg)
Abnormal program termination if a condition is true, with a message.
Definition abort.h:97
@ AC_UNDEF
Total number of ACs.
Definition qos-utils.h:76
Every class exported by the ns3 library is enclosed in the ns3 namespace.
std:: tuple< WifiContainerQueueType, WifiReceiverAddressType, Mac48Address, std::optional< uint8_t > > WifiContainerQueueId
Tuple (queue type, receiver address type, Address, TID) identifying a container queue.