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
|
// 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 "components/system_cpu/cpu_probe_mac.h"
#include <stdint.h>
#include <optional>
#include <utility>
#include <vector>
#include "base/check_op.h"
#include "base/memory/ptr_util.h"
#include "base/memory/scoped_refptr.h"
#include "base/sequence_checker.h"
#include "base/task/sequenced_task_runner.h"
#include "base/task/task_traits.h"
#include "base/task/thread_pool.h"
#include "components/system_cpu/core_times.h"
#include "components/system_cpu/cpu_sample.h"
#include "components/system_cpu/host_processor_info_scanner.h"
namespace system_cpu {
// Helper class that performs the actual I/O. It must run on a
// SequencedTaskRunner that is properly configured for blocking I/O
// operations.
class CpuProbeMac::BlockingTaskRunnerHelper final {
public:
BlockingTaskRunnerHelper();
~BlockingTaskRunnerHelper();
BlockingTaskRunnerHelper(const BlockingTaskRunnerHelper&) = delete;
BlockingTaskRunnerHelper& operator=(const BlockingTaskRunnerHelper&) = delete;
std::optional<CpuSample> Update();
private:
// Called when a core is seen the first time.
void InitializeCore(size_t, const CoreTimes&);
SEQUENCE_CHECKER(sequence_checker_);
// Used to derive CPU utilization.
HostProcessorInfoScanner processor_info_scanner_
GUARDED_BY_CONTEXT(sequence_checker_);
// Most recent per-core times.
std::vector<CoreTimes> last_per_core_times_
GUARDED_BY_CONTEXT(sequence_checker_);
};
CpuProbeMac::BlockingTaskRunnerHelper::BlockingTaskRunnerHelper() = default;
CpuProbeMac::BlockingTaskRunnerHelper::~BlockingTaskRunnerHelper() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
}
std::optional<CpuSample> CpuProbeMac::BlockingTaskRunnerHelper::Update() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
processor_info_scanner_.Update();
const std::vector<CoreTimes>& per_core_times =
processor_info_scanner_.core_times();
double utilization_sum = 0.0;
int utilization_cores = 0;
for (size_t i = 0; i < per_core_times.size(); ++i) {
CHECK_GE(last_per_core_times_.size(), i);
const CoreTimes& core_times = per_core_times[i];
if (last_per_core_times_.size() == i) {
InitializeCore(i, core_times);
continue;
}
double core_utilization =
core_times.TimeUtilization(last_per_core_times_[i]);
if (core_utilization >= 0) {
// Only overwrite `last_per_core_times_` if the cpu time counters are
// monotonically increasing. Otherwise, discard the measurement.
last_per_core_times_[i] = core_times;
utilization_sum += core_utilization;
++utilization_cores;
}
}
if (utilization_cores > 0) {
return CpuSample{.cpu_utilization = utilization_sum / utilization_cores};
} else {
return std::nullopt;
}
}
void CpuProbeMac::BlockingTaskRunnerHelper::InitializeCore(
size_t core_index,
const CoreTimes& initial_core_times) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
CHECK_EQ(last_per_core_times_.size(), core_index);
last_per_core_times_.push_back(initial_core_times);
}
// static
std::unique_ptr<CpuProbeMac> CpuProbeMac::Create() {
return base::WrapUnique(new CpuProbeMac());
}
CpuProbeMac::CpuProbeMac() {
helper_ = base::SequenceBound<BlockingTaskRunnerHelper>(
base::ThreadPool::CreateSequencedTaskRunner(
{base::MayBlock(), base::TaskPriority::BEST_EFFORT,
base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN}));
}
CpuProbeMac::~CpuProbeMac() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
}
void CpuProbeMac::Update(SampleCallback callback) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
helper_.AsyncCall(&BlockingTaskRunnerHelper::Update)
.Then(std::move(callback));
}
base::WeakPtr<CpuProbe> CpuProbeMac::GetWeakPtr() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
return weak_factory_.GetWeakPtr();
}
} // namespace system_cpu
|
