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
|
// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/platform/peerconnection/linear_histogram.h"
#include <cmath>
#include "base/check.h"
#include "base/check_op.h"
namespace blink {
LinearHistogram::LinearHistogram(float min_value,
float max_value,
wtf_size_t number_of_buckets)
: min_value_(min_value),
resolution_((max_value - min_value) / number_of_buckets),
buckets_(number_of_buckets + 2) {
DCHECK_GT(number_of_buckets, 0u);
DCHECK_GT(max_value, min_value);
}
void LinearHistogram::Add(float value) {
wtf_size_t ix = 0;
if (value > min_value_) {
ix = std::ceil((value - min_value_) / resolution_);
ix = std::min(ix, buckets_.size() - 1);
}
DCHECK_GE(ix, 0u);
DCHECK_LT(ix, buckets_.size());
++buckets_[ix];
++count_;
if (value > max_observed_value_) {
max_observed_value_ = value;
}
}
float LinearHistogram::GetPercentile(float probability) const {
DCHECK_GT(probability, 0.f);
DCHECK_LE(probability, 1.f);
DCHECK_GT(count_, 0ul);
wtf_size_t bucket = 0;
float accumulated_probability = 0;
while (accumulated_probability < probability && bucket < buckets_.size()) {
accumulated_probability += static_cast<float>(buckets_[bucket]) / count_;
++bucket;
}
if (bucket < buckets_.size()) {
return min_value_ + (bucket - 1) * resolution_;
} else {
// Return the maximum observed value if we end up in the overflow bucket.
return max_observed_value_;
}
}
wtf_size_t LinearHistogram::NumValues() const {
return count_;
}
} // namespace blink
|
