OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef COMPONENTS_DISCARDABLE_MEMORY_SERVICE_DISCARDABLE_SHARED_MEMORY_MANAGER_ H_ | 5 #ifndef COMPONENTS_DISCARDABLE_MEMORY_SERVICE_DISCARDABLE_SHARED_MEMORY_MANAGER_ H_ |
6 #define COMPONENTS_DISCARDABLE_MEMORY_SERVICE_DISCARDABLE_SHARED_MEMORY_MANAGER_ H_ | 6 #define COMPONENTS_DISCARDABLE_MEMORY_SERVICE_DISCARDABLE_SHARED_MEMORY_MANAGER_ H_ |
7 | 7 |
8 #include <stddef.h> | 8 #include <stddef.h> |
9 #include <stdint.h> | 9 #include <stdint.h> |
10 | 10 |
11 #include <memory> | 11 #include <memory> |
12 #include <vector> | 12 #include <vector> |
13 | 13 |
14 #include "base/callback.h" | 14 #include "base/callback.h" |
15 #include "base/containers/hash_tables.h" | 15 #include "base/containers/hash_tables.h" |
16 #include "base/format_macros.h" | 16 #include "base/format_macros.h" |
17 #include "base/macros.h" | 17 #include "base/macros.h" |
18 #include "base/memory/discardable_memory_allocator.h" | 18 #include "base/memory/discardable_memory_allocator.h" |
19 #include "base/memory/discardable_shared_memory.h" | 19 #include "base/memory/discardable_shared_memory.h" |
20 #include "base/memory/memory_coordinator_client.h" | 20 #include "base/memory/memory_coordinator_client.h" |
21 #include "base/memory/memory_pressure_listener.h" | 21 #include "base/memory/memory_pressure_listener.h" |
22 #include "base/memory/ref_counted.h" | 22 #include "base/memory/ref_counted.h" |
23 #include "base/memory/shared_memory.h" | 23 #include "base/memory/shared_memory.h" |
24 #include "base/memory/weak_ptr.h" | 24 #include "base/memory/weak_ptr.h" |
25 #include "base/process/process_handle.h" | 25 #include "base/process/process_handle.h" |
26 #include "base/synchronization/lock.h" | 26 #include "base/synchronization/lock.h" |
27 #include "base/threading/thread_task_runner_handle.h" | 27 #include "base/threading/thread_task_runner_handle.h" |
28 #include "base/trace_event/memory_dump_provider.h" | 28 #include "base/trace_event/memory_dump_provider.h" |
29 #include "components/discardable_memory/common/discardable_memory_export.h" | 29 #include "components/discardable_memory/common/discardable_memory_export.h" |
30 #include "components/discardable_memory/common/discardable_shared_memory_id.h" | 30 #include "components/discardable_memory/public/interfaces/discardable_shared_mem ory_manager.mojom.h" |
31 | 31 |
32 namespace discardable_memory { | 32 namespace discardable_memory { |
33 | 33 |
34 // Implementation of DiscardableMemoryAllocator that allocates and manages | 34 // Implementation of DiscardableMemoryAllocator that allocates and manages |
35 // discardable memory segments for the process which hosts this class, and | 35 // discardable memory segments for the process which hosts this class, and |
36 // for remote processes which request discardable memory from this class via | 36 // for remote processes which request discardable memory from this class via |
37 // IPC. | 37 // IPC. |
38 // This class is thread-safe and instances can safely be used on any thread. | 38 // This class is thread-safe and instances can safely be used on any thread. |
39 class DISCARDABLE_MEMORY_EXPORT DiscardableSharedMemoryManager | 39 class DISCARDABLE_MEMORY_EXPORT DiscardableSharedMemoryManager |
40 : public base::DiscardableMemoryAllocator, | 40 : public base::DiscardableMemoryAllocator, |
41 public base::trace_event::MemoryDumpProvider, | 41 public base::trace_event::MemoryDumpProvider, |
42 public base::MemoryCoordinatorClient { | 42 public base::MemoryCoordinatorClient { |
43 public: | 43 public: |
44 DiscardableSharedMemoryManager(); | 44 DiscardableSharedMemoryManager(); |
45 ~DiscardableSharedMemoryManager() override; | 45 ~DiscardableSharedMemoryManager() override; |
46 | 46 |
47 // Create a sigleton instance. | |
48 static DiscardableSharedMemoryManager* CreateInstance(); | |
49 | |
47 // Returns a singleton instance. | 50 // Returns a singleton instance. |
48 static DiscardableSharedMemoryManager* current(); | 51 static DiscardableSharedMemoryManager* GetInstance(); |
dcheng
2016/12/02 08:48:54
Nit: let's just combine GetInstance() and CreateIn
Peng
2016/12/02 15:27:36
We added this CreateInstance(), because we need cr
dcheng
2016/12/02 17:51:15
Where is the blocking IO happening?
Peng
2016/12/02 18:51:13
https://cs.chromium.org/chromium/src/components/di
| |
52 | |
53 // Bind the manager to a mojo interface request. | |
54 void Bind(mojom::DiscardableSharedMemoryManagerRequest request); | |
49 | 55 |
50 // Overridden from base::DiscardableMemoryAllocator: | 56 // Overridden from base::DiscardableMemoryAllocator: |
51 std::unique_ptr<base::DiscardableMemory> AllocateLockedDiscardableMemory( | 57 std::unique_ptr<base::DiscardableMemory> AllocateLockedDiscardableMemory( |
52 size_t size) override; | 58 size_t size) override; |
53 | 59 |
54 // Overridden from base::trace_event::MemoryDumpProvider: | 60 // Overridden from base::trace_event::MemoryDumpProvider: |
55 bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args, | 61 bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args, |
56 base::trace_event::ProcessMemoryDump* pmd) override; | 62 base::trace_event::ProcessMemoryDump* pmd) override; |
57 | 63 |
58 // TODO(penghuang): Get ride of the |process_handle| when we switch to mojo. | |
59 // This allocates a discardable memory segment for |process_handle|. | 64 // This allocates a discardable memory segment for |process_handle|. |
60 // A valid shared memory handle is returned on success. | 65 // A valid shared memory handle is returned on success. |
61 void AllocateLockedDiscardableSharedMemoryForClient( | 66 void AllocateLockedDiscardableSharedMemoryForClient( |
62 base::ProcessHandle process_handle, | |
63 int client_id, | 67 int client_id, |
64 size_t size, | 68 size_t size, |
65 DiscardableSharedMemoryId id, | 69 int32_t id, |
66 base::SharedMemoryHandle* shared_memory_handle); | 70 base::SharedMemoryHandle* shared_memory_handle); |
67 | 71 |
68 // Call this to notify the manager that client process associated with | 72 // Call this to notify the manager that client process associated with |
69 // |client_id| has deleted discardable memory segment with |id|. | 73 // |client_id| has deleted discardable memory segment with |id|. |
70 void ClientDeletedDiscardableSharedMemory(DiscardableSharedMemoryId id, | 74 void ClientDeletedDiscardableSharedMemory(int32_t id, int client_id); |
71 int client_id); | |
72 | 75 |
73 // Call this to notify the manager that client associated with |client_id| | 76 // Call this to notify the manager that client associated with |client_id| |
74 // has been removed. The manager will use this to release memory segments | 77 // has been removed. The manager will use this to release memory segments |
75 // allocated for client to the OS. | 78 // allocated for client to the OS. |
76 void ClientRemoved(int client_id); | 79 void ClientRemoved(int client_id); |
77 | 80 |
78 // The maximum number of bytes of memory that may be allocated. This will | 81 // The maximum number of bytes of memory that may be allocated. This will |
79 // cause memory usage to be reduced if currently above |limit|. | 82 // cause memory usage to be reduced if currently above |limit|. |
80 void SetMemoryLimit(size_t limit); | 83 void SetMemoryLimit(size_t limit); |
81 | 84 |
(...skipping 22 matching lines...) Expand all Loading... | |
104 | 107 |
105 static bool CompareMemoryUsageTime(const scoped_refptr<MemorySegment>& a, | 108 static bool CompareMemoryUsageTime(const scoped_refptr<MemorySegment>& a, |
106 const scoped_refptr<MemorySegment>& b) { | 109 const scoped_refptr<MemorySegment>& b) { |
107 // In this system, LRU memory segment is evicted first. | 110 // In this system, LRU memory segment is evicted first. |
108 return a->memory()->last_known_usage() > b->memory()->last_known_usage(); | 111 return a->memory()->last_known_usage() > b->memory()->last_known_usage(); |
109 } | 112 } |
110 | 113 |
111 // base::MemoryCoordinatorClient implementation: | 114 // base::MemoryCoordinatorClient implementation: |
112 void OnMemoryStateChange(base::MemoryState state) override; | 115 void OnMemoryStateChange(base::MemoryState state) override; |
113 | 116 |
114 // TODO(penghuang): Get ride of the |process_handle| when we switch to mojo. | |
115 void AllocateLockedDiscardableSharedMemory( | 117 void AllocateLockedDiscardableSharedMemory( |
116 base::ProcessHandle process_handle, | |
117 int client_id, | 118 int client_id, |
118 size_t size, | 119 size_t size, |
119 DiscardableSharedMemoryId id, | 120 int32_t id, |
120 base::SharedMemoryHandle* shared_memory_handle); | 121 base::SharedMemoryHandle* shared_memory_handle); |
121 void DeletedDiscardableSharedMemory(DiscardableSharedMemoryId id, | 122 void DeletedDiscardableSharedMemory(int32_t id, int client_id); |
122 int client_id); | |
123 void OnMemoryPressure( | 123 void OnMemoryPressure( |
124 base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level); | 124 base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level); |
125 void ReduceMemoryUsageUntilWithinMemoryLimit(); | 125 void ReduceMemoryUsageUntilWithinMemoryLimit(); |
126 void ReduceMemoryUsageUntilWithinLimit(size_t limit); | 126 void ReduceMemoryUsageUntilWithinLimit(size_t limit); |
127 void ReleaseMemory(base::DiscardableSharedMemory* memory); | 127 void ReleaseMemory(base::DiscardableSharedMemory* memory); |
128 void BytesAllocatedChanged(size_t new_bytes_allocated) const; | 128 void BytesAllocatedChanged(size_t new_bytes_allocated) const; |
129 | 129 |
130 // Virtual for tests. | 130 // Virtual for tests. |
131 virtual base::Time Now() const; | 131 virtual base::Time Now() const; |
132 virtual void ScheduleEnforceMemoryPolicy(); | 132 virtual void ScheduleEnforceMemoryPolicy(); |
133 | 133 |
134 int32_t next_client_id_; | |
135 | |
134 base::Lock lock_; | 136 base::Lock lock_; |
135 typedef base::hash_map<DiscardableSharedMemoryId, | 137 using MemorySegmentMap = |
136 scoped_refptr<MemorySegment>> | 138 base::hash_map<int32_t, scoped_refptr<MemorySegment>>; |
137 MemorySegmentMap; | 139 using ClientMap = base::hash_map<int, MemorySegmentMap>; |
138 typedef base::hash_map<int, MemorySegmentMap> ClientMap; | |
139 ClientMap clients_; | 140 ClientMap clients_; |
140 // Note: The elements in |segments_| are arranged in such a way that they form | 141 // Note: The elements in |segments_| are arranged in such a way that they form |
141 // a heap. The LRU memory segment always first. | 142 // a heap. The LRU memory segment always first. |
142 typedef std::vector<scoped_refptr<MemorySegment>> MemorySegmentVector; | 143 using MemorySegmentVector = std::vector<scoped_refptr<MemorySegment>>; |
143 MemorySegmentVector segments_; | 144 MemorySegmentVector segments_; |
144 size_t default_memory_limit_; | 145 size_t default_memory_limit_; |
145 size_t memory_limit_; | 146 size_t memory_limit_; |
146 size_t bytes_allocated_; | 147 size_t bytes_allocated_; |
147 std::unique_ptr<base::MemoryPressureListener> memory_pressure_listener_; | 148 std::unique_ptr<base::MemoryPressureListener> memory_pressure_listener_; |
148 scoped_refptr<base::SingleThreadTaskRunner> | 149 scoped_refptr<base::SingleThreadTaskRunner> |
149 enforce_memory_policy_task_runner_; | 150 enforce_memory_policy_task_runner_; |
150 base::Closure enforce_memory_policy_callback_; | 151 base::Closure enforce_memory_policy_callback_; |
151 bool enforce_memory_policy_pending_; | 152 bool enforce_memory_policy_pending_; |
152 base::WeakPtrFactory<DiscardableSharedMemoryManager> weak_ptr_factory_; | 153 base::WeakPtrFactory<DiscardableSharedMemoryManager> weak_ptr_factory_; |
153 | 154 |
154 DISALLOW_COPY_AND_ASSIGN(DiscardableSharedMemoryManager); | 155 DISALLOW_COPY_AND_ASSIGN(DiscardableSharedMemoryManager); |
155 }; | 156 }; |
156 | 157 |
157 } // namespace discardable_memory | 158 } // namespace discardable_memory |
158 | 159 |
159 #endif // COMPONENTS_DISCARDABLE_MEMORY_SERVICE_DISCARDABLE_SHARED_MEMORY_MANAG ER_H_ | 160 #endif // COMPONENTS_DISCARDABLE_MEMORY_SERVICE_DISCARDABLE_SHARED_MEMORY_MANAG ER_H_ |
OLD | NEW |