1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
/*
* Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef LOGGING_RTC_EVENT_LOG_RTC_EVENT_PROCESSOR_H_
#define LOGGING_RTC_EVENT_LOG_RTC_EVENT_PROCESSOR_H_
#include <stdint.h>
#include <functional>
#include <memory>
#include <optional>
#include <type_traits>
#include <vector>
#include "logging/rtc_event_log/rtc_event_log_parser.h"
#include "logging/rtc_event_log/rtc_event_processor_order.h"
#include "rtc_base/checks.h"
namespace webrtc {
// This file contains helper class used to process the elements of two or more
// sorted lists in timestamp order. The effect is the same as doing a merge step
// in the merge-sort algorithm but without copying the elements or modifying the
// lists.
namespace event_processor_impl {
// Interface to allow "merging" lists of different types. ProcessNext()
// processes the next unprocessed element in the list. IsEmpty() checks if all
// elements have been processed. GetNextTime returns the timestamp of the next
// unprocessed element.
class ProcessableEventListInterface {
public:
virtual ~ProcessableEventListInterface() = default;
virtual void ProcessNext() = 0;
virtual bool IsEmpty() const = 0;
virtual int64_t GetNextTime() const = 0;
virtual int GetTypeOrder() const = 0;
virtual std::optional<uint16_t> GetTransportSeqNum() const = 0;
virtual int GetInsertionOrder() const = 0;
};
// ProcessableEventList encapsulates a list of events and a function that will
// be applied to each element of the list.
template <typename Iterator, typename T>
class ProcessableEventList : public ProcessableEventListInterface {
public:
ProcessableEventList(Iterator begin,
Iterator end,
std::function<void(const T&)> f,
int type_order,
std::function<std::optional<uint16_t>(const T&)>
transport_seq_num_accessor,
int insertion_order)
: begin_(begin),
end_(end),
f_(f),
type_order_(type_order),
transport_seq_num_accessor_(transport_seq_num_accessor),
insertion_order_(insertion_order) {}
void ProcessNext() override {
RTC_DCHECK(!IsEmpty());
f_(*begin_);
++begin_;
}
bool IsEmpty() const override { return begin_ == end_; }
int64_t GetNextTime() const override {
RTC_DCHECK(!IsEmpty());
return begin_->log_time_us();
}
int GetTypeOrder() const override { return type_order_; }
std::optional<uint16_t> GetTransportSeqNum() const override {
RTC_DCHECK(!IsEmpty());
return transport_seq_num_accessor_(*begin_);
}
int GetInsertionOrder() const override { return insertion_order_; }
private:
Iterator begin_;
Iterator end_;
std::function<void(const T&)> f_;
int type_order_;
std::function<std::optional<uint16_t>(const T&)> transport_seq_num_accessor_;
int insertion_order_;
};
} // namespace event_processor_impl
// Helper class used to "merge" two or more lists of ordered RtcEventLog events
// so that they can be treated as a single ordered list. Since the individual
// lists may have different types, we need to access the lists via pointers to
// the common base class.
//
// Usage example:
// ParsedRtcEventLogNew log;
// auto incoming_handler = [] (LoggedRtcpPacketIncoming elem) { ... };
// auto outgoing_handler = [] (LoggedRtcpPacketOutgoing elem) { ... };
//
// RtcEventProcessor processor;
// processor.AddEvents(log.incoming_rtcp_packets(),
// incoming_handler);
// processor.AddEvents(log.outgoing_rtcp_packets(),
// outgoing_handler);
// processor.ProcessEventsInOrder();
class RtcEventProcessor {
public:
RtcEventProcessor();
~RtcEventProcessor();
// The elements of each list is processed in the index order. To process all
// elements in all lists in timestamp order, each list needs to be sorted in
// timestamp order prior to insertion.
// N.B. `iterable` is not owned by RtcEventProcessor. The caller must ensure
// that the iterable outlives RtcEventProcessor and it must not be modified
// until processing has finished.
template <typename Iterable>
void AddEvents(
const Iterable& iterable,
std::function<void(const typename Iterable::value_type&)> handler) {
using ValueType =
typename std::remove_const<typename Iterable::value_type>::type;
AddEvents(iterable, handler, TieBreaker<ValueType>::type_order,
TieBreaker<ValueType>::transport_seq_num_accessor,
num_insertions_);
}
template <typename Iterable>
void AddEvents(
const Iterable& iterable,
std::function<void(const typename Iterable::value_type&)> handler,
PacketDirection direction) {
using ValueType =
typename std::remove_const<typename Iterable::value_type>::type;
AddEvents(iterable, handler, TieBreaker<ValueType>::type_order(direction),
TieBreaker<ValueType>::transport_seq_num_accessor,
num_insertions_);
}
template <typename Iterable>
void AddEvents(
const Iterable& iterable,
std::function<void(const typename Iterable::value_type&)> handler,
int type_order,
std::function<std::optional<uint16_t>(
const typename Iterable::value_type&)> transport_seq_num_accessor,
int insertion_order) {
if (iterable.begin() == iterable.end())
return;
num_insertions_++;
event_lists_.push_back(
std::make_unique<event_processor_impl::ProcessableEventList<
typename Iterable::const_iterator, typename Iterable::value_type>>(
iterable.begin(), iterable.end(), handler, type_order,
transport_seq_num_accessor, insertion_order));
}
void ProcessEventsInOrder();
private:
using ListPtrType =
std::unique_ptr<event_processor_impl::ProcessableEventListInterface>;
// Comparison function to make `event_lists_` into a min heap.
static bool Cmp(const ListPtrType& a, const ListPtrType& b);
std::vector<ListPtrType> event_lists_;
int num_insertions_ = 0;
};
} // namespace webrtc
#endif // LOGGING_RTC_EVENT_LOG_RTC_EVENT_PROCESSOR_H_
|
