blob: d809b2b7c6a99a9507fee1eeb965ccdc1db07347 (
plain)
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
|
/*
* Copyright (c) 2021 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <hicn/transport/interfaces/statistics.h>
#include <hicn/transport/utils/noncopyable.h>
#include <protocols/raaqm_data_path.h>
#include <chrono>
namespace transport {
namespace protocol {
class IcnRateEstimator : utils::NonCopyable {
public:
IcnRateEstimator(){};
virtual ~IcnRateEstimator(){};
virtual void onRttUpdate(const utils::SteadyTime::Microseconds &rtt){};
virtual void onDataReceived(int packetSize){};
virtual void onWindowIncrease(double winCurrent){};
virtual void onWindowDecrease(double winCurrent){};
virtual void onStart(){};
virtual void onDownloadFinished(){};
virtual void setObserver(interface::IcnObserver *observer) {
this->observer_ = observer;
};
interface::IcnObserver *observer_;
utils::SteadyTime::TimePoint start_time_;
utils::SteadyTime::TimePoint begin_batch_;
double base_alpha_;
double alpha_;
double estimation_;
int number_of_packets_;
// this boolean is to make sure at least one estimation of the BW is done
bool estimated_;
};
// A rate estimator RTT-based. Computes EWMA(WinSize)/EWMA(RTT)
class InterRttEstimator : public IcnRateEstimator {
public:
InterRttEstimator(double alpha_arg);
~InterRttEstimator();
void onRttUpdate(const utils::SteadyTime::Microseconds &rtt);
void onDataReceived(int packet_size) {
if (packet_size > this->max_packet_size_) {
this->max_packet_size_ = packet_size;
}
};
void onWindowIncrease(double win_current);
void onWindowDecrease(double win_current);
void onStart(){};
void onDownloadFinished(){};
// private: should be done by using getters
pthread_t *my_th_;
bool thread_is_running_;
double rtt_;
bool is_running_;
pthread_mutex_t mutex_;
double avg_rtt_;
double avg_win_;
int max_packet_size_;
double win_change_;
double win_current_;
};
// A rate estimator, Batching Packets based. Computes EWMA(WinSize)/EWMA(RTT)
class BatchingPacketsEstimator : public IcnRateEstimator {
public:
BatchingPacketsEstimator(double alpha_arg, int batchingParam);
void onRttUpdate(const utils::SteadyTime::Microseconds &rtt);
void onDataReceived(int packet_size) {
if (packet_size > this->max_packet_size_) {
this->max_packet_size_ = packet_size;
}
};
void onWindowIncrease(double win_current);
void onWindowDecrease(double win_current);
void onStart(){};
void onDownloadFinished(){};
private:
int batching_param_;
double avg_rtt_;
double avg_win_;
double win_change_;
int max_packet_size_;
double win_current_;
};
// Segment Estimator
class ALaTcpEstimator : public IcnRateEstimator {
public:
ALaTcpEstimator();
void onDataReceived(int packet_size);
void onStart();
void onDownloadFinished();
private:
double totalSize_;
};
// A Rate estimator, this one is the simplest: counting batching_param_ packets
// and then divide the sum of the size of these packets by the time taken to DL
// them. Should be the one used
class SimpleEstimator : public IcnRateEstimator {
public:
SimpleEstimator(double alpha, int batching_param);
void onRttUpdate(const utils::SteadyTime::Microseconds &rtt);
void onDataReceived(int packet_size);
void onWindowIncrease(double win_current){};
void onWindowDecrease(double win_current){};
void onStart();
void onDownloadFinished();
private:
int batching_param_;
double total_size_;
};
void *Timer(void *data);
} // namespace protocol
} // end namespace transport
|
