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
|
// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_SERVICES_HEAP_PROFILING_CONNECTION_MANAGER_H_
#define COMPONENTS_SERVICES_HEAP_PROFILING_CONNECTION_MANAGER_H_
#include <map>
#include <string>
#include <unordered_map>
#include <vector>
#include "base/containers/flat_map.h"
#include "base/functional/callback_forward.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "base/synchronization/lock.h"
#include "base/threading/thread.h"
#include "base/timer/timer.h"
#include "build/build_config.h"
#include "components/services/heap_profiling/allocation.h"
#include "components/services/heap_profiling/public/mojom/heap_profiling_service.mojom.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "services/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.mojom.h"
namespace heap_profiling {
struct ExportParams;
using VmRegions =
base::flat_map<base::ProcessId,
std::vector<memory_instrumentation::mojom::VmRegionPtr>>;
// Manages all connections and logging for each process. Pipes are supplied by
// the pipe server and this class will connect them to a parser and logger.
//
// Note |backtrace_storage| must outlive ConnectionManager.
//
// This object is constructed on the UI thread, but the rest of the usage
// (including deletion) is on the IO thread.
class ConnectionManager {
using AddressToStringMap = std::unordered_map<uint64_t, std::string>;
using CompleteCallback = base::OnceClosure;
using ContextMap = std::map<std::string, int>;
using DumpProcessesForTracingCallback = memory_instrumentation::mojom::
HeapProfiler::DumpProcessesForTracingCallback;
public:
ConnectionManager();
ConnectionManager(const ConnectionManager&) = delete;
ConnectionManager& operator=(const ConnectionManager&) = delete;
~ConnectionManager();
// Dumping is asynchronous so will not be complete when this function
// returns. The dump is complete when the callback provided in the args is
// fired.
void DumpProcessesForTracing(bool strip_path_from_mapped_files,
bool write_proto,
DumpProcessesForTracingCallback callback,
VmRegions vm_regions);
void OnNewConnection(base::ProcessId pid,
mojo::PendingRemote<mojom::ProfilingClient> client,
mojom::ProcessType process_type,
mojom::ProfilingParamsPtr params,
mojom::ProfilingService::AddProfilingClientCallback
started_profiling_closure);
// Returns pids of clients that have started profiling.
std::vector<base::ProcessId> GetConnectionPids();
// Returns pids of all connected clients that need vm regions, regardless of
// whether they've started profiling.
std::vector<base::ProcessId> GetConnectionPidsThatNeedVmRegions();
private:
struct Connection;
struct DumpProcessesForTracingTracking;
void HeapProfileRetrieved(
scoped_refptr<DumpProcessesForTracingTracking> tracking,
base::ProcessId pid,
mojom::ProcessType process_type,
bool strip_path_from_mapped_files,
uint32_t sampling_rate,
mojom::HeapProfilePtr profile);
bool ConvertProfileToExportParams(mojom::HeapProfilePtr profile,
uint32_t sampling_rate,
ExportParams* out_params);
// Notification that the client has disconnected. Unlike OnNewConnection which
// is signaled by the pipe server, this is signaled by the allocation tracker
// to ensure that the pipeline for this process has been flushed of all
// messages.
void OnConnectionComplete(base::ProcessId pid);
// Indicates that the client has enabled profiling. Necessary for tests to
// know when initialization is complete.
void OnProfilingStarted(base::ProcessId pid);
// Reports the ProcessTypes of the processes being profiled.
void ReportMetrics();
// The next ID to use when exporting a heap dump.
size_t next_id_ = 1;
// Maps process ID to the connection information for it.
base::flat_map<base::ProcessId, std::unique_ptr<Connection>> connections_;
base::Lock connections_lock_;
// Every 24-hours, reports the types of profiled processes.
base::RepeatingTimer metrics_timer_;
// Must be the last.
base::WeakPtrFactory<ConnectionManager> weak_factory_{this};
};
} // namespace heap_profiling
#endif // COMPONENTS_SERVICES_HEAP_PROFILING_CONNECTION_MANAGER_H_
|
