OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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 #include "base/memory/discardable_memory_emulated.h" | 5 #include "base/memory/discardable_memory_emulated.h" |
6 | 6 |
7 #include "base/lazy_instance.h" | 7 #include "base/lazy_instance.h" |
8 #include "base/memory/discardable_memory_manager.h" | 8 #include "base/memory/discardable_memory_manager.h" |
9 | 9 |
10 namespace base { | 10 namespace base { |
11 namespace { | 11 namespace { |
12 | 12 |
13 base::LazyInstance<internal::DiscardableMemoryManager>::Leaky g_manager = | 13 // This is admittedly pretty magical. It's approximately enough memory for eight |
14 LAZY_INSTANCE_INITIALIZER; | 14 // 2560x1600 images. |
| 15 const size_t kEmulatedMemoryLimit = 128 * 1024 * 1024; |
| 16 const size_t kEmulatedBytesToKeepUnderModeratePressure = 12 * 1024 * 1024; |
| 17 |
| 18 struct SharedState { |
| 19 SharedState() |
| 20 : manager(kEmulatedMemoryLimit, |
| 21 kEmulatedBytesToKeepUnderModeratePressure) {} |
| 22 |
| 23 internal::DiscardableMemoryManager manager; |
| 24 }; |
| 25 LazyInstance<SharedState>::Leaky g_shared_state = LAZY_INSTANCE_INITIALIZER; |
15 | 26 |
16 } // namespace | 27 } // namespace |
17 | 28 |
18 namespace internal { | 29 namespace internal { |
19 | 30 |
20 DiscardableMemoryEmulated::DiscardableMemoryEmulated(size_t bytes) | 31 DiscardableMemoryEmulated::DiscardableMemoryEmulated(size_t bytes) |
21 : bytes_(bytes), | 32 : bytes_(bytes), |
22 is_locked_(false) { | 33 is_locked_(false) { |
23 g_manager.Pointer()->Register(this, bytes); | 34 g_shared_state.Pointer()->manager.Register(this, bytes); |
24 } | 35 } |
25 | 36 |
26 DiscardableMemoryEmulated::~DiscardableMemoryEmulated() { | 37 DiscardableMemoryEmulated::~DiscardableMemoryEmulated() { |
27 if (is_locked_) | 38 if (is_locked_) |
28 Unlock(); | 39 Unlock(); |
29 g_manager.Pointer()->Unregister(this); | 40 g_shared_state.Pointer()->manager.Unregister(this); |
30 } | 41 } |
31 | 42 |
32 // static | 43 // static |
33 void DiscardableMemoryEmulated::RegisterMemoryPressureListeners() { | 44 void DiscardableMemoryEmulated::RegisterMemoryPressureListeners() { |
34 g_manager.Pointer()->RegisterMemoryPressureListener(); | 45 g_shared_state.Pointer()->manager.RegisterMemoryPressureListener(); |
35 } | 46 } |
36 | 47 |
37 // static | 48 // static |
38 void DiscardableMemoryEmulated::UnregisterMemoryPressureListeners() { | 49 void DiscardableMemoryEmulated::UnregisterMemoryPressureListeners() { |
39 g_manager.Pointer()->UnregisterMemoryPressureListener(); | 50 g_shared_state.Pointer()->manager.UnregisterMemoryPressureListener(); |
40 } | 51 } |
41 | 52 |
42 // static | 53 // static |
43 void DiscardableMemoryEmulated::PurgeForTesting() { | 54 void DiscardableMemoryEmulated::PurgeForTesting() { |
44 g_manager.Pointer()->PurgeAll(); | 55 g_shared_state.Pointer()->manager.PurgeAll(); |
45 } | 56 } |
46 | 57 |
47 bool DiscardableMemoryEmulated::Initialize() { | 58 bool DiscardableMemoryEmulated::Initialize() { |
48 return Lock() == DISCARDABLE_MEMORY_LOCK_STATUS_PURGED; | 59 return Lock() == DISCARDABLE_MEMORY_LOCK_STATUS_PURGED; |
49 } | 60 } |
50 | 61 |
51 DiscardableMemoryLockStatus DiscardableMemoryEmulated::Lock() { | 62 DiscardableMemoryLockStatus DiscardableMemoryEmulated::Lock() { |
52 DCHECK(!is_locked_); | 63 DCHECK(!is_locked_); |
53 | 64 |
54 bool purged = false; | 65 bool purged = false; |
55 if (!g_manager.Pointer()->AcquireLock(this, &purged)) | 66 if (!g_shared_state.Pointer()->manager.AcquireLock(this, &purged)) |
56 return DISCARDABLE_MEMORY_LOCK_STATUS_FAILED; | 67 return DISCARDABLE_MEMORY_LOCK_STATUS_FAILED; |
57 | 68 |
58 is_locked_ = true; | 69 is_locked_ = true; |
59 return purged ? DISCARDABLE_MEMORY_LOCK_STATUS_PURGED | 70 return purged ? DISCARDABLE_MEMORY_LOCK_STATUS_PURGED |
60 : DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS; | 71 : DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS; |
61 } | 72 } |
62 | 73 |
63 void DiscardableMemoryEmulated::Unlock() { | 74 void DiscardableMemoryEmulated::Unlock() { |
64 DCHECK(is_locked_); | 75 DCHECK(is_locked_); |
65 g_manager.Pointer()->ReleaseLock(this); | 76 g_shared_state.Pointer()->manager.ReleaseLock(this); |
66 is_locked_ = false; | 77 is_locked_ = false; |
67 } | 78 } |
68 | 79 |
69 void* DiscardableMemoryEmulated::Memory() const { | 80 void* DiscardableMemoryEmulated::Memory() const { |
70 DCHECK(is_locked_); | 81 DCHECK(is_locked_); |
71 DCHECK(memory_); | 82 DCHECK(memory_); |
72 return memory_.get(); | 83 return memory_.get(); |
73 } | 84 } |
74 | 85 |
75 bool DiscardableMemoryEmulated::AllocateAndAcquireLock() { | 86 bool DiscardableMemoryEmulated::AllocateAndAcquireLock() { |
76 if (memory_) | 87 if (memory_) |
77 return true; | 88 return true; |
78 | 89 |
79 memory_.reset(new uint8[bytes_]); | 90 memory_.reset(new uint8[bytes_]); |
80 return false; | 91 return false; |
81 } | 92 } |
82 | 93 |
83 void DiscardableMemoryEmulated::Purge() { | 94 void DiscardableMemoryEmulated::Purge() { |
84 memory_.reset(); | 95 memory_.reset(); |
85 } | 96 } |
86 | 97 |
87 } // namespace internal | 98 } // namespace internal |
88 } // namespace base | 99 } // namespace base |
OLD | NEW |