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
|
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef SERVICES_RESOURCE_COORDINATOR_MEMORY_INSTRUMENTATION_COORDINATOR_IMPL_H_
#define SERVICES_RESOURCE_COORDINATOR_MEMORY_INSTRUMENTATION_COORDINATOR_IMPL_H_
#include <list>
#include <map>
#include <set>
#include <unordered_map>
#include "base/memory/ref_counted.h"
#include "base/threading/thread_checker.h"
#include "base/time/time.h"
#include "base/trace_event/memory_dump_request_args.h"
#include "mojo/public/cpp/bindings/binding.h"
#include "mojo/public/cpp/bindings/binding_set.h"
#include "services/resource_coordinator/memory_instrumentation/process_map.h"
#include "services/resource_coordinator/memory_instrumentation/queued_request.h"
#include "services/resource_coordinator/public/cpp/memory_instrumentation/coordinator.h"
#include "services/resource_coordinator/public/cpp/memory_instrumentation/tracing_observer.h"
#include "services/resource_coordinator/public/interfaces/memory_instrumentation/memory_instrumentation.mojom.h"
#include "services/service_manager/public/cpp/identity.h"
namespace service_manager {
struct BindSourceInfo;
class Connector;
}
namespace memory_instrumentation {
// Memory instrumentation service. It serves two purposes:
// - Handles a registry of the processes that have a memory instrumentation
// client library instance (../../public/cpp/memory).
// - Provides global (i.e. for all processes) memory snapshots on demand.
// Global snapshots are obtained by requesting in-process snapshots from each
// registered client and aggregating them.
class CoordinatorImpl : public Coordinator,
public mojom::Coordinator,
public mojom::HeapProfilerHelper {
public:
// The getter of the unique instance.
static CoordinatorImpl* GetInstance();
CoordinatorImpl(service_manager::Connector* connector);
// Binds a client library to this coordinator instance.
void BindCoordinatorRequest(
mojom::CoordinatorRequest,
const service_manager::BindSourceInfo& source_info) override;
void BindHeapProfilerHelperRequest(
mojom::HeapProfilerHelperRequest request,
const service_manager::BindSourceInfo& source_info);
// mojom::Coordinator implementation.
void RegisterClientProcess(mojom::ClientProcessPtr,
mojom::ProcessType) override;
void UnregisterClientProcess(mojom::ClientProcess*);
void RequestGlobalMemoryDump(
base::trace_event::MemoryDumpType,
base::trace_event::MemoryDumpLevelOfDetail,
const std::vector<std::string>& allocator_dump_names,
const RequestGlobalMemoryDumpCallback&) override;
void RequestGlobalMemoryDumpForPid(
base::ProcessId,
const RequestGlobalMemoryDumpForPidCallback&) override;
void RequestGlobalMemoryDumpAndAppendToTrace(
base::trace_event::MemoryDumpType,
base::trace_event::MemoryDumpLevelOfDetail,
const RequestGlobalMemoryDumpAndAppendToTraceCallback&) override;
// mojom::HeapProfilerHelper implementation.
void GetVmRegionsForHeapProfiler(
const GetVmRegionsForHeapProfilerCallback&) override;
protected:
// virtual for testing.
virtual service_manager::Identity GetClientIdentityForCurrentRequest() const;
// virtual for testing.
virtual base::ProcessId GetProcessIdForClientIdentity(
service_manager::Identity identity) const;
~CoordinatorImpl() override;
private:
using OSMemDumpMap =
std::unordered_map<base::ProcessId, mojom::RawOSMemDumpPtr>;
using RequestGlobalMemoryDumpInternalCallback =
base::Callback<void(bool, uint64_t, mojom::GlobalMemoryDumpPtr)>;
friend std::default_delete<CoordinatorImpl>; // For testing
friend class CoordinatorImplTest; // For testing
// Holds the identity and remote reference of registered clients.
struct ClientInfo {
ClientInfo(const service_manager::Identity&,
mojom::ClientProcessPtr,
mojom::ProcessType);
~ClientInfo();
const service_manager::Identity identity;
const mojom::ClientProcessPtr client;
const mojom::ProcessType process_type;
};
void RequestGlobalMemoryDumpInternal(
const QueuedRequest::Args& args,
const RequestGlobalMemoryDumpInternalCallback& callback);
// Callback of RequestChromeMemoryDump.
void OnChromeMemoryDumpResponse(
mojom::ClientProcess*,
bool success,
uint64_t dump_guid,
std::unique_ptr<base::trace_event::ProcessMemoryDump> chrome_memory_dump);
// Callback of RequestOSMemoryDump.
void OnOSMemoryDumpResponse(uint64_t dump_guid,
mojom::ClientProcess*,
bool success,
OSMemDumpMap);
void RemovePendingResponse(mojom::ClientProcess*,
QueuedRequest::PendingResponse::Type);
void OnQueuedRequestTimedOut(uint64_t dump_guid);
void PerformNextQueuedGlobalMemoryDump();
void FinalizeGlobalMemoryDumpIfAllManagersReplied();
QueuedRequest* GetCurrentRequest();
void set_client_process_timeout(base::TimeDelta client_process_timeout) {
client_process_timeout_ = client_process_timeout;
}
// Map of registered client processes.
std::map<mojom::ClientProcess*, std::unique_ptr<ClientInfo>> clients_;
// Outstanding dump requests, enqueued via RequestGlobalMemoryDump().
std::list<QueuedRequest> queued_memory_dump_requests_;
// There may be extant callbacks in |queued_memory_dump_requests_|. The
// bindings_ must be closed before destroying the un-run callbacks.
mojo::BindingSet<mojom::Coordinator, service_manager::Identity> bindings_;
// There may be extant callbacks in |queued_memory_dump_requests_|. The
// bindings_ must be closed before destroying the un-run callbacks.
mojo::BindingSet<mojom::HeapProfilerHelper, service_manager::Identity>
bindings_heap_profiler_helper_;
// Maintains a map of service_manager::Identity -> pid for registered clients.
std::unique_ptr<ProcessMap> process_map_;
uint64_t next_dump_id_;
std::unique_ptr<TracingObserver> tracing_observer_;
// Timeout for registered client processes to respond to dump requests.
base::TimeDelta client_process_timeout_;
THREAD_CHECKER(thread_checker_);
DISALLOW_COPY_AND_ASSIGN(CoordinatorImpl);
};
} // namespace memory_instrumentation
#endif // SERVICES_RESOURCE_COORDINATOR_MEMORY_INSTRUMENTATION_COORDINATOR_IMPL_H_
|
