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 CONTENT_COMMON_HOST_DISCARDABLE_SHARED_MEMORY_MANAGER_H_ | 5 #ifndef COMPONENTS_DISCARDABLE_MEMORY_SERVICE_DISCARDABLE_SHARED_MEMORY_MANAGER_
H_ |
6 #define CONTENT_COMMON_HOST_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 "content/common/content_export.h" | 29 #include "components/discardable_memory/common/discardable_memory_export.h" |
| 30 #include "components/discardable_memory/common/discardable_shared_memory_id.h" |
30 | 31 |
31 namespace content { | 32 namespace discardable_memory { |
32 typedef int32_t DiscardableSharedMemoryId; | |
33 | 33 |
34 // Implementation of DiscardableMemoryAllocator that allocates and manages | 34 // Implementation of DiscardableMemoryAllocator that allocates and manages |
35 // discardable memory segments for the browser process and child processes. | 35 // discardable memory segments for the process which hosts this class, and |
| 36 // for remote processes which request discardable memory from this class via |
| 37 // IPC. |
36 // 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. |
37 class CONTENT_EXPORT HostDiscardableSharedMemoryManager | 39 class DISCARDABLE_MEMORY_EXPORT DiscardableSharedMemoryManager |
38 : public base::DiscardableMemoryAllocator, | 40 : public base::DiscardableMemoryAllocator, |
39 public base::trace_event::MemoryDumpProvider, | 41 public base::trace_event::MemoryDumpProvider, |
40 public base::MemoryCoordinatorClient { | 42 public base::MemoryCoordinatorClient { |
41 public: | 43 public: |
42 HostDiscardableSharedMemoryManager(); | 44 DiscardableSharedMemoryManager(); |
43 ~HostDiscardableSharedMemoryManager() override; | 45 ~DiscardableSharedMemoryManager() override; |
44 | 46 |
45 // Returns a singleton instance. | 47 // Returns a singleton instance. |
46 static HostDiscardableSharedMemoryManager* current(); | 48 static DiscardableSharedMemoryManager* current(); |
47 | 49 |
48 // Overridden from base::DiscardableMemoryAllocator: | 50 // Overridden from base::DiscardableMemoryAllocator: |
49 std::unique_ptr<base::DiscardableMemory> AllocateLockedDiscardableMemory( | 51 std::unique_ptr<base::DiscardableMemory> AllocateLockedDiscardableMemory( |
50 size_t size) override; | 52 size_t size) override; |
51 | 53 |
52 // Overridden from base::trace_event::MemoryDumpProvider: | 54 // Overridden from base::trace_event::MemoryDumpProvider: |
53 bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args, | 55 bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args, |
54 base::trace_event::ProcessMemoryDump* pmd) override; | 56 base::trace_event::ProcessMemoryDump* pmd) override; |
55 | 57 |
| 58 // TODO(penghuang): Get ride of the |process_handle| when we switch to mojo. |
56 // This allocates a discardable memory segment for |process_handle|. | 59 // This allocates a discardable memory segment for |process_handle|. |
57 // A valid shared memory handle is returned on success. | 60 // A valid shared memory handle is returned on success. |
58 void AllocateLockedDiscardableSharedMemoryForChild( | 61 void AllocateLockedDiscardableSharedMemoryForClient( |
59 base::ProcessHandle process_handle, | 62 base::ProcessHandle process_handle, |
60 int child_process_id, | 63 int client_id, |
61 size_t size, | 64 size_t size, |
62 DiscardableSharedMemoryId id, | 65 DiscardableSharedMemoryId id, |
63 base::SharedMemoryHandle* shared_memory_handle); | 66 base::SharedMemoryHandle* shared_memory_handle); |
64 | 67 |
65 // Call this to notify the manager that child process associated with | 68 // Call this to notify the manager that client process associated with |
66 // |child_process_id| has deleted discardable memory segment with |id|. | 69 // |client_id| has deleted discardable memory segment with |id|. |
67 void ChildDeletedDiscardableSharedMemory(DiscardableSharedMemoryId id, | 70 void ClientDeletedDiscardableSharedMemory(DiscardableSharedMemoryId id, |
68 int child_process_id); | 71 int client_id); |
69 | 72 |
70 // Call this to notify the manager that child process associated with | 73 // Call this to notify the manager that client associated with |client_id| |
71 // |child_process_id| has been removed. The manager will use this to release | 74 // has been removed. The manager will use this to release memory segments |
72 // memory segments allocated for child process to the OS. | 75 // allocated for client to the OS. |
73 void ProcessRemoved(int child_process_id); | 76 void ClientRemoved(int client_id); |
74 | 77 |
75 // The maximum number of bytes of memory that may be allocated. This will | 78 // The maximum number of bytes of memory that may be allocated. This will |
76 // cause memory usage to be reduced if currently above |limit|. | 79 // cause memory usage to be reduced if currently above |limit|. |
77 void SetMemoryLimit(size_t limit); | 80 void SetMemoryLimit(size_t limit); |
78 | 81 |
79 // Reduce memory usage if above current memory limit. | 82 // Reduce memory usage if above current memory limit. |
80 void EnforceMemoryPolicy(); | 83 void EnforceMemoryPolicy(); |
81 | 84 |
82 // Returns bytes of allocated discardable memory. | 85 // Returns bytes of allocated discardable memory. |
83 size_t GetBytesAllocated(); | 86 size_t GetBytesAllocated(); |
(...skipping 17 matching lines...) Expand all Loading... |
101 | 104 |
102 static bool CompareMemoryUsageTime(const scoped_refptr<MemorySegment>& a, | 105 static bool CompareMemoryUsageTime(const scoped_refptr<MemorySegment>& a, |
103 const scoped_refptr<MemorySegment>& b) { | 106 const scoped_refptr<MemorySegment>& b) { |
104 // In this system, LRU memory segment is evicted first. | 107 // In this system, LRU memory segment is evicted first. |
105 return a->memory()->last_known_usage() > b->memory()->last_known_usage(); | 108 return a->memory()->last_known_usage() > b->memory()->last_known_usage(); |
106 } | 109 } |
107 | 110 |
108 // base::MemoryCoordinatorClient implementation: | 111 // base::MemoryCoordinatorClient implementation: |
109 void OnMemoryStateChange(base::MemoryState state) override; | 112 void OnMemoryStateChange(base::MemoryState state) override; |
110 | 113 |
| 114 // TODO(penghuang): Get ride of the |process_handle| when we switch to mojo. |
111 void AllocateLockedDiscardableSharedMemory( | 115 void AllocateLockedDiscardableSharedMemory( |
112 base::ProcessHandle process_handle, | 116 base::ProcessHandle process_handle, |
113 int client_process_id, | 117 int client_id, |
114 size_t size, | 118 size_t size, |
115 DiscardableSharedMemoryId id, | 119 DiscardableSharedMemoryId id, |
116 base::SharedMemoryHandle* shared_memory_handle); | 120 base::SharedMemoryHandle* shared_memory_handle); |
117 void DeletedDiscardableSharedMemory(DiscardableSharedMemoryId id, | 121 void DeletedDiscardableSharedMemory(DiscardableSharedMemoryId id, |
118 int client_process_id); | 122 int client_id); |
119 void OnMemoryPressure( | 123 void OnMemoryPressure( |
120 base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level); | 124 base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level); |
121 void ReduceMemoryUsageUntilWithinMemoryLimit(); | 125 void ReduceMemoryUsageUntilWithinMemoryLimit(); |
122 void ReduceMemoryUsageUntilWithinLimit(size_t limit); | 126 void ReduceMemoryUsageUntilWithinLimit(size_t limit); |
123 void ReleaseMemory(base::DiscardableSharedMemory* memory); | 127 void ReleaseMemory(base::DiscardableSharedMemory* memory); |
124 void BytesAllocatedChanged(size_t new_bytes_allocated) const; | 128 void BytesAllocatedChanged(size_t new_bytes_allocated) const; |
125 | 129 |
126 // Virtual for tests. | 130 // Virtual for tests. |
127 virtual base::Time Now() const; | 131 virtual base::Time Now() const; |
128 virtual void ScheduleEnforceMemoryPolicy(); | 132 virtual void ScheduleEnforceMemoryPolicy(); |
129 | 133 |
130 base::Lock lock_; | 134 base::Lock lock_; |
131 typedef base::hash_map<DiscardableSharedMemoryId, | 135 typedef base::hash_map<DiscardableSharedMemoryId, |
132 scoped_refptr<MemorySegment>> MemorySegmentMap; | 136 scoped_refptr<MemorySegment>> |
133 typedef base::hash_map<int, MemorySegmentMap> ProcessMap; | 137 MemorySegmentMap; |
134 ProcessMap processes_; | 138 typedef base::hash_map<int, MemorySegmentMap> ClientMap; |
| 139 ClientMap clients_; |
135 // Note: The elements in |segments_| are arranged in such a way that they form | 140 // Note: The elements in |segments_| are arranged in such a way that they form |
136 // a heap. The LRU memory segment always first. | 141 // a heap. The LRU memory segment always first. |
137 typedef std::vector<scoped_refptr<MemorySegment>> MemorySegmentVector; | 142 typedef std::vector<scoped_refptr<MemorySegment>> MemorySegmentVector; |
138 MemorySegmentVector segments_; | 143 MemorySegmentVector segments_; |
139 size_t default_memory_limit_; | 144 size_t default_memory_limit_; |
140 size_t memory_limit_; | 145 size_t memory_limit_; |
141 size_t bytes_allocated_; | 146 size_t bytes_allocated_; |
142 std::unique_ptr<base::MemoryPressureListener> memory_pressure_listener_; | 147 std::unique_ptr<base::MemoryPressureListener> memory_pressure_listener_; |
143 scoped_refptr<base::SingleThreadTaskRunner> | 148 scoped_refptr<base::SingleThreadTaskRunner> |
144 enforce_memory_policy_task_runner_; | 149 enforce_memory_policy_task_runner_; |
145 base::Closure enforce_memory_policy_callback_; | 150 base::Closure enforce_memory_policy_callback_; |
146 bool enforce_memory_policy_pending_; | 151 bool enforce_memory_policy_pending_; |
147 base::WeakPtrFactory<HostDiscardableSharedMemoryManager> weak_ptr_factory_; | 152 base::WeakPtrFactory<DiscardableSharedMemoryManager> weak_ptr_factory_; |
148 | 153 |
149 DISALLOW_COPY_AND_ASSIGN(HostDiscardableSharedMemoryManager); | 154 DISALLOW_COPY_AND_ASSIGN(DiscardableSharedMemoryManager); |
150 }; | 155 }; |
151 | 156 |
152 } // namespace content | 157 } // namespace discardable_memory |
153 | 158 |
154 #endif // CONTENT_COMMON_HOST_DISCARDABLE_SHARED_MEMORY_MANAGER_H_ | 159 #endif // COMPONENTS_DISCARDABLE_MEMORY_SERVICE_DISCARDABLE_SHARED_MEMORY_MANAG
ER_H_ |
OLD | NEW |