A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
tcp-rate-ops-test.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2018 NITK Surathkal
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 * Authors: Vivek Jain <jain.vivek.anand@gmail.com>
7 * Viyom Mittal <viyommittal@gmail.com>
8 * Mohit P. Tahiliani <tahiliani@nitk.edu.in>
9 */
10
11#include "tcp-error-model.h"
12#include "tcp-general-test.h"
13
14#include "ns3/config.h"
15#include "ns3/log.h"
16#include "ns3/tcp-rate-ops.h"
17#include "ns3/tcp-tx-buffer.h"
18#include "ns3/tcp-tx-item.h"
19#include "ns3/test.h"
20
21using namespace ns3;
22
23NS_LOG_COMPONENT_DEFINE("TcpRateOpsTestSuite");
24
26
27/**
28 * \ingroup internet-test
29 * \ingroup tests
30 *
31 * \brief The TcpRateLinux Basic Test
32 */
34{
35 public:
36 /**
37 * Constructor
38 * \param cWnd Congestion window size
39 * \param tailSeq Tail sequence number
40 * \param nextTx Tx next sequence number
41 * \param testCase test case type
42 * \param testName test name
43 */
45 SequenceNumber32 tailSeq,
46 SequenceNumber32 nextTx,
47 uint32_t testCase,
48 std::string testName);
49
50 private:
51 void DoRun() override;
52
53 /**
54 * Send an application packet
55 * \param skb the data to send
56 */
57 void SendSkb(TcpTxItem* skb);
58 /**
59 * Deliver an application packet
60 * \param skb the data to deliver
61 */
62 void SkbDelivered(TcpTxItem* skb);
63
64 TcpRateLinux m_rateOps; //!< Rate information for TCP
65 uint32_t m_cWnd; //!< Congestion window size
66 uint32_t m_inFlight; //!< Number of packets in-flight
67 uint32_t m_segmentSize; //!< Segment size
68 uint32_t m_delivered; //!< Number of segments delivered
69 Time m_deliveredTime; //!< Last time of a delivery
70 SequenceNumber32 m_tailSeq; //!< Tail sequence number
71 SequenceNumber32 m_nextTx; //!< Tx next sequence number
72 uint32_t m_testCase; //!< Test case type
73 std::vector<TcpTxItem*> m_skbs; //!< Application packets
74};
75
77 SequenceNumber32 tailSeq,
78 SequenceNumber32 nextTx,
79 uint32_t testCase,
80 std::string testName)
81 : TestCase(testName),
82 m_cWnd(cWnd),
83 m_inFlight(0),
84 m_segmentSize(1),
85 m_delivered(0),
86 m_deliveredTime(Seconds(0)),
87 m_tailSeq(tailSeq),
88 m_nextTx(nextTx),
89 m_testCase(testCase)
90{
91}
92
93void
95{
96 for (uint8_t i = 0; i < 100; ++i)
97 {
98 m_skbs.push_back(new TcpTxItem());
101 this,
102 m_skbs[i]);
103 }
104
105 for (uint8_t i = 0; i < 100; ++i)
106 {
107 Simulator::Schedule(Time(Seconds((i + 1) * 0.1)),
109 this,
110 m_skbs[i]);
111 }
112
115
116 for (uint8_t i = 0; i < 100; ++i)
117 {
118 delete m_skbs[i];
119 }
120}
121
122void
124{
125 bool isStartOfTransmission = m_inFlight == 0;
127 m_rateOps.SkbSent(skb, isStartOfTransmission);
128 m_inFlight += skb->GetSeqSize();
129
132 "SKB should have delivered equal to current value of total delivered");
133
134 if (isStartOfTransmission)
135 {
138 "SKB should have updated the delivered time to current value");
139 }
140 else
141 {
144 "SKB should have updated the delivered time to current value");
145 }
146}
147
148void
150{
152 m_inFlight -= skb->GetSeqSize();
153 m_delivered += skb->GetSeqSize();
155
157 Time::Max(),
158 "SKB should have delivered time as Time::Max ()");
159
160 if (m_testCase == 1)
161 {
163 false,
164 "Socket should not be applimited");
165 }
166 else if (m_testCase == 2)
167 {
169 true,
170 "Socket should be applimited");
171 }
172}
173
174/**
175 * \ingroup internet-test
176 *
177 * \brief Behaves as NewReno except HasCongControl returns true
178 */
180{
181 public:
182 /**
183 * \brief Get the type ID.
184 * \return the object TypeId
185 */
186 static TypeId GetTypeId();
187
189 {
190 }
191
192 bool HasCongControl() const override
193 {
194 return true;
195 }
196};
197
198TypeId
200{
201 static TypeId tid = TypeId("ns3::MimicCongControl")
203 .AddConstructor<MimicCongControl>()
204 .SetGroupName("Internet");
205 return tid;
206}
207
208/**
209 * \ingroup internet-test
210 * \ingroup tests
211 *
212 * \brief The TcpRateLinux Test uses sender-receiver model to test its functionality.
213 * This test case uses the bytes inflight trace to check whether rate sample
214 * correctly sets the value of m_deliveredTime and m_firstSentTime. This is
215 * done using rate trace. Further, Using Rx trace, m_isDupAck is maintained to
216 * track duplicate acknowledgments. This, in turn, is used to see whether rate
217 * sample is updated properly (in case of SACK) or not (in case of non SACK).
218 */
220{
221 public:
222 /**
223 * \brief Constructor.
224 * \param desc Description.
225 * \param sackEnabled To use SACK or not
226 * \param toDrop Packets to drop.
227 */
228 TcpRateLinuxWithSocketsTest(const std::string& desc,
229 bool sackEnabled,
230 std::vector<uint32_t>& toDrop);
231
232 protected:
233 /**
234 * \brief Create and install the socket to install on the sender
235 * \param node sender node pointer
236 * \return the socket to be installed in the sender
237 */
239
240 /**
241 * \brief Create a receiver error model.
242 * \returns The receiver error model.
243 */
245
246 /**
247 * \brief Receive a packet.
248 * \param p The packet.
249 * \param h The TCP header.
250 * \param who Who the socket belongs to (sender or receiver).
251 */
252 void Rx(const Ptr<const Packet> p, const TcpHeader& h, SocketWho who) override;
253
254 /**
255 * \brief Track the bytes in flight.
256 * \param oldValue previous value.
257 * \param newValue actual value.
258 */
259 void BytesInFlightTrace(uint32_t oldValue, uint32_t newValue) override;
260
261 /**
262 * \brief Called when a packet is dropped.
263 * \param ipH The IP header.
264 * \param tcpH The TCP header.
265 * \param p The packet.
266 */
267 void PktDropped(const Ipv4Header& ipH, const TcpHeader& tcpH, Ptr<const Packet> p);
268
269 /**
270 * \brief Configure the test.
271 */
272 void ConfigureEnvironment() override;
273
274 /**
275 * \brief Do the final checks.
276 */
277 void FinalChecks() override;
278
279 /**
280 * \brief Track the rate value of TcpRateLinux.
281 * \param rate updated value of TcpRate.
282 */
283 void RateUpdatedTrace(const TcpRateLinux::TcpRateConnection& rate) override;
284
285 /**
286 * \brief Track the rate sample value of TcpRateLinux.
287 * \param sample updated value of TcpRateSample.
288 */
289 void RateSampleUpdatedTrace(const TcpRateLinux::TcpRateSample& sample) override;
290
291 private:
292 Ptr<MimicCongControl> m_congCtl; //!< Dummy congestion control.
293 bool m_sackEnabled; //!< Sack Variable
294 std::vector<uint32_t> m_toDrop; //!< List of SequenceNumber to drop
295 uint32_t m_bytesInFlight{0}; //!< Bytes inflight
297 bool m_isDupAck; //!< Whether ACK is DupAck
300};
301
303 bool sackEnabled,
304 std::vector<uint32_t>& toDrop)
305 : TcpGeneralTest(desc),
306 m_sackEnabled(sackEnabled),
307 m_toDrop(toDrop)
308{
309}
310
319
320void
330
333{
335 for (auto it = m_toDrop.begin(); it != m_toDrop.end(); ++it)
336 {
337 m_errorModel->AddSeqToKill(SequenceNumber32(*it));
338 }
339
340 m_errorModel->SetDropCallback(MakeCallback(&TcpRateLinuxWithSocketsTest::PktDropped, this));
341
342 return m_errorModel;
343}
344
345void
347 const TcpHeader& tcpH,
349{
350 NS_LOG_DEBUG("Drop seq= " << tcpH.GetSequenceNumber() << " size " << p->GetSize());
351}
352
353void
355{
356 if (who == SENDER)
357 {
359 (h.GetFlags() & TcpHeader::FIN) == 0)
360 {
361 m_isDupAck = true;
362 }
363 else
364 {
365 m_isDupAck = false;
367 }
368 }
369}
370
371void
373{
374 m_bytesInFlight = newValue;
375}
376
377void
379{
380 NS_LOG_DEBUG("Rate updated " << rate);
381 if (m_bytesInFlight == 0)
382 {
385 "FirstSentTime should be current time when bytes inflight is zero");
388 "Delivered time should be current time when bytes inflight is zero");
389 }
391 m_prevRate.m_delivered,
392 "Total delivered should not be lesser than previous values");
393 m_prevRate = rate;
394}
395
396void
398{
399 NS_LOG_DEBUG("Rate sample updated " << sample);
400 if (m_isDupAck)
401 {
402 if (!m_sackEnabled)
403 {
405 sample,
406 "RateSample should not update due to DupAcks");
407 }
408 else
409 {
410 if (sample.m_ackedSacked == 0)
411 {
413 sample,
414 "RateSample should not update as nothing is acked or sacked");
415 }
416 }
417 }
418 m_prevRateSample = sample;
419}
420
421void
425
426/**
427 * \ingroup internet-test
428 * \ingroup tests
429 *
430 * \brief The TcpRateLinuxWithBufferTest tests rate sample functionality with arbitrary SACK
431 * scenario. Check the value of delivered against a home-made guess
432 */
434{
435 public:
436 /**
437 * \brief Constructor.
438 * \param segmentSize Segment size to use.
439 * \param desc Description.
440 */
442
443 private:
444 void DoRun() override;
445 void DoTeardown() override;
446
447 /**
448 * \brief Track the rate value of TcpRateLinux.
449 * \param rate updated value of TcpRate.
450 */
451 virtual void RateUpdatedTrace(const TcpRateLinux::TcpRateConnection& rate);
452
453 /**
454 * \brief Track the rate sample value of TcpRateLinux.
455 * \param sample updated value of TcpRateSample.
456 */
457 virtual void RateSampleUpdatedTrace(const TcpRateLinux::TcpRateSample& sample);
458
459 /** \brief Test with acks without drop */
461
462 /** \brief Test with arbitrary SACK scenario */
463 void TestWithSackBlocks();
464
465 uint32_t m_expectedDelivered{0}; //!< Amount of expected delivered data
466 uint32_t m_expectedAckedSacked{0}; //!< Amount of expected acked sacked data
467 uint32_t m_segmentSize; //!< Segment size
468 TcpTxBuffer m_txBuf; //!< Tcp Tx buffer
469 Ptr<TcpRateOps> m_rateOps; //!< Rate operations
470};
471
473 : TestCase(testString),
474 m_segmentSize(segmentSize)
475{
477 m_rateOps->TraceConnectWithoutContext(
478 "TcpRateUpdated",
480 m_rateOps->TraceConnectWithoutContext(
481 "TcpRateSampleUpdated",
483}
484
485void
492
493void
495{
496 NS_LOG_DEBUG("Rate updated " << rate);
499 "Delivered data is not equal to expected delivered");
500}
501
502void
504{
505 NS_LOG_DEBUG("Rate sample updated " << sample);
508 "AckedSacked bytes is not equal to expected AckedSacked bytes");
509}
510
511void
513{
514 SequenceNumber32 head(1);
520
522
523 // Send 10 Segments
524 for (uint8_t i = 0; i < 10; ++i)
525 {
526 bool isStartOfTransmission = m_txBuf.BytesInFlight() == 0;
527 TcpTxItem* outItem =
529 m_rateOps->SkbSent(outItem, isStartOfTransmission);
530 }
531
532 uint32_t priorInFlight = m_txBuf.BytesInFlight();
533 // ACK 2 Segments
534 for (uint8_t i = 1; i <= 2; ++i)
535 {
536 priorInFlight = m_txBuf.BytesInFlight();
541 m_rateOps->GenerateSample(m_segmentSize, 0, false, priorInFlight, Seconds(0));
542 }
543
544 priorInFlight = m_txBuf.BytesInFlight();
545 sack->AddSackBlock(TcpOptionSack::SackBlock(SequenceNumber32(m_segmentSize * 4 + 1),
550 m_rateOps->GenerateSample(m_segmentSize, 0, false, priorInFlight, Seconds(0));
551
552 priorInFlight = m_txBuf.BytesInFlight();
553 sack->AddSackBlock(TcpOptionSack::SackBlock(SequenceNumber32(m_segmentSize * 3 + 1),
557 m_rateOps->GenerateSample(m_segmentSize, 0, false, priorInFlight, Seconds(0));
558
559 priorInFlight = m_txBuf.BytesInFlight();
560 // Actual delivered should be increased by one segment even multiple blocks are acked.
564 m_rateOps->GenerateSample(m_segmentSize, 0, false, priorInFlight, Seconds(0));
565
566 priorInFlight = m_txBuf.BytesInFlight();
567 // ACK rest of the segments
568 for (uint8_t i = 6; i <= 10; ++i)
569 {
573 }
575 TcpRateOps::TcpRateSample rateSample =
576 m_rateOps->GenerateSample(5 * m_segmentSize, 0, false, priorInFlight, Seconds(0));
577}
578
579void
583
584/**
585 * \ingroup internet-test
586 *
587 * \brief the TestSuite for the TcpRateLinux test case
588 */
590{
591 public:
593 : TestSuite("tcp-rate-ops", Type::UNIT)
594 {
598 1,
599 "Testing SkbDelivered and SkbSent"),
600 TestCase::Duration::QUICK);
602 new TcpRateLinuxBasicTest(1000,
605 2,
606 "Testing SkbDelivered and SkbSent with app limited data"),
607 TestCase::Duration::QUICK);
608
609 std::vector<uint32_t> toDrop;
610 toDrop.push_back(4001);
612 new TcpRateLinuxWithSocketsTest("Checking Rate sample value without SACK, one drop",
613 false,
614 toDrop),
615 TestCase::Duration::QUICK);
616
618 new TcpRateLinuxWithSocketsTest("Checking Rate sample value with SACK, one drop",
619 true,
620 toDrop),
621 TestCase::Duration::QUICK);
622 toDrop.push_back(4001);
624 new TcpRateLinuxWithSocketsTest("Checking Rate sample value without SACK, two drop",
625 false,
626 toDrop),
627 TestCase::Duration::QUICK);
628
630 new TcpRateLinuxWithSocketsTest("Checking Rate sample value with SACK, two drop",
631 true,
632 toDrop),
633 TestCase::Duration::QUICK);
634
637 "Checking rate sample values with arbitrary SACK Block"),
638 TestCase::Duration::QUICK);
639
642 "Checking rate sample values with arbitrary SACK Block"),
643 TestCase::Duration::QUICK);
644 }
645};
646
647static TcpRateOpsTestSuite g_TcpRateOpsTestSuite; //!< Static variable for test initialization
Behaves as NewReno except HasCongControl returns true.
static TypeId GetTypeId()
Get the type ID.
bool HasCongControl() const override
Returns true when Congestion Control Algorithm implements CongControl.
The TcpRateLinux Basic Test.
void SkbDelivered(TcpTxItem *skb)
Deliver an application packet.
uint32_t m_delivered
Number of segments delivered.
void SendSkb(TcpTxItem *skb)
Send an application packet.
uint32_t m_segmentSize
Segment size.
TcpRateLinux m_rateOps
Rate information for TCP.
Time m_deliveredTime
Last time of a delivery.
uint32_t m_testCase
Test case type.
uint32_t m_inFlight
Number of packets in-flight.
uint32_t m_cWnd
Congestion window size.
TcpRateLinuxBasicTest(uint32_t cWnd, SequenceNumber32 tailSeq, SequenceNumber32 nextTx, uint32_t testCase, std::string testName)
Constructor.
SequenceNumber32 m_tailSeq
Tail sequence number.
void DoRun() override
Implementation to actually run this TestCase.
std::vector< TcpTxItem * > m_skbs
Application packets.
SequenceNumber32 m_nextTx
Tx next sequence number.
The TcpRateLinuxWithBufferTest tests rate sample functionality with arbitrary SACK scenario.
uint32_t m_expectedAckedSacked
Amount of expected acked sacked data.
void DoRun() override
Implementation to actually run this TestCase.
void TestWithStraightAcks()
Test with acks without drop.
TcpTxBuffer m_txBuf
Tcp Tx buffer.
virtual void RateUpdatedTrace(const TcpRateLinux::TcpRateConnection &rate)
Track the rate value of TcpRateLinux.
TcpRateLinuxWithBufferTest(uint32_t segmentSize, std::string desc)
Constructor.
virtual void RateSampleUpdatedTrace(const TcpRateLinux::TcpRateSample &sample)
Track the rate sample value of TcpRateLinux.
void TestWithSackBlocks()
Test with arbitrary SACK scenario.
Ptr< TcpRateOps > m_rateOps
Rate operations.
uint32_t m_expectedDelivered
Amount of expected delivered data.
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
uint32_t m_segmentSize
Segment size.
The TcpRateLinux Test uses sender-receiver model to test its functionality.
void PktDropped(const Ipv4Header &ipH, const TcpHeader &tcpH, Ptr< const Packet > p)
Called when a packet is dropped.
TcpRateLinuxWithSocketsTest(const std::string &desc, bool sackEnabled, std::vector< uint32_t > &toDrop)
Constructor.
void Rx(const Ptr< const Packet > p, const TcpHeader &h, SocketWho who) override
Receive a packet.
Ptr< TcpSocketMsgBase > CreateSenderSocket(Ptr< Node > node) override
Create and install the socket to install on the sender.
bool m_isDupAck
Whether ACK is DupAck.
void BytesInFlightTrace(uint32_t oldValue, uint32_t newValue) override
Track the bytes in flight.
void ConfigureEnvironment() override
Configure the test.
void FinalChecks() override
Do the final checks.
void RateSampleUpdatedTrace(const TcpRateLinux::TcpRateSample &sample) override
Track the rate sample value of TcpRateLinux.
SequenceNumber32 m_lastAckRecv
Last ACK received.
TcpRateLinux::TcpRateSample m_prevRateSample
Previous rate sample.
std::vector< uint32_t > m_toDrop
List of SequenceNumber to drop.
Ptr< ErrorModel > CreateReceiverErrorModel() override
Create a receiver error model.
uint32_t m_bytesInFlight
Bytes inflight.
void RateUpdatedTrace(const TcpRateLinux::TcpRateConnection &rate) override
Track the rate value of TcpRateLinux.
TcpRateLinux::TcpRateConnection m_prevRate
Previous rate.
Ptr< MimicCongControl > m_congCtl
Dummy congestion control.
the TestSuite for the TcpRateLinux test case
Packet header for IPv4.
Definition ipv4-header.h:23
Smart pointer class similar to boost::intrusive_ptr.
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition simulator.h:560
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition simulator.cc:131
static Time Now()
Return the current simulation virtual time.
Definition simulator.cc:197
static void Run()
Run the simulation.
Definition simulator.cc:167
General infrastructure for TCP testing.
virtual Ptr< TcpSocketMsgBase > CreateSenderSocket(Ptr< Node > node)
Create and install the socket to install on the sender.
void SetPropagationDelay(Time propDelay)
Propagation delay of the bottleneck link.
void SetAppPktCount(uint32_t pktCount)
Set app packet count.
SocketWho
Used as parameter of methods, specifies on what node the caller is interested (e.g.
virtual void ConfigureEnvironment()
Change the configuration of the environment.
void SetTransmitStart(Time startTime)
Set the initial time at which the application sends the first data packet.
Header for the Transmission Control Protocol.
Definition tcp-header.h:36
SequenceNumber32 GetSequenceNumber() const
Get the sequence number.
uint8_t GetFlags() const
Get the flags.
SequenceNumber32 GetAckNumber() const
Get the ACK number.
The NewReno implementation.
std::pair< SequenceNumber32, SequenceNumber32 > SackBlock
SACK block definition.
Linux management and generation of Rate information for TCP.
void SkbDelivered(TcpTxItem *skb) override
Update the Rate information after an item is received.
void SkbSent(TcpTxItem *skb, bool isStartOfTransmission) override
Put the rate information inside the sent skb.
void CalculateAppLimited(uint32_t cWnd, uint32_t in_flight, uint32_t segmentSize, const SequenceNumber32 &tailSeq, const SequenceNumber32 &nextTx, const uint32_t lostOut, const uint32_t retransOut) override
If a gap is detected between sends, it means we are app-limited.
virtual void SkbDelivered(TcpTxItem *skb)=0
Update the Rate information after an item is received.
Tcp sender buffer.
bool Add(Ptr< Packet > p)
Append a data packet to the end of the buffer.
void SetSegmentSize(uint32_t segmentSize)
Set the segment size.
void SetDupAckThresh(uint32_t dupAckThresh)
Set the DupAckThresh.
TcpTxItem * CopyFromSequence(uint32_t numBytes, const SequenceNumber32 &seq)
Copy data from the range [seq, seq+numBytes) into a packet.
uint32_t Update(const TcpOptionSack::SackList &list, const Callback< void, TcpTxItem * > &sackedCb=m_nullCb)
Update the scoreboard.
uint32_t BytesInFlight() const
Return total bytes in flight.
void DiscardUpTo(const SequenceNumber32 &seq, const Callback< void, TcpTxItem * > &beforeDelCb=m_nullCb)
Discard data up to but not including this sequence number.
void SetHeadSequence(const SequenceNumber32 &seq)
Set the head sequence of the buffer.
Item that encloses the application packet and some flags for it.
Definition tcp-tx-item.h:22
uint32_t GetSeqSize() const
Get the size in the sequence number space.
RateInformation & GetRateInformation()
Get (to modify) the Rate Information of this item.
encapsulates test code
Definition test.h:1050
void AddTestCase(TestCase *testCase, Duration duration=Duration::QUICK)
Add an individual child TestCase to this test suite.
Definition test.cc:292
A suite of tests to run.
Definition test.h:1267
Type
Type of test.
Definition test.h:1274
static constexpr auto UNIT
Definition test.h:1291
Simulation virtual time values and global simulation resolution.
Definition nstime.h:94
static Time Max()
Maximum representable Time Not to be confused with Max(Time,Time).
Definition nstime.h:286
a unique identifier for an interface.
Definition type-id.h:48
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition type-id.cc:1001
uint32_t segmentSize
void SetDefault(std::string name, const AttributeValue &value)
Definition config.cc:883
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition log.h:191
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition log.h:257
Ptr< T > CreateObject(Args &&... args)
Create an object by type, with varying number of constructor parameters.
Definition object.h:619
Ptr< T > Create(Ts &&... args)
Create class instances by constructors with varying numbers of arguments and return them by Ptr.
Definition ptr.h:436
SequenceNumber< uint32_t, int32_t > SequenceNumber32
32 bit Sequence number.
#define NS_TEST_ASSERT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report and abort if not.
Definition test.h:134
#define NS_TEST_ASSERT_MSG_GT_OR_EQ(actual, limit, msg)
Test that an actual value is greater than or equal to a limit and report and abort if not.
Definition test.h:905
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition nstime.h:1308
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition nstime.h:1320
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Callback< R, Args... > MakeCallback(R(T::*memPtr)(Args...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition callback.h:684
Information about the connection rate.
Time m_deliveredTime
Simulator time when m_delivered was last updated.
uint64_t m_delivered
The total amount of data in bytes delivered so far.
Time m_firstSentTime
The send time of the packet that was most recently marked as delivered.
Rate Sample structure.
uint32_t m_ackedSacked
The amount of data acked and sacked in the last received ack.
bool m_isAppLimited
Connection's app limited at the time the packet was sent.
Definition tcp-tx-item.h:83
uint64_t m_delivered
Connection's delivered data at the time the packet was sent.
Definition tcp-tx-item.h:78
Time m_deliveredTime
Connection's delivered time at the time the packet was sent.
Definition tcp-tx-item.h:79
static TcpRateOpsTestSuite g_TcpRateOpsTestSuite
Static variable for test initialization.