Debian Codegraph @

srtcore/stats.h

raw
1 /*
2 * SRT - Secure, Reliable, Transport
3 * Copyright (c) 2021 Haivision Systems Inc.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 */
10
11 #ifndef INC_SRT_STATS_H
12 #define INC_SRT_STATS_H
13
14 #include "platform_sys.h"
15 #include "packet.h"
16
17 namespace srt
18 {
19 namespace stats
20 {
21
22 class Packets
23 {
24 public:
25 Packets() : m_count(0) {}
26
27 Packets(uint32_t num) : m_count(num) {}
28
29 void reset()
30 {
31 m_count = 0;
32 }
33
34 Packets& operator+= (const Packets& other)
35 {
36 m_count += other.m_count;
37 return *this;
38 }
39
40 uint32_t count() const
41 {
42 return m_count;
43 }
44
45 private:
46 uint32_t m_count;
47 };
48
49 class BytesPackets
50 {
51 public:
52 BytesPackets()
53 : m_bytes(0)
54 , m_packets(0)
55 {}
56
57 BytesPackets(uint64_t bytes, uint32_t n = 1)
58 : m_bytes(bytes)
59 , m_packets(n)
60 {}
61
62
63 void reset()
64 {
65 m_packets = 0;
66 m_bytes = 0;
67 }
68
69 void count(uint64_t bytes, size_t n = 1)
70 {
71 m_packets += (uint32_t) n;
72 m_bytes += bytes;
73 }
74
75 uint64_t bytes() const
76 {
77 return m_bytes;
78 }
79
80 uint32_t count() const
81 {
82 return m_packets;
83 }
84
85 BytesPackets& operator+= (const BytesPackets& other)
86 {
87 m_bytes += other.m_bytes;
88 m_packets += other.m_packets;
89 return *this;
90 }
91
92 uint64_t bytesWithHdr(size_t hdr_size) const
93 {
94 return m_bytes + m_packets * hdr_size;
95 }
96
97 protected:
98 uint64_t m_bytes;
99 uint32_t m_packets;
100 };
101
102
103 template <class METRIC_TYPE, class BASE_METRIC_TYPE = METRIC_TYPE>
104 struct Metric
105 {
106 METRIC_TYPE trace;
107 METRIC_TYPE total;
108
109 void count(BASE_METRIC_TYPE val)
110 {
111 trace += val;
112 total += val;
113 }
114
115 void setupHeaderSize(int loc)
116 {
117 trace.setupHeaderSize(loc);
118 total.setupHeaderSize(loc);
119 }
120
121 void reset()
122 {
123 trace.reset();
124 total.reset();
125 }
126
127 void resetTrace()
128 {
129 trace.reset();
130 }
131 };
132
133 /// Sender-side statistics.
134 struct Sender
135 {
136 Metric<BytesPackets> sent;
137 Metric<BytesPackets> sentUnique;
138 Metric<BytesPackets> sentRetrans; // The number of data packets retransmitted by the sender.
139 Metric<Packets> lost; // The number of packets reported lost (including repeated reports) to the sender in NAKs.
140 Metric<BytesPackets> dropped; // The number of data packets dropped by the sender.
141
142 Metric<Packets> sentFilterExtra; // The number of packets generate by the packet filter and sent by the sender.
143
144 Metric<Packets> recvdAck; // The number of ACK packets received by the sender.
145 Metric<Packets> recvdNak; // The number of ACK packets received by the sender.
146
147 void reset()
148 {
149 sent.reset();
150 sentUnique.reset();
151 sentRetrans.reset();
152 lost.reset();
153 dropped.reset();
154 recvdAck.reset();
155 recvdNak.reset();
156 sentFilterExtra.reset();
157 }
158
159 void resetTrace()
160 {
161 sent.resetTrace();
162 sentUnique.resetTrace();
163 sentRetrans.resetTrace();
164 lost.resetTrace();
165 dropped.resetTrace();
166 recvdAck.resetTrace();
167 recvdNak.resetTrace();
168 sentFilterExtra.resetTrace();
169 }
170 };
171
172 /// Receiver-side statistics.
173 struct Receiver
174 {
175 Metric<BytesPackets> recvd;
176 Metric<BytesPackets> recvdUnique;
177 Metric<BytesPackets> recvdRetrans; // The number of retransmitted data packets received by the receiver.
178 Metric<BytesPackets> lost; // The number of packets detected by the receiver as lost.
179 Metric<BytesPackets> dropped; // The number of packets dropped by the receiver (as too-late to be delivered).
180 Metric<BytesPackets> recvdBelated; // The number of belated packets received (dropped as too late but eventually received).
181 Metric<BytesPackets> undecrypted; // The number of packets received by the receiver that failed to be decrypted.
182
183 Metric<Packets> recvdFilterExtra; // The number of filter packets (e.g. FEC) received by the receiver.
184 Metric<Packets> suppliedByFilter; // The number of lost packets got from the packet filter at the receiver side (e.g. loss recovered by FEC).
185 Metric<Packets> lossFilter; // The number of lost DATA packets not recovered by the packet filter at the receiver side.
186
187 Metric<Packets> sentAck; // The number of ACK packets sent by the receiver.
188 Metric<Packets> sentNak; // The number of NACK packets sent by the receiver.
189
190 void reset()
191 {
192 recvd.reset();
193 recvdUnique.reset();
194 recvdRetrans.reset();
195 lost.reset();
196 dropped.reset();
197 recvdBelated.reset();
198 undecrypted.reset();
199 recvdFilterExtra.reset();
200 suppliedByFilter.reset();
201 lossFilter.reset();
202 sentAck.reset();
203 sentNak.reset();
204 }
205
206 void resetTrace()
207 {
208 recvd.resetTrace();
209 recvdUnique.resetTrace();
210 recvdRetrans.resetTrace();
211 lost.resetTrace();
212 dropped.resetTrace();
213 recvdBelated.resetTrace();
214 undecrypted.resetTrace();
215 recvdFilterExtra.resetTrace();
216 suppliedByFilter.resetTrace();
217 lossFilter.resetTrace();
218 sentAck.resetTrace();
219 sentNak.resetTrace();
220 }
221 };
222
223 } // namespace stats
224 } // namespace srt
225
226 #endif // INC_SRT_STATS_H
227
228