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 #include "content/common/discardable_shared_memory_heap.h" | 5 #include "content/common/discardable_shared_memory_heap.h" |
6 | 6 |
| 7 #include "base/bind.h" |
7 #include "base/memory/discardable_shared_memory.h" | 8 #include "base/memory/discardable_shared_memory.h" |
8 #include "base/process/process_metrics.h" | 9 #include "base/process/process_metrics.h" |
9 #include "testing/gtest/include/gtest/gtest.h" | 10 #include "testing/gtest/include/gtest/gtest.h" |
10 | 11 |
11 namespace content { | 12 namespace content { |
12 namespace { | 13 namespace { |
13 | 14 |
| 15 void NullTask() { |
| 16 } |
| 17 |
14 TEST(DiscardableSharedMemoryHeapTest, Basic) { | 18 TEST(DiscardableSharedMemoryHeapTest, Basic) { |
15 size_t block_size = base::GetPageSize(); | 19 size_t block_size = base::GetPageSize(); |
16 DiscardableSharedMemoryHeap heap(block_size); | 20 DiscardableSharedMemoryHeap heap(block_size); |
17 | 21 |
18 // Initial size should be 0. | 22 // Initial size should be 0. |
19 EXPECT_EQ(0u, heap.GetSize()); | 23 EXPECT_EQ(0u, heap.GetSize()); |
20 | 24 |
21 // Initial size of free lists should be 0. | 25 // Initial size of free lists should be 0. |
22 EXPECT_EQ(0u, heap.GetSizeOfFreeLists()); | 26 EXPECT_EQ(0u, heap.GetSizeOfFreeLists()); |
23 | 27 |
24 // Free lists are initially empty. | 28 // Free lists are initially empty. |
25 EXPECT_FALSE(heap.SearchFreeLists(1, 0)); | 29 EXPECT_FALSE(heap.SearchFreeLists(1, 0)); |
26 | 30 |
27 const size_t kBlocks = 10; | 31 const size_t kBlocks = 10; |
28 size_t memory_size = block_size * kBlocks; | 32 size_t memory_size = block_size * kBlocks; |
29 | 33 |
30 scoped_ptr<base::DiscardableSharedMemory> memory( | 34 scoped_ptr<base::DiscardableSharedMemory> memory( |
31 new base::DiscardableSharedMemory); | 35 new base::DiscardableSharedMemory); |
32 ASSERT_TRUE(memory->CreateAndMap(memory_size)); | 36 ASSERT_TRUE(memory->CreateAndMap(memory_size)); |
33 | 37 |
34 // Create new span for memory. | 38 // Create new span for memory. |
35 scoped_ptr<DiscardableSharedMemoryHeap::Span> new_span( | 39 scoped_ptr<DiscardableSharedMemoryHeap::Span> new_span( |
36 heap.Grow(memory.Pass(), memory_size)); | 40 heap.Grow(memory.Pass(), memory_size, base::Bind(NullTask))); |
37 | 41 |
38 // Size should match |memory_size|. | 42 // Size should match |memory_size|. |
39 EXPECT_EQ(memory_size, heap.GetSize()); | 43 EXPECT_EQ(memory_size, heap.GetSize()); |
40 | 44 |
41 // Size of free lists should still be 0. | 45 // Size of free lists should still be 0. |
42 EXPECT_EQ(0u, heap.GetSizeOfFreeLists()); | 46 EXPECT_EQ(0u, heap.GetSizeOfFreeLists()); |
43 | 47 |
44 // Free list should still be empty as |new_span| is currently in use. | 48 // Free list should still be empty as |new_span| is currently in use. |
45 EXPECT_FALSE(heap.SearchFreeLists(1, 0)); | 49 EXPECT_FALSE(heap.SearchFreeLists(1, 0)); |
46 | 50 |
(...skipping 22 matching lines...) Expand all Loading... |
69 size_t block_size = base::GetPageSize(); | 73 size_t block_size = base::GetPageSize(); |
70 DiscardableSharedMemoryHeap heap(block_size); | 74 DiscardableSharedMemoryHeap heap(block_size); |
71 | 75 |
72 const size_t kBlocks = 6; | 76 const size_t kBlocks = 6; |
73 size_t memory_size = block_size * kBlocks; | 77 size_t memory_size = block_size * kBlocks; |
74 | 78 |
75 scoped_ptr<base::DiscardableSharedMemory> memory( | 79 scoped_ptr<base::DiscardableSharedMemory> memory( |
76 new base::DiscardableSharedMemory); | 80 new base::DiscardableSharedMemory); |
77 ASSERT_TRUE(memory->CreateAndMap(memory_size)); | 81 ASSERT_TRUE(memory->CreateAndMap(memory_size)); |
78 scoped_ptr<DiscardableSharedMemoryHeap::Span> new_span( | 82 scoped_ptr<DiscardableSharedMemoryHeap::Span> new_span( |
79 heap.Grow(memory.Pass(), memory_size)); | 83 heap.Grow(memory.Pass(), memory_size, base::Bind(NullTask))); |
80 | 84 |
81 // Split span into two. | 85 // Split span into two. |
82 scoped_ptr<DiscardableSharedMemoryHeap::Span> leftover = | 86 scoped_ptr<DiscardableSharedMemoryHeap::Span> leftover = |
83 heap.Split(new_span.get(), 3); | 87 heap.Split(new_span.get(), 3); |
84 ASSERT_TRUE(leftover); | 88 ASSERT_TRUE(leftover); |
85 | 89 |
86 // Merge |leftover| into free lists. | 90 // Merge |leftover| into free lists. |
87 heap.MergeIntoFreeLists(leftover.Pass()); | 91 heap.MergeIntoFreeLists(leftover.Pass()); |
88 | 92 |
89 // Some of the memory is still in use. | 93 // Some of the memory is still in use. |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
124 size_t block_size = base::GetPageSize(); | 128 size_t block_size = base::GetPageSize(); |
125 DiscardableSharedMemoryHeap heap(block_size); | 129 DiscardableSharedMemoryHeap heap(block_size); |
126 | 130 |
127 const size_t kBlocks = 6; | 131 const size_t kBlocks = 6; |
128 size_t memory_size = block_size * kBlocks; | 132 size_t memory_size = block_size * kBlocks; |
129 | 133 |
130 scoped_ptr<base::DiscardableSharedMemory> memory( | 134 scoped_ptr<base::DiscardableSharedMemory> memory( |
131 new base::DiscardableSharedMemory); | 135 new base::DiscardableSharedMemory); |
132 ASSERT_TRUE(memory->CreateAndMap(memory_size)); | 136 ASSERT_TRUE(memory->CreateAndMap(memory_size)); |
133 scoped_ptr<DiscardableSharedMemoryHeap::Span> new_span( | 137 scoped_ptr<DiscardableSharedMemoryHeap::Span> new_span( |
134 heap.Grow(memory.Pass(), memory_size)); | 138 heap.Grow(memory.Pass(), memory_size, base::Bind(NullTask))); |
135 | 139 |
136 // Split span into two. | 140 // Split span into two. |
137 scoped_ptr<DiscardableSharedMemoryHeap::Span> leftover = | 141 scoped_ptr<DiscardableSharedMemoryHeap::Span> leftover = |
138 heap.Split(new_span.get(), 5); | 142 heap.Split(new_span.get(), 5); |
139 ASSERT_TRUE(leftover); | 143 ASSERT_TRUE(leftover); |
140 | 144 |
141 // Merge |new_span| into free lists. | 145 // Merge |new_span| into free lists. |
142 heap.MergeIntoFreeLists(new_span.Pass()); | 146 heap.MergeIntoFreeLists(new_span.Pass()); |
143 | 147 |
144 // Merge |leftover| into free lists. | 148 // Merge |leftover| into free lists. |
145 heap.MergeIntoFreeLists(leftover.Pass()); | 149 heap.MergeIntoFreeLists(leftover.Pass()); |
146 } | 150 } |
147 | 151 |
148 TEST(DiscardableSharedMemoryHeapTest, Grow) { | 152 TEST(DiscardableSharedMemoryHeapTest, Grow) { |
149 size_t block_size = base::GetPageSize(); | 153 size_t block_size = base::GetPageSize(); |
150 DiscardableSharedMemoryHeap heap(block_size); | 154 DiscardableSharedMemoryHeap heap(block_size); |
151 | 155 |
152 scoped_ptr<base::DiscardableSharedMemory> memory1( | 156 scoped_ptr<base::DiscardableSharedMemory> memory1( |
153 new base::DiscardableSharedMemory); | 157 new base::DiscardableSharedMemory); |
154 ASSERT_TRUE(memory1->CreateAndMap(block_size)); | 158 ASSERT_TRUE(memory1->CreateAndMap(block_size)); |
155 heap.MergeIntoFreeLists(heap.Grow(memory1.Pass(), block_size).Pass()); | 159 heap.MergeIntoFreeLists( |
| 160 heap.Grow(memory1.Pass(), block_size, base::Bind(NullTask)).Pass()); |
156 | 161 |
157 // Remove a span from free lists. | 162 // Remove a span from free lists. |
158 scoped_ptr<DiscardableSharedMemoryHeap::Span> span1 = | 163 scoped_ptr<DiscardableSharedMemoryHeap::Span> span1 = |
159 heap.SearchFreeLists(1, 0); | 164 heap.SearchFreeLists(1, 0); |
160 EXPECT_TRUE(span1); | 165 EXPECT_TRUE(span1); |
161 | 166 |
162 // No more memory available. | 167 // No more memory available. |
163 EXPECT_FALSE(heap.SearchFreeLists(1, 0)); | 168 EXPECT_FALSE(heap.SearchFreeLists(1, 0)); |
164 | 169 |
165 // Grow free lists using new memory. | 170 // Grow free lists using new memory. |
166 scoped_ptr<base::DiscardableSharedMemory> memory2( | 171 scoped_ptr<base::DiscardableSharedMemory> memory2( |
167 new base::DiscardableSharedMemory); | 172 new base::DiscardableSharedMemory); |
168 ASSERT_TRUE(memory2->CreateAndMap(block_size)); | 173 ASSERT_TRUE(memory2->CreateAndMap(block_size)); |
169 heap.MergeIntoFreeLists(heap.Grow(memory2.Pass(), block_size).Pass()); | 174 heap.MergeIntoFreeLists( |
| 175 heap.Grow(memory2.Pass(), block_size, base::Bind(NullTask)).Pass()); |
170 | 176 |
171 // Memory should now be available. | 177 // Memory should now be available. |
172 scoped_ptr<DiscardableSharedMemoryHeap::Span> span2 = | 178 scoped_ptr<DiscardableSharedMemoryHeap::Span> span2 = |
173 heap.SearchFreeLists(1, 0); | 179 heap.SearchFreeLists(1, 0); |
174 EXPECT_TRUE(span2); | 180 EXPECT_TRUE(span2); |
175 | 181 |
176 // Merge spans into the free lists again. | 182 // Merge spans into the free lists again. |
177 heap.MergeIntoFreeLists(span1.Pass()); | 183 heap.MergeIntoFreeLists(span1.Pass()); |
178 heap.MergeIntoFreeLists(span2.Pass()); | 184 heap.MergeIntoFreeLists(span2.Pass()); |
179 } | 185 } |
180 | 186 |
181 TEST(DiscardableSharedMemoryHeapTest, ReleaseFreeMemory) { | 187 TEST(DiscardableSharedMemoryHeapTest, ReleaseFreeMemory) { |
182 size_t block_size = base::GetPageSize(); | 188 size_t block_size = base::GetPageSize(); |
183 DiscardableSharedMemoryHeap heap(block_size); | 189 DiscardableSharedMemoryHeap heap(block_size); |
184 | 190 |
185 scoped_ptr<base::DiscardableSharedMemory> memory( | 191 scoped_ptr<base::DiscardableSharedMemory> memory( |
186 new base::DiscardableSharedMemory); | 192 new base::DiscardableSharedMemory); |
187 ASSERT_TRUE(memory->CreateAndMap(block_size)); | 193 ASSERT_TRUE(memory->CreateAndMap(block_size)); |
188 scoped_ptr<DiscardableSharedMemoryHeap::Span> span = | 194 scoped_ptr<DiscardableSharedMemoryHeap::Span> span = |
189 heap.Grow(memory.Pass(), block_size); | 195 heap.Grow(memory.Pass(), block_size, base::Bind(NullTask)); |
190 | 196 |
191 // Free lists should be empty. | 197 // Free lists should be empty. |
192 EXPECT_EQ(0u, heap.GetSizeOfFreeLists()); | 198 EXPECT_EQ(0u, heap.GetSizeOfFreeLists()); |
193 | 199 |
194 heap.ReleaseFreeMemory(); | 200 heap.ReleaseFreeMemory(); |
195 | 201 |
196 // Size should still match |block_size|. | 202 // Size should still match |block_size|. |
197 EXPECT_EQ(block_size, heap.GetSize()); | 203 EXPECT_EQ(block_size, heap.GetSize()); |
198 | 204 |
199 heap.MergeIntoFreeLists(span.Pass()); | 205 heap.MergeIntoFreeLists(span.Pass()); |
200 heap.ReleaseFreeMemory(); | 206 heap.ReleaseFreeMemory(); |
201 | 207 |
202 // Memory should have been released. | 208 // Memory should have been released. |
203 EXPECT_EQ(0u, heap.GetSize()); | 209 EXPECT_EQ(0u, heap.GetSize()); |
204 EXPECT_EQ(0u, heap.GetSizeOfFreeLists()); | 210 EXPECT_EQ(0u, heap.GetSizeOfFreeLists()); |
205 } | 211 } |
206 | 212 |
207 TEST(DiscardableSharedMemoryHeapTest, ReleasePurgedMemory) { | 213 TEST(DiscardableSharedMemoryHeapTest, ReleasePurgedMemory) { |
208 size_t block_size = base::GetPageSize(); | 214 size_t block_size = base::GetPageSize(); |
209 DiscardableSharedMemoryHeap heap(block_size); | 215 DiscardableSharedMemoryHeap heap(block_size); |
210 | 216 |
211 scoped_ptr<base::DiscardableSharedMemory> memory( | 217 scoped_ptr<base::DiscardableSharedMemory> memory( |
212 new base::DiscardableSharedMemory); | 218 new base::DiscardableSharedMemory); |
213 ASSERT_TRUE(memory->CreateAndMap(block_size)); | 219 ASSERT_TRUE(memory->CreateAndMap(block_size)); |
214 scoped_ptr<DiscardableSharedMemoryHeap::Span> span = | 220 scoped_ptr<DiscardableSharedMemoryHeap::Span> span = |
215 heap.Grow(memory.Pass(), block_size); | 221 heap.Grow(memory.Pass(), block_size, base::Bind(NullTask)); |
216 | 222 |
217 // Unlock memory so it can be purged. | 223 // Unlock memory so it can be purged. |
218 span->shared_memory()->Unlock(0, 0); | 224 span->shared_memory()->Unlock(0, 0); |
219 | 225 |
220 // Purge and release shared memory. | 226 // Purge and release shared memory. |
221 bool rv = span->shared_memory()->Purge(base::Time::Now()); | 227 bool rv = span->shared_memory()->Purge(base::Time::Now()); |
222 EXPECT_TRUE(rv); | 228 EXPECT_TRUE(rv); |
223 heap.ReleasePurgedMemory(); | 229 heap.ReleasePurgedMemory(); |
224 | 230 |
225 // Shared memory backing for |span| should be gone. | 231 // Shared memory backing for |span| should be gone. |
226 EXPECT_FALSE(span->shared_memory()); | 232 EXPECT_FALSE(span->shared_memory()); |
227 | 233 |
228 // Size should be 0. | 234 // Size should be 0. |
229 EXPECT_EQ(0u, heap.GetSize()); | 235 EXPECT_EQ(0u, heap.GetSize()); |
230 } | 236 } |
231 | 237 |
232 TEST(DiscardableSharedMemoryHeapTest, Slack) { | 238 TEST(DiscardableSharedMemoryHeapTest, Slack) { |
233 size_t block_size = base::GetPageSize(); | 239 size_t block_size = base::GetPageSize(); |
234 DiscardableSharedMemoryHeap heap(block_size); | 240 DiscardableSharedMemoryHeap heap(block_size); |
235 | 241 |
236 const size_t kBlocks = 6; | 242 const size_t kBlocks = 6; |
237 size_t memory_size = block_size * kBlocks; | 243 size_t memory_size = block_size * kBlocks; |
238 | 244 |
239 scoped_ptr<base::DiscardableSharedMemory> memory( | 245 scoped_ptr<base::DiscardableSharedMemory> memory( |
240 new base::DiscardableSharedMemory); | 246 new base::DiscardableSharedMemory); |
241 ASSERT_TRUE(memory->CreateAndMap(memory_size)); | 247 ASSERT_TRUE(memory->CreateAndMap(memory_size)); |
242 heap.MergeIntoFreeLists(heap.Grow(memory.Pass(), memory_size).Pass()); | 248 heap.MergeIntoFreeLists( |
| 249 heap.Grow(memory.Pass(), memory_size, base::Bind(NullTask)).Pass()); |
243 | 250 |
244 // No free span that is less or equal to 3 + 1. | 251 // No free span that is less or equal to 3 + 1. |
245 EXPECT_FALSE(heap.SearchFreeLists(3, 1)); | 252 EXPECT_FALSE(heap.SearchFreeLists(3, 1)); |
246 | 253 |
247 // No free span that is less or equal to 3 + 2. | 254 // No free span that is less or equal to 3 + 2. |
248 EXPECT_FALSE(heap.SearchFreeLists(3, 2)); | 255 EXPECT_FALSE(heap.SearchFreeLists(3, 2)); |
249 | 256 |
250 // No free span that is less or equal to 1 + 4. | 257 // No free span that is less or equal to 1 + 4. |
251 EXPECT_FALSE(heap.SearchFreeLists(1, 4)); | 258 EXPECT_FALSE(heap.SearchFreeLists(1, 4)); |
252 | 259 |
253 scoped_ptr<DiscardableSharedMemoryHeap::Span> span = | 260 scoped_ptr<DiscardableSharedMemoryHeap::Span> span = |
254 heap.SearchFreeLists(1, 5); | 261 heap.SearchFreeLists(1, 5); |
255 EXPECT_TRUE(span); | 262 EXPECT_TRUE(span); |
256 | 263 |
257 heap.MergeIntoFreeLists(span.Pass()); | 264 heap.MergeIntoFreeLists(span.Pass()); |
258 } | 265 } |
259 | 266 |
| 267 void OnDeleted(bool* deleted) { |
| 268 *deleted = true; |
| 269 } |
| 270 |
| 271 TEST(DiscardableSharedMemoryHeapTest, DeletedCallback) { |
| 272 size_t block_size = base::GetPageSize(); |
| 273 DiscardableSharedMemoryHeap heap(block_size); |
| 274 |
| 275 scoped_ptr<base::DiscardableSharedMemory> memory( |
| 276 new base::DiscardableSharedMemory); |
| 277 ASSERT_TRUE(memory->CreateAndMap(block_size)); |
| 278 bool deleted = false; |
| 279 scoped_ptr<DiscardableSharedMemoryHeap::Span> span = |
| 280 heap.Grow(memory.Pass(), block_size, |
| 281 base::Bind(OnDeleted, base::Unretained(&deleted))); |
| 282 |
| 283 heap.MergeIntoFreeLists(span.Pass()); |
| 284 heap.ReleaseFreeMemory(); |
| 285 |
| 286 EXPECT_TRUE(deleted); |
| 287 } |
| 288 |
260 } // namespace | 289 } // namespace |
261 } // namespace content | 290 } // namespace content |
OLD | NEW |