A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
flow-monitor.cc
Go to the documentation of this file.
1//
2// Copyright (c) 2009 INESC Porto
3//
4// SPDX-License-Identifier: GPL-2.0-only
5//
6// Author: Gustavo J. A. M. Carneiro <gjc@inescporto.pt> <gjcarneiro@gmail.com>
7//
8
9#include "flow-monitor.h"
10
11#include "ns3/double.h"
12#include "ns3/log.h"
13#include "ns3/simulator.h"
14
15#include <fstream>
16#include <limits>
17#include <sstream>
18
19#define PERIODIC_CHECK_INTERVAL (Seconds(1))
20
21namespace ns3
22{
23
24NS_LOG_COMPONENT_DEFINE("FlowMonitor");
25
27
28TypeId
30{
31 static TypeId tid =
32 TypeId("ns3::FlowMonitor")
34 .SetGroupName("FlowMonitor")
35 .AddConstructor<FlowMonitor>()
36 .AddAttribute(
37 "MaxPerHopDelay",
38 ("The maximum per-hop delay that should be considered. "
39 "Packets still not received after this delay are to be considered lost."),
40 TimeValue(Seconds(10.0)),
43 .AddAttribute("StartTime",
44 ("The time when the monitoring starts."),
45 TimeValue(Seconds(0.0)),
48 .AddAttribute("DelayBinWidth",
49 ("The width used in the delay histogram."),
50 DoubleValue(0.001),
53 .AddAttribute("JitterBinWidth",
54 ("The width used in the jitter histogram."),
55 DoubleValue(0.001),
58 .AddAttribute("PacketSizeBinWidth",
59 ("The width used in the packetSize histogram."),
60 DoubleValue(20),
63 .AddAttribute("FlowInterruptionsBinWidth",
64 ("The width used in the flowInterruptions histogram."),
65 DoubleValue(0.250),
68 .AddAttribute(
69 "FlowInterruptionsMinTime",
70 ("The minimum inter-arrival time that is considered a flow interruption."),
71 TimeValue(Seconds(0.5)),
74 return tid;
75}
76
79{
80 return GetTypeId();
81}
82
84 : m_enabled(false)
85{
86 NS_LOG_FUNCTION(this);
87}
88
89void
91{
92 NS_LOG_FUNCTION(this);
95 for (auto iter = m_classifiers.begin(); iter != m_classifiers.end(); iter++)
96 {
97 *iter = nullptr;
98 }
99 for (uint32_t i = 0; i < m_flowProbes.size(); i++)
100 {
101 m_flowProbes[i]->Dispose();
102 m_flowProbes[i] = nullptr;
103 }
105}
106
109{
110 NS_LOG_FUNCTION(this);
111 auto iter = m_flowStats.find(flowId);
112 if (iter == m_flowStats.end())
113 {
114 FlowMonitor::FlowStats& ref = m_flowStats[flowId];
115 ref.delaySum = Seconds(0);
116 ref.jitterSum = Seconds(0);
117 ref.lastDelay = Seconds(0);
118 ref.maxDelay = Seconds(0);
119 ref.minDelay = Seconds(std::numeric_limits<double>::max());
120 ref.txBytes = 0;
121 ref.rxBytes = 0;
122 ref.txPackets = 0;
123 ref.rxPackets = 0;
124 ref.lostPackets = 0;
125 ref.timesForwarded = 0;
130 return ref;
131 }
132 else
133 {
134 return iter->second;
135 }
136}
137
138void
140 uint32_t flowId,
141 uint32_t packetId,
143{
144 NS_LOG_FUNCTION(this << probe << flowId << packetId << packetSize);
145 if (!m_enabled)
146 {
147 NS_LOG_DEBUG("FlowMonitor not enabled; returning");
148 return;
149 }
150 Time now = Simulator::Now();
151 TrackedPacket& tracked = m_trackedPackets[std::make_pair(flowId, packetId)];
152 tracked.firstSeenTime = now;
153 tracked.lastSeenTime = tracked.firstSeenTime;
154 tracked.timesForwarded = 0;
155 NS_LOG_DEBUG("ReportFirstTx: adding tracked packet (flowId=" << flowId << ", packetId="
156 << packetId << ").");
157
158 probe->AddPacketStats(flowId, packetSize, Seconds(0));
159
160 FlowStats& stats = GetStatsForFlow(flowId);
161 stats.txBytes += packetSize;
162 stats.txPackets++;
163 if (stats.txPackets == 1)
164 {
165 stats.timeFirstTxPacket = now;
166 }
167 stats.timeLastTxPacket = now;
168}
169
170void
172 uint32_t flowId,
173 uint32_t packetId,
175{
176 NS_LOG_FUNCTION(this << probe << flowId << packetId << packetSize);
177 if (!m_enabled)
178 {
179 NS_LOG_DEBUG("FlowMonitor not enabled; returning");
180 return;
181 }
182 std::pair<FlowId, FlowPacketId> key(flowId, packetId);
183 auto tracked = m_trackedPackets.find(key);
184 if (tracked == m_trackedPackets.end())
185 {
186 NS_LOG_WARN("Received packet forward report (flowId="
187 << flowId << ", packetId=" << packetId << ") but not known to be transmitted.");
188 return;
189 }
190
191 tracked->second.timesForwarded++;
192 tracked->second.lastSeenTime = Simulator::Now();
193
194 Time delay = (Simulator::Now() - tracked->second.firstSeenTime);
195 probe->AddPacketStats(flowId, packetSize, delay);
196}
197
198void
200 uint32_t flowId,
201 uint32_t packetId,
203{
204 NS_LOG_FUNCTION(this << probe << flowId << packetId << packetSize);
205 if (!m_enabled)
206 {
207 NS_LOG_DEBUG("FlowMonitor not enabled; returning");
208 return;
209 }
210 auto tracked = m_trackedPackets.find(std::make_pair(flowId, packetId));
211 if (tracked == m_trackedPackets.end())
212 {
213 NS_LOG_WARN("Received packet last-tx report (flowId="
214 << flowId << ", packetId=" << packetId << ") but not known to be transmitted.");
215 return;
216 }
217
218 Time now = Simulator::Now();
219 Time delay = (now - tracked->second.firstSeenTime);
220 probe->AddPacketStats(flowId, packetSize, delay);
221
222 FlowStats& stats = GetStatsForFlow(flowId);
223 stats.delaySum += delay;
224 stats.delayHistogram.AddValue(delay.GetSeconds());
225 if (stats.rxPackets > 0)
226 {
227 Time jitter = stats.lastDelay - delay;
228 if (jitter > Seconds(0))
229 {
230 stats.jitterSum += jitter;
231 stats.jitterHistogram.AddValue(jitter.GetSeconds());
232 }
233 else
234 {
235 stats.jitterSum -= jitter;
236 stats.jitterHistogram.AddValue(-jitter.GetSeconds());
237 }
238 }
239 stats.lastDelay = delay;
240 if (delay > stats.maxDelay)
241 {
242 stats.maxDelay = delay;
243 }
244 if (delay < stats.minDelay)
245 {
246 stats.minDelay = delay;
247 }
248
249 stats.rxBytes += packetSize;
251 stats.rxPackets++;
252 if (stats.rxPackets == 1)
253 {
254 stats.timeFirstRxPacket = now;
255 }
256 else
257 {
258 // measure possible flow interruptions
259 Time interArrivalTime = now - stats.timeLastRxPacket;
260 if (interArrivalTime > m_flowInterruptionsMinTime)
261 {
262 stats.flowInterruptionsHistogram.AddValue(interArrivalTime.GetSeconds());
263 }
264 }
265 stats.timeLastRxPacket = now;
266 stats.timesForwarded += tracked->second.timesForwarded;
267
268 NS_LOG_DEBUG("ReportLastTx: removing tracked packet (flowId=" << flowId << ", packetId="
269 << packetId << ").");
270
271 m_trackedPackets.erase(tracked); // we don't need to track this packet anymore
272}
273
274void
276 uint32_t flowId,
277 uint32_t packetId,
279 uint32_t reasonCode)
280{
281 NS_LOG_FUNCTION(this << probe << flowId << packetId << packetSize << reasonCode);
282 if (!m_enabled)
283 {
284 NS_LOG_DEBUG("FlowMonitor not enabled; returning");
285 return;
286 }
287
288 probe->AddPacketDropStats(flowId, packetSize, reasonCode);
289
290 FlowStats& stats = GetStatsForFlow(flowId);
291 stats.lostPackets++;
292 if (stats.packetsDropped.size() < reasonCode + 1)
293 {
294 stats.packetsDropped.resize(reasonCode + 1, 0);
295 stats.bytesDropped.resize(reasonCode + 1, 0);
296 }
297 ++stats.packetsDropped[reasonCode];
298 stats.bytesDropped[reasonCode] += packetSize;
299 NS_LOG_DEBUG("++stats.packetsDropped["
300 << reasonCode << "]; // becomes: " << stats.packetsDropped[reasonCode]);
301
302 auto tracked = m_trackedPackets.find(std::make_pair(flowId, packetId));
303 if (tracked != m_trackedPackets.end())
304 {
305 // we don't need to track this packet anymore
306 // FIXME: this will not necessarily be true with broadcast/multicast
307 NS_LOG_DEBUG("ReportDrop: removing tracked packet (flowId=" << flowId << ", packetId="
308 << packetId << ").");
309 m_trackedPackets.erase(tracked);
310 }
311}
312
315{
316 return m_flowStats;
317}
318
319void
321{
322 NS_LOG_FUNCTION(this << maxDelay.As(Time::S));
323 Time now = Simulator::Now();
324
325 for (auto iter = m_trackedPackets.begin(); iter != m_trackedPackets.end();)
326 {
327 if (now - iter->second.lastSeenTime >= maxDelay)
328 {
329 // packet is considered lost, add it to the loss statistics
330 auto flow = m_flowStats.find(iter->first.first);
331 NS_ASSERT(flow != m_flowStats.end());
332 flow->second.lostPackets++;
333
334 // we won't track it anymore
335 m_trackedPackets.erase(iter++);
336 }
337 else
338 {
339 iter++;
340 }
341 }
342}
343
344void
349
350void
356
357void
363
364void
366{
367 m_flowProbes.push_back(probe);
368}
369
372{
373 return m_flowProbes;
374}
375
376void
378{
379 NS_LOG_FUNCTION(this << time.As(Time::S));
380 if (m_enabled)
381 {
382 NS_LOG_DEBUG("FlowMonitor already enabled; returning");
383 return;
384 }
386 NS_LOG_DEBUG("Scheduling start at " << time.As(Time::S));
388}
389
390void
392{
393 NS_LOG_FUNCTION(this << time.As(Time::S));
395 NS_LOG_DEBUG("Scheduling stop at " << time.As(Time::S));
397}
398
399void
401{
402 NS_LOG_FUNCTION(this);
403 if (m_enabled)
404 {
405 NS_LOG_DEBUG("FlowMonitor already enabled; returning");
406 return;
407 }
408 m_enabled = true;
409}
410
411void
413{
414 NS_LOG_FUNCTION(this);
415 if (!m_enabled)
416 {
417 NS_LOG_DEBUG("FlowMonitor not enabled; returning");
418 return;
419 }
420 m_enabled = false;
422}
423
424void
426{
427 m_classifiers.push_back(classifier);
428}
429
430void
432 uint16_t indent,
433 bool enableHistograms,
434 bool enableProbes)
435{
436 NS_LOG_FUNCTION(this << indent << enableHistograms << enableProbes);
438
439 os << std::string(indent, ' ') << "<FlowMonitor>\n";
440 indent += 2;
441 os << std::string(indent, ' ') << "<FlowStats>\n";
442 indent += 2;
443 for (auto flowI = m_flowStats.begin(); flowI != m_flowStats.end(); flowI++)
444 {
445 os << std::string(indent, ' ');
446#define ATTRIB(name) " " #name "=\"" << flowI->second.name << "\""
447#define ATTRIB_TIME(name) " " #name "=\"" << flowI->second.name.As(Time::NS) << "\""
448 os << "<Flow flowId=\"" << flowI->first << "\"" << ATTRIB_TIME(timeFirstTxPacket)
449 << ATTRIB_TIME(timeFirstRxPacket) << ATTRIB_TIME(timeLastTxPacket)
450 << ATTRIB_TIME(timeLastRxPacket) << ATTRIB_TIME(delaySum) << ATTRIB_TIME(jitterSum)
451 << ATTRIB_TIME(lastDelay) << ATTRIB_TIME(maxDelay) << ATTRIB_TIME(minDelay)
452 << ATTRIB(txBytes) << ATTRIB(rxBytes) << ATTRIB(txPackets) << ATTRIB(rxPackets)
453 << ATTRIB(lostPackets) << ATTRIB(timesForwarded) << ">\n";
454#undef ATTRIB_TIME
455#undef ATTRIB
456
457 indent += 2;
458 for (uint32_t reasonCode = 0; reasonCode < flowI->second.packetsDropped.size();
459 reasonCode++)
460 {
461 os << std::string(indent, ' ');
462 os << "<packetsDropped reasonCode=\"" << reasonCode << "\""
463 << " number=\"" << flowI->second.packetsDropped[reasonCode] << "\" />\n";
464 }
465 for (uint32_t reasonCode = 0; reasonCode < flowI->second.bytesDropped.size(); reasonCode++)
466 {
467 os << std::string(indent, ' ');
468 os << "<bytesDropped reasonCode=\"" << reasonCode << "\""
469 << " bytes=\"" << flowI->second.bytesDropped[reasonCode] << "\" />\n";
470 }
471 if (enableHistograms)
472 {
473 flowI->second.delayHistogram.SerializeToXmlStream(os, indent, "delayHistogram");
474 flowI->second.jitterHistogram.SerializeToXmlStream(os, indent, "jitterHistogram");
475 flowI->second.packetSizeHistogram.SerializeToXmlStream(os,
476 indent,
477 "packetSizeHistogram");
478 flowI->second.flowInterruptionsHistogram.SerializeToXmlStream(
479 os,
480 indent,
481 "flowInterruptionsHistogram");
482 }
483 indent -= 2;
484
485 os << std::string(indent, ' ') << "</Flow>\n";
486 }
487 indent -= 2;
488 os << std::string(indent, ' ') << "</FlowStats>\n";
489
490 for (auto iter = m_classifiers.begin(); iter != m_classifiers.end(); iter++)
491 {
492 (*iter)->SerializeToXmlStream(os, indent);
493 }
494
495 if (enableProbes)
496 {
497 os << std::string(indent, ' ') << "<FlowProbes>\n";
498 indent += 2;
499 for (uint32_t i = 0; i < m_flowProbes.size(); i++)
500 {
501 m_flowProbes[i]->SerializeToXmlStream(os, indent, i);
502 }
503 indent -= 2;
504 os << std::string(indent, ' ') << "</FlowProbes>\n";
505 }
506
507 indent -= 2;
508 os << std::string(indent, ' ') << "</FlowMonitor>\n";
509}
510
511std::string
512FlowMonitor::SerializeToXmlString(uint16_t indent, bool enableHistograms, bool enableProbes)
513{
514 NS_LOG_FUNCTION(this << indent << enableHistograms << enableProbes);
515 std::ostringstream os;
516 SerializeToXmlStream(os, indent, enableHistograms, enableProbes);
517 return os.str();
518}
519
520void
521FlowMonitor::SerializeToXmlFile(std::string fileName, bool enableHistograms, bool enableProbes)
522{
523 NS_LOG_FUNCTION(this << fileName << enableHistograms << enableProbes);
524 std::ofstream os(fileName, std::ios::out | std::ios::binary);
525 os << "<?xml version=\"1.0\" ?>\n";
526 SerializeToXmlStream(os, 0, enableHistograms, enableProbes);
527 os.close();
528}
529
530void
532{
533 NS_LOG_FUNCTION(this);
534
535 for (auto& iter : m_flowStats)
536 {
537 auto& flowStat = iter.second;
538 flowStat.delaySum = Seconds(0);
539 flowStat.jitterSum = Seconds(0);
540 flowStat.lastDelay = Seconds(0);
541 flowStat.maxDelay = Seconds(0);
542 flowStat.minDelay = Seconds(std::numeric_limits<double>::max());
543 flowStat.txBytes = 0;
544 flowStat.rxBytes = 0;
545 flowStat.txPackets = 0;
546 flowStat.rxPackets = 0;
547 flowStat.lostPackets = 0;
548 flowStat.timesForwarded = 0;
549 flowStat.bytesDropped.clear();
550 flowStat.packetsDropped.clear();
551
552 flowStat.delayHistogram.Clear();
553 flowStat.jitterHistogram.Clear();
554 flowStat.packetSizeHistogram.Clear();
555 flowStat.flowInterruptionsHistogram.Clear();
556 }
557}
558
559} // namespace ns3
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition double.h:31
An object that monitors and reports back packet flows observed during a simulation.
FlowStats & GetStatsForFlow(FlowId flowId)
Get the stats for a given flow.
FlowProbeContainer m_flowProbes
all the FlowProbes
void StopRightNow()
End monitoring flows right now
void ResetAllStats()
Reset all the statistics.
const FlowProbeContainer & GetAllProbes() const
Get a list of all FlowProbe's associated with this FlowMonitor.
std::vector< Ptr< FlowProbe > > FlowProbeContainer
Container: FlowProbe.
FlowStatsContainer m_flowStats
FlowId --> FlowStats.
bool m_enabled
FlowMon is enabled.
void CheckForLostPackets()
Check right now for packets that appear to be lost.
void Start(const Time &time)
Set the time, counting from the current time, from which to start monitoring flows.
double m_flowInterruptionsBinWidth
Flow interruptions bin width (for histograms)
void SerializeToXmlFile(std::string fileName, bool enableHistograms, bool enableProbes)
Same as SerializeToXmlStream, but writes to a file instead.
void AddFlowClassifier(Ptr< FlowClassifier > classifier)
Add a FlowClassifier to be used by the flow monitor.
void ReportLastRx(Ptr< FlowProbe > probe, FlowId flowId, FlowPacketId packetId, uint32_t packetSize)
FlowProbe implementations are supposed to call this method to report that a known packet is being rec...
EventId m_startEvent
Start event.
std::list< Ptr< FlowClassifier > > m_classifiers
the FlowClassifiers
void AddProbe(Ptr< FlowProbe > probe)
Register a new FlowProbe that will begin monitoring and report events to this monitor.
void ReportForwarding(Ptr< FlowProbe > probe, FlowId flowId, FlowPacketId packetId, uint32_t packetSize)
FlowProbe implementations are supposed to call this method to report that a known packet is being for...
Time m_flowInterruptionsMinTime
Flow interruptions minimum time.
std::map< FlowId, FlowStats > FlowStatsContainer
Container: FlowId, FlowStats.
double m_jitterBinWidth
Jitter bin width (for histograms)
std::string SerializeToXmlString(uint16_t indent, bool enableHistograms, bool enableProbes)
Same as SerializeToXmlStream, but returns the output as a std::string.
void Stop(const Time &time)
Set the time, counting from the current time, from which to stop monitoring flows.
void PeriodicCheckForLostPackets()
Periodic function to check for lost packets and prune statistics.
double m_packetSizeBinWidth
packet size bin width (for histograms)
Time m_maxPerHopDelay
Minimum per-hop delay.
void DoDispose() override
Destructor implementation.
void NotifyConstructionCompleted() override
Notifier called once the ObjectBase is fully constructed.
const FlowStatsContainer & GetFlowStats() const
Retrieve all collected the flow statistics.
TrackedPacketMap m_trackedPackets
Tracked packets.
TypeId GetInstanceTypeId() const override
Get the most derived TypeId for this Object.
double m_delayBinWidth
Delay bin width (for histograms)
void StartRightNow()
Begin monitoring flows right now
void ReportFirstTx(Ptr< FlowProbe > probe, FlowId flowId, FlowPacketId packetId, uint32_t packetSize)
FlowProbe implementations are supposed to call this method to report that a new packet was transmitte...
void SerializeToXmlStream(std::ostream &os, uint16_t indent, bool enableHistograms, bool enableProbes)
Serializes the results to an std::ostream in XML format.
EventId m_stopEvent
Stop event.
static TypeId GetTypeId()
Get the type ID.
void ReportDrop(Ptr< FlowProbe > probe, FlowId flowId, FlowPacketId packetId, uint32_t packetSize, uint32_t reasonCode)
FlowProbe implementations are supposed to call this method to report that a known packet is being dro...
void SetDefaultBinWidth(double binWidth)
Set the bin width.
Definition histogram.cc:56
void AddValue(double value)
Add a value to the histogram.
Definition histogram.cc:70
virtual void NotifyConstructionCompleted()
Notifier called once the ObjectBase is fully constructed.
A base class which provides memory management and object aggregation.
Definition object.h:78
virtual void DoDispose()
Destructor implementation.
Definition object.cc:433
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 Cancel(const EventId &id)
Set the cancel bit on this event: the event's associated function will not be invoked when it expires...
Definition simulator.cc:274
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
TimeWithUnit As(const Unit unit=Time::AUTO) const
Attach a unit to a Time, to facilitate output in a specific unit.
Definition time.cc:404
double GetSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
Definition nstime.h:392
@ S
second
Definition nstime.h:105
a unique identifier for an interface.
Definition type-id.h:48
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition type-id.cc:1001
#define ATTRIB(name)
#define PERIODIC_CHECK_INTERVAL
#define ATTRIB_TIME(name)
#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_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
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition log.h:250
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition object-base.h:35
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition nstime.h:1308
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Ptr< const AttributeAccessor > MakeTimeAccessor(T1 a1)
Definition nstime.h:1396
Ptr< const AttributeChecker > MakeDoubleChecker()
Definition double.h:82
Ptr< const AttributeAccessor > MakeDoubleAccessor(T1 a1)
Definition double.h:32
Ptr< const AttributeChecker > MakeTimeChecker()
Helper to make an unbounded Time checker.
Definition nstime.h:1416
Structure that represents the measured metrics of an individual packet flow.
uint32_t rxPackets
Total number of received packets for the flow.
Histogram packetSizeHistogram
Histogram of the packet sizes.
Time timeLastTxPacket
Contains the absolute time when the last packet in the flow was transmitted, i.e.
uint32_t lostPackets
Total number of packets that are assumed to be lost, i.e.
Histogram jitterHistogram
Histogram of the packet jitters.
Time lastDelay
Contains the last measured delay of a packet It is stored to measure the packet's Jitter.
Time timeLastRxPacket
Contains the absolute time when the last packet in the flow was received, i.e.
Histogram flowInterruptionsHistogram
histogram of durations of flow interruptions
uint64_t rxBytes
Total number of received bytes for the flow.
Time maxDelay
Contains the largest measured delay of a received packet.
Time minDelay
Contains the smallest measured delay of a received packet.
Time delaySum
Contains the sum of all end-to-end delays for all received packets of the flow.
Time timeFirstRxPacket
Contains the absolute time when the first packet in the flow was received by an end node,...
uint32_t timesForwarded
Contains the number of times a packet has been reportedly forwarded, summed for all received packets ...
uint32_t txPackets
Total number of transmitted packets for the flow.
uint64_t txBytes
Total number of transmitted bytes for the flow.
Histogram delayHistogram
Histogram of the packet delays.
Time jitterSum
Contains the sum of all end-to-end delay jitter (delay variation) values for all received packets of ...
std::vector< uint64_t > bytesDropped
This attribute also tracks the number of lost bytes.
Time timeFirstTxPacket
Contains the absolute time when the first packet in the flow was transmitted, i.e.
std::vector< uint32_t > packetsDropped
This attribute also tracks the number of lost packets and bytes, but discriminates the losses by a re...
Structure to represent a single tracked packet data.
Time lastSeenTime
absolute time when the packet was last seen by a probe
Time firstSeenTime
absolute time when the packet was first seen by a probe
uint32_t timesForwarded
number of times the packet was reportedly forwarded
static const uint32_t packetSize
Packet size generated at the AP.