A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
txop.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2005 INRIA
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 *
17 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
18 */
19
20#include "txop.h"
21
23#include "mac-tx-middle.h"
25#include "wifi-mac-queue.h"
26#include "wifi-mac-trailer.h"
27#include "wifi-mac.h"
28
29#include "ns3/attribute-container.h"
30#include "ns3/log.h"
31#include "ns3/pointer.h"
32#include "ns3/random-variable-stream.h"
33#include "ns3/simulator.h"
34#include "ns3/socket.h"
35
36#undef NS_LOG_APPEND_CONTEXT
37#define NS_LOG_APPEND_CONTEXT \
38 if (m_mac) \
39 { \
40 std::clog << "[mac=" << m_mac->GetAddress() << "] "; \
41 }
42
43namespace ns3
44{
45
47
49
50TypeId
52{
53 static TypeId tid =
54 TypeId("ns3::Txop")
56 .SetGroupName("Wifi")
57 .AddConstructor<Txop>()
58 .AddAttribute("MinCw",
59 "The minimum value of the contention window (just for the first link, "
60 "in case of 11be multi-link devices).",
61 TypeId::ATTR_GET | TypeId::ATTR_SET, // do not set at construction time
62 UintegerValue(15),
64 (uint32_t(Txop::*)() const) & Txop::GetMinCw),
65 MakeUintegerChecker<uint32_t>())
66 .AddAttribute(
67 "MinCws",
68 "The minimum values of the contention window for all the links",
69 TypeId::ATTR_GET | TypeId::ATTR_SET, // do not set at construction time
71 MakeAttributeContainerAccessor<UintegerValue>(&Txop::SetMinCws, &Txop::GetMinCws),
72 MakeAttributeContainerChecker<UintegerValue>(MakeUintegerChecker<uint32_t>()))
73 .AddAttribute("MaxCw",
74 "The maximum value of the contention window (just for the first link, "
75 "in case of 11be multi-link devices).",
76 TypeId::ATTR_GET | TypeId::ATTR_SET, // do not set at construction time
77 UintegerValue(1023),
79 (uint32_t(Txop::*)() const) & Txop::GetMaxCw),
80 MakeUintegerChecker<uint32_t>())
81 .AddAttribute(
82 "MaxCws",
83 "The maximum values of the contention window for all the links",
84 TypeId::ATTR_GET | TypeId::ATTR_SET, // do not set at construction time
86 MakeAttributeContainerAccessor<UintegerValue>(&Txop::SetMaxCws, &Txop::GetMaxCws),
87 MakeAttributeContainerChecker<UintegerValue>(MakeUintegerChecker<uint32_t>()))
88 .AddAttribute(
89 "Aifsn",
90 "The AIFSN: the default value conforms to non-QOS (just for the first link, "
91 "in case of 11be multi-link devices).",
92 TypeId::ATTR_GET | TypeId::ATTR_SET, // do not set at construction time
94 MakeUintegerAccessor((void(Txop::*)(uint8_t)) & Txop::SetAifsn,
95 (uint8_t(Txop::*)() const) & Txop::GetAifsn),
96 MakeUintegerChecker<uint8_t>())
97 .AddAttribute(
98 "Aifsns",
99 "The values of AIFSN for all the links",
100 TypeId::ATTR_GET | TypeId::ATTR_SET, // do not set at construction time
102 MakeAttributeContainerAccessor<UintegerValue>(&Txop::SetAifsns, &Txop::GetAifsns),
103 MakeAttributeContainerChecker<UintegerValue>(MakeUintegerChecker<uint8_t>()))
104 .AddAttribute("TxopLimit",
105 "The TXOP limit: the default value conforms to non-QoS "
106 "(just for the first link, in case of 11be multi-link devices).",
107 TypeId::ATTR_GET | TypeId::ATTR_SET, // do not set at construction time
110 (Time(Txop::*)() const) & Txop::GetTxopLimit),
112 .AddAttribute("TxopLimits",
113 "The values of TXOP limit for all the links",
114 TypeId::ATTR_GET | TypeId::ATTR_SET, // do not set at construction time
116 MakeAttributeContainerAccessor<TimeValue>(&Txop::SetTxopLimits,
118 MakeAttributeContainerChecker<TimeValue>(MakeTimeChecker()))
119 .AddAttribute("Queue",
120 "The WifiMacQueue object",
121 PointerValue(),
123 MakePointerChecker<WifiMacQueue>())
124 .AddTraceSource("BackoffTrace",
125 "Trace source for backoff values",
127 "ns3::Txop::BackoffValueTracedCallback")
128 .AddTraceSource("CwTrace",
129 "Trace source for contention window values",
131 "ns3::Txop::CwValueTracedCallback");
132 return tid;
133}
134
137{
138}
139
141 : m_queue(queue)
142{
143 NS_LOG_FUNCTION(this);
144 m_rng = CreateObject<UniformRandomVariable>();
145}
146
148{
149 NS_LOG_FUNCTION(this);
150}
151
152void
154{
155 NS_LOG_FUNCTION(this);
156 m_queue = nullptr;
157 m_mac = nullptr;
158 m_rng = nullptr;
159 m_txMiddle = nullptr;
160 m_links.clear();
161}
162
163std::unique_ptr<Txop::LinkEntity>
165{
166 return std::make_unique<LinkEntity>();
167}
168
170Txop::GetLink(uint8_t linkId) const
171{
172 auto it = m_links.find(linkId);
173 NS_ASSERT(it != m_links.cend());
174 NS_ASSERT(it->second); // check that the pointer owns an object
175 return *it->second;
176}
177
178const std::map<uint8_t, std::unique_ptr<Txop::LinkEntity>>&
180{
181 return m_links;
182}
183
184void
185Txop::SwapLinks(std::map<uint8_t, uint8_t> links)
186{
187 NS_LOG_FUNCTION(this);
188
189 decltype(m_links) tmp;
190 tmp.swap(m_links); // move all links to temporary map
191 for (const auto& [from, to] : links)
192 {
193 auto nh = tmp.extract(from);
194 nh.key() = to;
195 m_links.insert(std::move(nh));
196 }
197 // move links remaining in tmp to m_links
198 m_links.merge(tmp);
199}
200
201void
203{
204 NS_LOG_FUNCTION(this);
205 m_txMiddle = txMiddle;
206}
207
208void
210{
211 NS_LOG_FUNCTION(this << mac);
212 m_mac = mac;
213 for (const auto linkId : m_mac->GetLinkIds())
214 {
215 m_links.emplace(linkId, CreateLinkEntity());
216 }
217}
218
219void
221{
222 NS_LOG_FUNCTION(this << &callback);
223 m_droppedMpduCallback = callback;
224 m_queue->TraceConnectWithoutContext("DropBeforeEnqueue",
226 m_queue->TraceConnectWithoutContext("Expired",
228}
229
232{
233 NS_LOG_FUNCTION(this);
234 return m_queue;
235}
236
237void
239{
240 SetMinCw(minCw, 0);
241}
242
243void
244Txop::SetMinCws(std::vector<uint32_t> minCws)
245{
246 NS_ABORT_IF(minCws.size() != m_links.size());
247 std::size_t i = 0;
248 for (const auto& [id, link] : m_links)
249 {
250 SetMinCw(minCws[i++], id);
251 }
252}
253
254void
255Txop::SetMinCw(uint32_t minCw, uint8_t linkId)
256{
257 NS_LOG_FUNCTION(this << minCw << +linkId);
258 auto& link = GetLink(linkId);
259 bool changed = (link.cwMin != minCw);
260 link.cwMin = minCw;
261 if (changed)
262 {
263 ResetCw(linkId);
264 }
265}
266
267void
269{
270 SetMaxCw(maxCw, 0);
271}
272
273void
274Txop::SetMaxCws(std::vector<uint32_t> maxCws)
275{
276 NS_ABORT_IF(maxCws.size() != m_links.size());
277 std::size_t i = 0;
278 for (const auto& [id, link] : m_links)
279 {
280 SetMaxCw(maxCws[i++], id);
281 }
282}
283
284void
285Txop::SetMaxCw(uint32_t maxCw, uint8_t linkId)
286{
287 NS_LOG_FUNCTION(this << maxCw << +linkId);
288 auto& link = GetLink(linkId);
289 bool changed = (link.cwMax != maxCw);
290 link.cwMax = maxCw;
291 if (changed)
292 {
293 ResetCw(linkId);
294 }
295}
296
298Txop::GetCw(uint8_t linkId) const
299{
300 return GetLink(linkId).cw;
301}
302
303void
304Txop::ResetCw(uint8_t linkId)
305{
306 NS_LOG_FUNCTION(this);
307 auto& link = GetLink(linkId);
308 link.cw = GetMinCw(linkId);
309 m_cwTrace(link.cw, linkId);
310}
311
312void
313Txop::UpdateFailedCw(uint8_t linkId)
314{
315 NS_LOG_FUNCTION(this);
316 auto& link = GetLink(linkId);
317 // see 802.11-2012, section 9.19.2.5
318 link.cw = std::min(2 * (link.cw + 1) - 1, GetMaxCw(linkId));
319 // if the MU EDCA timer is running, CW cannot be less than MU CW min
320 link.cw = std::max(link.cw, GetMinCw(linkId));
321 m_cwTrace(link.cw, linkId);
322}
323
325Txop::GetBackoffSlots(uint8_t linkId) const
326{
327 return GetLink(linkId).backoffSlots;
328}
329
330Time
331Txop::GetBackoffStart(uint8_t linkId) const
332{
333 return GetLink(linkId).backoffStart;
334}
335
336void
337Txop::UpdateBackoffSlotsNow(uint32_t nSlots, Time backoffUpdateBound, uint8_t linkId)
338{
339 NS_LOG_FUNCTION(this << nSlots << backoffUpdateBound << +linkId);
340 auto& link = GetLink(linkId);
341
342 link.backoffSlots -= nSlots;
343 link.backoffStart = backoffUpdateBound;
344 NS_LOG_DEBUG("update slots=" << nSlots << " slots, backoff=" << link.backoffSlots);
345}
346
347void
348Txop::StartBackoffNow(uint32_t nSlots, uint8_t linkId)
349{
350 NS_LOG_FUNCTION(this << nSlots << +linkId);
351 auto& link = GetLink(linkId);
352
353 if (link.backoffSlots != 0)
354 {
355 NS_LOG_DEBUG("reset backoff from " << link.backoffSlots << " to " << nSlots << " slots");
356 }
357 else
358 {
359 NS_LOG_DEBUG("start backoff=" << nSlots << " slots");
360 }
361 link.backoffSlots = nSlots;
362 link.backoffStart = Simulator::Now();
363}
364
365void
366Txop::SetAifsn(uint8_t aifsn)
367{
368 SetAifsn(aifsn, 0);
369}
370
371void
372Txop::SetAifsns(std::vector<uint8_t> aifsns)
373{
374 NS_ABORT_IF(aifsns.size() != m_links.size());
375 std::size_t i = 0;
376 for (const auto& [id, link] : m_links)
377 {
378 SetAifsn(aifsns[i++], id);
379 }
380}
381
382void
383Txop::SetAifsn(uint8_t aifsn, uint8_t linkId)
384{
385 NS_LOG_FUNCTION(this << +aifsn << +linkId);
386 GetLink(linkId).aifsn = aifsn;
387}
388
389void
391{
392 SetTxopLimit(txopLimit, 0);
393}
394
395void
396Txop::SetTxopLimits(const std::vector<Time>& txopLimits)
397{
398 NS_ABORT_MSG_IF(txopLimits.size() != m_links.size(),
399 "The size of the given vector (" << txopLimits.size()
400 << ") does not match the number of links ("
401 << m_links.size() << ")");
402 std::size_t i = 0;
403 for (const auto& [id, link] : m_links)
404 {
405 SetTxopLimit(txopLimits[i++], id);
406 }
407}
408
409void
410Txop::SetTxopLimit(Time txopLimit, uint8_t linkId)
411{
412 NS_LOG_FUNCTION(this << txopLimit << +linkId);
413 NS_ASSERT_MSG((txopLimit.GetMicroSeconds() % 32 == 0),
414 "The TXOP limit must be expressed in multiple of 32 microseconds!");
415 GetLink(linkId).txopLimit = txopLimit;
416}
417
420{
421 return GetMinCw(0);
422}
423
424std::vector<uint32_t>
426{
427 std::vector<uint32_t> ret;
428 ret.reserve(m_links.size());
429 for (const auto& [id, link] : m_links)
430 {
431 ret.push_back(link->cwMin);
432 }
433 return ret;
434}
435
437Txop::GetMinCw(uint8_t linkId) const
438{
439 return GetLink(linkId).cwMin;
440}
441
444{
445 return GetMaxCw(0);
446}
447
448std::vector<uint32_t>
450{
451 std::vector<uint32_t> ret;
452 ret.reserve(m_links.size());
453 for (const auto& [id, link] : m_links)
454 {
455 ret.push_back(link->cwMax);
456 }
457 return ret;
458}
459
461Txop::GetMaxCw(uint8_t linkId) const
462{
463 return GetLink(linkId).cwMax;
464}
465
466uint8_t
468{
469 return GetAifsn(0);
470}
471
472std::vector<uint8_t>
474{
475 std::vector<uint8_t> ret;
476 ret.reserve(m_links.size());
477 for (const auto& [id, link] : m_links)
478 {
479 ret.push_back(link->aifsn);
480 }
481 return ret;
482}
483
484uint8_t
485Txop::GetAifsn(uint8_t linkId) const
486{
487 return GetLink(linkId).aifsn;
488}
489
490Time
492{
493 return GetTxopLimit(0);
494}
495
496std::vector<Time>
498{
499 std::vector<Time> ret;
500 ret.reserve(m_links.size());
501 for (const auto& [id, link] : m_links)
502 {
503 ret.push_back(link->txopLimit);
504 }
505 return ret;
506}
507
508Time
509Txop::GetTxopLimit(uint8_t linkId) const
510{
511 return GetLink(linkId).txopLimit;
512}
513
514bool
516{
517 m_queue->WipeAllExpiredMpdus();
518 bool ret = static_cast<bool>(m_queue->Peek(linkId));
519 NS_LOG_FUNCTION(this << +linkId << ret);
520 return ret;
521}
522
523void
525{
526 NS_LOG_FUNCTION(this << packet << &hdr);
527 // remove the priority tag attached, if any
528 SocketPriorityTag priorityTag;
529 packet->RemovePacketTag(priorityTag);
530 Queue(Create<WifiMpdu>(packet, hdr));
531}
532
533void
535{
536 NS_LOG_FUNCTION(this << *mpdu);
537 const auto linkIds = m_mac->GetMacQueueScheduler()->GetLinkIds(m_queue->GetAc(), mpdu);
538 for (const auto linkId : linkIds)
539 {
541 {
542 GenerateBackoff(linkId);
543 }
544 }
545 m_queue->Enqueue(mpdu);
546 for (const auto linkId : linkIds)
547 {
548 StartAccessIfNeeded(linkId);
549 }
550}
551
552int64_t
553Txop::AssignStreams(int64_t stream)
554{
555 NS_LOG_FUNCTION(this << stream);
556 m_rng->SetStream(stream);
557 return 1;
558}
559
560void
562{
563 NS_LOG_FUNCTION(this << +linkId);
564 if (HasFramesToTransmit(linkId) && GetLink(linkId).access == NOT_REQUESTED)
565 {
567 }
568}
569
570void
572{
573 NS_LOG_FUNCTION(this);
574 for (const auto& [id, link] : m_links)
575 {
576 ResetCw(id);
577 GenerateBackoff(id);
578 }
579}
580
582Txop::GetAccessStatus(uint8_t linkId) const
583{
584 return GetLink(linkId).access;
585}
586
587void
589{
590 NS_LOG_FUNCTION(this << +linkId);
591 GetLink(linkId).access = REQUESTED;
592}
593
594void
595Txop::NotifyChannelAccessed(uint8_t linkId, Time txopDuration)
596{
597 NS_LOG_FUNCTION(this << +linkId << txopDuration);
598 GetLink(linkId).access = GRANTED;
599}
600
601void
603{
604 NS_LOG_FUNCTION(this << +linkId);
605 GetLink(linkId).access = NOT_REQUESTED;
606 GenerateBackoff(linkId);
607 if (HasFramesToTransmit(linkId))
608 {
610 }
611}
612
613void
614Txop::RequestAccess(uint8_t linkId)
615{
616 NS_LOG_FUNCTION(this << +linkId);
617 if (GetLink(linkId).access == NOT_REQUESTED)
618 {
620 }
621}
622
623void
625{
626 NS_LOG_FUNCTION(this << +linkId);
627 uint32_t backoff = m_rng->GetInteger(0, GetCw(linkId));
628 m_backoffTrace(backoff, linkId);
629 StartBackoffNow(backoff, linkId);
630}
631
632void
633Txop::NotifySleep(uint8_t linkId)
634{
635 NS_LOG_FUNCTION(this << +linkId);
636}
637
638void
640{
641 NS_LOG_FUNCTION(this);
642 m_queue->Flush();
643}
644
645void
646Txop::NotifyWakeUp(uint8_t linkId)
647{
648 NS_LOG_FUNCTION(this << +linkId);
649 StartAccessIfNeeded(linkId);
650}
651
652void
654{
655 NS_LOG_FUNCTION(this);
656 for (const auto& [id, link] : m_links)
657 {
659 }
660}
661
662bool
664{
665 return false;
666}
667
668} // namespace ns3
A container for one type of attribute.
auto Bind(BoundArgs &&... bargs)
Bind a variable number of arguments.
Definition: callback.h:557
void RequestAccess(Ptr< Txop > txop)
bool NeedBackoffUponAccess(Ptr< Txop > txop)
Determine if a new backoff needs to be generated when a packet is queued for transmission.
A base class which provides memory management and object aggregation.
Definition: object.h:89
Hold objects of type Ptr<T>.
Definition: pointer.h:37
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:78
Template class for packet Queues.
Definition: queue.h:268
void SetStream(int64_t stream)
Specifies the stream number for the RngStream.
static Time Now()
Return the current simulation virtual time.
Definition: simulator.cc:199
static EventId ScheduleNow(FUNC f, Ts &&... args)
Schedule an event to expire Now.
Definition: simulator.h:592
indicates whether the socket has a priority set.
Definition: socket.h:1316
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
int64_t GetMicroSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:412
AttributeValue implementation for Time.
Definition: nstime.h:1412
Handle packet fragmentation and retransmissions for data and management frames.
Definition: txop.h:72
virtual void StartAccessIfNeeded(uint8_t linkId)
Request access from Txop on the given link if needed.
Definition: txop.cc:561
Ptr< WifiMac > m_mac
the wifi MAC
Definition: txop.h:526
Time GetTxopLimit() const
Return the TXOP limit.
Definition: txop.cc:491
virtual std::unique_ptr< LinkEntity > CreateLinkEntity() const
Create a LinkEntity object.
Definition: txop.cc:164
int64_t AssignStreams(int64_t stream)
Assign a fixed random variable stream number to the random variables used by this model.
Definition: txop.cc:553
virtual ChannelAccessStatus GetAccessStatus(uint8_t linkId) const
Definition: txop.cc:582
Ptr< WifiMacQueue > m_queue
the wifi MAC queue
Definition: txop.h:524
virtual bool HasFramesToTransmit(uint8_t linkId)
Check if the Txop has frames to transmit over the given link.
Definition: txop.cc:515
virtual void NotifyOff()
When off operation occurs, the queue gets cleaned up.
Definition: txop.cc:639
Ptr< UniformRandomVariable > m_rng
the random stream
Definition: txop.h:527
CwValueTracedCallback m_cwTrace
CW trace value.
Definition: txop.h:535
void DoDispose() override
Destructor implementation.
Definition: txop.cc:153
void SetMaxCw(uint32_t maxCw)
Set the maximum contention window size.
Definition: txop.cc:268
uint32_t GetMinCw() const
Return the minimum contention window size.
Definition: txop.cc:419
ChannelAccessStatus
Enumeration for channel access status.
Definition: txop.h:100
@ GRANTED
Definition: txop.h:103
@ NOT_REQUESTED
Definition: txop.h:101
@ REQUESTED
Definition: txop.h:102
virtual void NotifyOn()
When on operation occurs, channel access will be started.
Definition: txop.cc:653
void UpdateFailedCw(uint8_t linkId)
Update the value of the CW variable for the given link to take into account a transmission failure.
Definition: txop.cc:313
Ptr< WifiMacQueue > GetWifiMacQueue() const
Return the packet queue associated with this Txop.
Definition: txop.cc:231
virtual void SetWifiMac(const Ptr< WifiMac > mac)
Set the wifi MAC this Txop is associated to.
Definition: txop.cc:209
virtual void NotifyWakeUp(uint8_t linkId)
When wake up operation occurs on a link, channel access on that link will be restarted.
Definition: txop.cc:646
virtual void NotifyChannelReleased(uint8_t linkId)
Called by the FrameExchangeManager to notify the completion of the transmissions.
Definition: txop.cc:602
std::vector< uint32_t > GetMaxCws() const
Return the maximum contention window size for each link.
Definition: txop.cc:449
void SetTxopLimit(Time txopLimit)
Set the TXOP limit.
Definition: txop.cc:390
void ResetCw(uint8_t linkId)
Update the value of the CW variable for the given link to take into account a transmission success or...
Definition: txop.cc:304
Txop()
Definition: txop.cc:135
LinkEntity & GetLink(uint8_t linkId) const
Get a reference to the link associated with the given ID.
Definition: txop.cc:170
virtual bool IsQosTxop() const
Check for QoS TXOP.
Definition: txop.cc:663
std::vector< uint32_t > GetMinCws() const
Return the minimum contention window size for each link.
Definition: txop.cc:425
std::vector< uint8_t > GetAifsns() const
Return the number of slots that make up an AIFS for each link.
Definition: txop.cc:473
void UpdateBackoffSlotsNow(uint32_t nSlots, Time backoffUpdateBound, uint8_t linkId)
Update backoff slots for the given link that nSlots has passed.
Definition: txop.cc:337
Time GetBackoffStart(uint8_t linkId) const
Return the time when the backoff procedure started on the given link.
Definition: txop.cc:331
void SetMaxCws(std::vector< uint32_t > maxCws)
Set the maximum contention window size for each link.
Definition: txop.cc:274
void SetTxopLimits(const std::vector< Time > &txopLimits)
Set the TXOP limit for each link.
Definition: txop.cc:396
DroppedMpdu m_droppedMpduCallback
the dropped MPDU callback
Definition: txop.h:523
void SwapLinks(std::map< uint8_t, uint8_t > links)
Swap the links based on the information included in the given map.
Definition: txop.cc:185
void SetTxMiddle(const Ptr< MacTxMiddle > txMiddle)
Set MacTxMiddle this Txop is associated to.
Definition: txop.cc:202
std::vector< Time > GetTxopLimits() const
Return the TXOP limit for each link.
Definition: txop.cc:497
const std::map< uint8_t, std::unique_ptr< LinkEntity > > & GetLinks() const
Definition: txop.cc:179
static TypeId GetTypeId()
Get the type ID.
Definition: txop.cc:51
void SetAifsn(uint8_t aifsn)
Set the number of slots that make up an AIFS.
Definition: txop.cc:366
uint32_t GetCw(uint8_t linkId) const
Get the current value of the CW variable for the given link.
Definition: txop.cc:298
void SetMinCws(std::vector< uint32_t > minCws)
Set the minimum contention window size for each link.
Definition: txop.cc:244
virtual void SetDroppedMpduCallback(DroppedMpdu callback)
Definition: txop.cc:220
virtual void GenerateBackoff(uint8_t linkId)
Generate a new backoff for the given link now.
Definition: txop.cc:624
BackoffValueTracedCallback m_backoffTrace
backoff trace value
Definition: txop.h:534
virtual void NotifyAccessRequested(uint8_t linkId)
Notify that access request has been received for the given link.
Definition: txop.cc:588
void SetAifsns(std::vector< uint8_t > aifsns)
Set the number of slots that make up an AIFS for each link.
Definition: txop.cc:372
Ptr< MacTxMiddle > m_txMiddle
the MacTxMiddle
Definition: txop.h:525
~Txop() override
Definition: txop.cc:147
void StartBackoffNow(uint32_t nSlots, uint8_t linkId)
Definition: txop.cc:348
virtual void NotifyChannelAccessed(uint8_t linkId, Time txopDuration=Seconds(0))
Called by the FrameExchangeManager to notify that channel access has been granted on the given link f...
Definition: txop.cc:595
std::map< uint8_t, std::unique_ptr< LinkEntity > > m_links
ID-indexed map of LinkEntity objects.
Definition: txop.h:546
void RequestAccess(uint8_t linkId)
Request access to the ChannelAccessManager associated with the given link.
Definition: txop.cc:614
void SetMinCw(uint32_t minCw)
Set the minimum contention window size.
Definition: txop.cc:238
uint8_t GetAifsn() const
Return the number of slots that make up an AIFS.
Definition: txop.cc:467
uint32_t GetBackoffSlots(uint8_t linkId) const
Return the current number of backoff slots on the given link.
Definition: txop.cc:325
virtual void Queue(Ptr< Packet > packet, const WifiMacHeader &hdr)
Definition: txop.cc:524
virtual void NotifySleep(uint8_t linkId)
Notify that the given link switched to sleep mode.
Definition: txop.cc:633
uint32_t GetMaxCw() const
Return the maximum contention window size.
Definition: txop.cc:443
void DoInitialize() override
Initialize() implementation.
Definition: txop.cc:571
a unique identifier for an interface.
Definition: type-id.h:59
@ ATTR_GET
The attribute can be read.
Definition: type-id.h:64
@ ATTR_SET
The attribute can be written.
Definition: type-id.h:65
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:930
Hold an unsigned integer type.
Definition: uinteger.h:45
uint32_t GetInteger(uint32_t min, uint32_t max)
Get the next random value drawn from the distribution.
Implements the IEEE 802.11 MAC header.
Ptr< WifiMacQueueScheduler > GetMacQueueScheduler() const
Get the wifi MAC queue scheduler.
Definition: wifi-mac.cc:576
const std::set< uint8_t > & GetLinkIds() const
Definition: wifi-mac.cc:941
Ptr< ChannelAccessManager > GetChannelAccessManager(uint8_t linkId=SINGLE_LINK_OP_ID) const
Get the Channel Access Manager associated with the given link.
Definition: wifi-mac.cc:872
This queue implements the timeout procedure described in (Section 9.19.2.6 "Retransmit procedures" pa...
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:66
#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:86
Ptr< const AttributeAccessor > MakePointerAccessor(T1 a1)
Definition: pointer.h:227
Ptr< const AttributeChecker > MakeTimeChecker()
Helper to make an unbounded Time checker.
Definition: nstime.h:1433
Ptr< const AttributeAccessor > MakeTimeAccessor(T1 a1)
Definition: nstime.h:1413
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Definition: uinteger.h:46
#define NS_ABORT_MSG_IF(cond, msg)
Abnormal program termination if a condition is true, with a message.
Definition: abort.h:108
#define NS_ABORT_IF(cond)
Abnormal program termination if a condition is true.
Definition: abort.h:76
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:268
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
Ptr< T > CreateObject(Args &&... args)
Create an object by type, with varying number of constructor parameters.
Definition: object.h:579
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:46
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1337
Ptr< const TraceSourceAccessor > MakeTraceSourceAccessor(T a)
Create a TraceSourceAccessor which will control access to the underlying trace source.
@ WIFI_MAC_DROP_FAILED_ENQUEUE
Definition: wifi-mac.h:78
@ WIFI_MAC_DROP_EXPIRED_LIFETIME
Definition: wifi-mac.h:79
@ AC_BE_NQOS
Non-QoS.
Definition: qos-utils.h:82
Every class exported by the ns3 library is enclosed in the ns3 namespace.