Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(15)

Side by Side Diff: content/common/discardable_shared_memory_heap_unittest.cc

Issue 1009203004: content: Add DeletedDiscardableSharedMemory IPC. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: rebase Created 5 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
OLDNEW
« no previous file with comments | « content/common/discardable_shared_memory_heap_perftest.cc ('k') | content/common/host_discardable_shared_memory_manager.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698