1 /*
2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 *nless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "mem/mem.h"
16 #include "mem/mem_pool.h"
17 #include "mem/mmap_mem_pool-inl.h"
18
19 #include "gtest/gtest.h"
20
21 namespace ark {
22
23 class MMapMemPoolTest : public testing::Test {
24 public:
MMapMemPoolTest()25 MMapMemPoolTest()
26 {
27 instance_ = nullptr;
28 }
29
~MMapMemPoolTest()30 ~MMapMemPoolTest() override
31 {
32 delete instance_;
33 FinalizeMemConfig();
34 }
35
36 NO_MOVE_SEMANTIC(MMapMemPoolTest);
37 NO_COPY_SEMANTIC(MMapMemPoolTest);
38
39 protected:
CreateMMapMemPool(size_t objectPoolSize=0,size_t internalSize=0,size_t compilerSize=0,size_t codeSize=0U,size_t framesSize=0U,size_t stacksSize=0U)40 MmapMemPool *CreateMMapMemPool(size_t objectPoolSize = 0, size_t internalSize = 0, size_t compilerSize = 0,
41 size_t codeSize = 0U, size_t framesSize = 0U, size_t stacksSize = 0U)
42 {
43 ASSERT(instance_ == nullptr);
44 SetupMemConfig(objectPoolSize, internalSize, compilerSize, codeSize, framesSize, stacksSize);
45 instance_ = new MmapMemPool();
46 return instance_;
47 }
48
FreePoolWithPolicy(MmapMemPool * memPool,OSPagesPolicy policy,Pool & pool)49 void FreePoolWithPolicy(MmapMemPool *memPool, OSPagesPolicy policy, Pool &pool)
50 {
51 if (policy == OSPagesPolicy::NO_RETURN) {
52 memPool->template FreePool<OSPagesPolicy::NO_RETURN>(pool.GetMem(), pool.GetSize());
53 } else {
54 memPool->template FreePool<OSPagesPolicy::IMMEDIATE_RETURN>(pool.GetMem(), pool.GetSize());
55 }
56 }
57
ReturnedToOsTest(OSPagesPolicy firstPoolPolicy,OSPagesPolicy secondPoolPolicy,OSPagesPolicy thirdPoolPolicy,bool needFourthPool,bool bigPoolRealloc)58 void ReturnedToOsTest(OSPagesPolicy firstPoolPolicy, OSPagesPolicy secondPoolPolicy, OSPagesPolicy thirdPoolPolicy,
59 bool needFourthPool, bool bigPoolRealloc)
60 {
61 static constexpr size_t POOL_COUNT = 3U;
62 static constexpr size_t MMAP_MEMORY_SIZE = 16_MB;
63 static constexpr size_t BIG_POOL_ALLOC_SIZE = 12_MB;
64 MmapMemPool *memPool = CreateMMapMemPool(MMAP_MEMORY_SIZE);
65 std::array<Pool, POOL_COUNT> pools {{NULLPOOL, NULLPOOL, NULLPOOL}};
66 Pool fourthPool = NULLPOOL;
67
68 for (size_t i = 0; i < POOL_COUNT; i++) {
69 pools[i] = memPool->AllocPool(4_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
70 ASSERT_TRUE(pools[i].GetMem() != nullptr);
71 FillMemory(pools[i].GetMem(), pools[i].GetSize());
72 }
73 if (needFourthPool) {
74 fourthPool = memPool->AllocPool(4_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
75 ASSERT_TRUE(fourthPool.GetMem() != nullptr);
76 FillMemory(fourthPool.GetMem(), fourthPool.GetSize());
77 }
78
79 FreePoolWithPolicy(memPool, firstPoolPolicy, pools[0U]);
80 FreePoolWithPolicy(memPool, thirdPoolPolicy, pools[2U]);
81 FreePoolWithPolicy(memPool, secondPoolPolicy, pools[1U]);
82
83 if (bigPoolRealloc) {
84 auto finalPool = memPool->template AllocPool<OSPagesAllocPolicy::ZEROED_MEMORY>(
85 BIG_POOL_ALLOC_SIZE, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
86 ASSERT_TRUE(finalPool.GetMem() != nullptr);
87 IsZeroMemory(finalPool.GetMem(), finalPool.GetSize());
88 memPool->FreePool(finalPool.GetMem(), finalPool.GetSize());
89 } else {
90 // reallocate again
91 for (size_t i = 0; i < POOL_COUNT; i++) {
92 pools[i] = memPool->template AllocPool<OSPagesAllocPolicy::ZEROED_MEMORY>(
93 4_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
94 ASSERT_TRUE(pools[i].GetMem() != nullptr);
95 IsZeroMemory(pools[i].GetMem(), pools[i].GetSize());
96 }
97 for (size_t i = 0; i < POOL_COUNT; i++) {
98 memPool->FreePool(pools[i].GetMem(), pools[i].GetSize());
99 }
100 }
101 if (needFourthPool) {
102 memPool->FreePool(fourthPool.GetMem(), fourthPool.GetSize());
103 }
104 DeleteMMapMemPool(memPool);
105 }
106
107 private:
SetupMemConfig(size_t objectPoolSize,size_t internalSize,size_t compilerSize,size_t codeSize,size_t framesSize,size_t stacksSize)108 void SetupMemConfig(size_t objectPoolSize, size_t internalSize, size_t compilerSize, size_t codeSize,
109 size_t framesSize, size_t stacksSize)
110 {
111 mem::MemConfig::Initialize(objectPoolSize, internalSize, compilerSize, codeSize, framesSize, stacksSize);
112 }
113
FinalizeMemConfig()114 void FinalizeMemConfig()
115 {
116 mem::MemConfig::Finalize();
117 }
118
DeleteMMapMemPool(MmapMemPool * memPool)119 void DeleteMMapMemPool(MmapMemPool *memPool)
120 {
121 ASSERT(instance_ == memPool);
122 delete memPool;
123 FinalizeMemConfig();
124 instance_ = nullptr;
125 }
126
FillMemory(void * start,size_t size)127 void FillMemory(void *start, size_t size)
128 {
129 size_t itEnd = size / sizeof(uint64_t);
130 auto *pointer = static_cast<uint64_t *>(start);
131 for (size_t i = 0; i < itEnd; i++) {
132 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
133 pointer[i] = MAGIC_VALUE;
134 }
135 }
136
IsZeroMemory(void * start,size_t size)137 bool IsZeroMemory(void *start, size_t size)
138 {
139 size_t itEnd = size / sizeof(uint64_t);
140 auto *pointer = static_cast<uint64_t *>(start);
141 for (size_t i = 0; i < itEnd; i++) {
142 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
143 if (pointer[i] != 0U) {
144 return false;
145 }
146 }
147 return true;
148 }
149
150 static constexpr uint64_t MAGIC_VALUE = 0xDEADBEEF;
151
152 MmapMemPool *instance_;
153 };
154
TEST_F(MMapMemPoolTest,HeapOOMTest)155 TEST_F(MMapMemPoolTest, HeapOOMTest)
156 {
157 MmapMemPool *memPool = CreateMMapMemPool(4_MB);
158
159 auto pool1 = memPool->AllocPool(4_MB, SpaceType::SPACE_TYPE_HUMONGOUS_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
160 ASSERT_TRUE(pool1.GetMem() != nullptr);
161 auto pool2 = memPool->AllocPool(4_MB, SpaceType::SPACE_TYPE_HUMONGOUS_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
162 ASSERT_TRUE(pool2.GetMem() == nullptr);
163 auto pool3 = memPool->AllocPool(4_MB, SpaceType::SPACE_TYPE_NON_MOVABLE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
164 ASSERT_TRUE(pool3.GetMem() == nullptr);
165 auto pool4 = memPool->AllocPool(4_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
166 ASSERT_TRUE(pool4.GetMem() == nullptr);
167
168 memPool->FreePool(pool1.GetMem(), pool1.GetSize());
169 }
170
TEST_F(MMapMemPoolTest,HeapOOMAndAllocInOtherSpacesTest)171 TEST_F(MMapMemPoolTest, HeapOOMAndAllocInOtherSpacesTest)
172 {
173 MmapMemPool *memPool = CreateMMapMemPool(4_MB, 1_MB, 1_MB, 1_MB, 1_MB, 1_MB);
174
175 auto pool1 = memPool->AllocPool(4_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::BUMP_ALLOCATOR);
176 ASSERT_TRUE(pool1.GetMem() != nullptr);
177 auto pool2 = memPool->AllocPool(4_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::BUMP_ALLOCATOR);
178 ASSERT_TRUE(pool2.GetMem() == nullptr);
179 auto pool3 = memPool->AllocPool(1_MB, SpaceType::SPACE_TYPE_COMPILER, AllocatorType::BUMP_ALLOCATOR);
180 ASSERT_TRUE(pool3.GetMem() != nullptr);
181 auto pool4 = memPool->AllocPool(1_MB, SpaceType::SPACE_TYPE_CODE, AllocatorType::BUMP_ALLOCATOR);
182 ASSERT_TRUE(pool4.GetMem() != nullptr);
183 auto pool5 = memPool->AllocPool(1_MB, SpaceType::SPACE_TYPE_INTERNAL, AllocatorType::BUMP_ALLOCATOR);
184 ASSERT_TRUE(pool5.GetMem() != nullptr);
185 auto pool6 = memPool->AllocPool(1_MB, SpaceType::SPACE_TYPE_FRAMES, AllocatorType::BUMP_ALLOCATOR);
186 ASSERT_TRUE(pool6.GetMem() != nullptr);
187 auto pool7 = memPool->AllocPool(1_MB, SpaceType::SPACE_TYPE_NATIVE_STACKS, AllocatorType::BUMP_ALLOCATOR);
188 ASSERT_TRUE(pool7.GetMem() != nullptr);
189
190 // cleaning
191 memPool->FreePool(pool1.GetMem(), pool1.GetSize());
192 memPool->FreePool(pool3.GetMem(), pool3.GetSize());
193 memPool->FreePool(pool4.GetMem(), pool4.GetSize());
194 memPool->FreePool(pool5.GetMem(), pool5.GetSize());
195 memPool->FreePool(pool6.GetMem(), pool6.GetSize());
196 memPool->FreePool(pool7.GetMem(), pool7.GetSize());
197 }
198
TEST_F(MMapMemPoolTest,GetAllocatorInfoTest)199 TEST_F(MMapMemPoolTest, GetAllocatorInfoTest)
200 {
201 static constexpr AllocatorType ALLOC_TYPE = AllocatorType::BUMP_ALLOCATOR;
202 static constexpr size_t POOL_SIZE = 4_MB;
203 static constexpr size_t POINTER_POOL_OFFSET = 1_MB;
204 ASSERT_TRUE(POINTER_POOL_OFFSET < POOL_SIZE);
205 MmapMemPool *memPool = CreateMMapMemPool(POOL_SIZE * 2U, 0U, 0U, 0U);
206 int *allocatorAddr = new int();
207 Pool poolWithAllocAddr = memPool->AllocPool(POOL_SIZE, SpaceType::SPACE_TYPE_OBJECT, ALLOC_TYPE, allocatorAddr);
208 Pool poolWithoutAllocAddr = memPool->AllocPool(POOL_SIZE, SpaceType::SPACE_TYPE_OBJECT, ALLOC_TYPE);
209 ASSERT_TRUE(poolWithAllocAddr.GetMem() != nullptr);
210 ASSERT_TRUE(poolWithoutAllocAddr.GetMem() != nullptr);
211
212 void *firstPoolPointer = ToVoidPtr(ToUintPtr(poolWithAllocAddr.GetMem()) + POINTER_POOL_OFFSET);
213 ASSERT_TRUE(ToUintPtr(memPool->GetAllocatorInfoForAddr(firstPoolPointer).GetAllocatorHeaderAddr()) ==
214 ToUintPtr(allocatorAddr));
215 ASSERT_TRUE(memPool->GetAllocatorInfoForAddr(firstPoolPointer).GetType() == ALLOC_TYPE);
216 ASSERT_TRUE(ToUintPtr(memPool->GetStartAddrPoolForAddr(firstPoolPointer)) == ToUintPtr(poolWithAllocAddr.GetMem()));
217
218 void *secondPoolPointer = ToVoidPtr(ToUintPtr(poolWithoutAllocAddr.GetMem()) + POINTER_POOL_OFFSET);
219 ASSERT_TRUE(ToUintPtr(memPool->GetAllocatorInfoForAddr(secondPoolPointer).GetAllocatorHeaderAddr()) ==
220 ToUintPtr(poolWithoutAllocAddr.GetMem()));
221 ASSERT_TRUE(memPool->GetAllocatorInfoForAddr(secondPoolPointer).GetType() == ALLOC_TYPE);
222 ASSERT_TRUE(ToUintPtr(memPool->GetStartAddrPoolForAddr(secondPoolPointer)) ==
223 ToUintPtr(poolWithoutAllocAddr.GetMem()));
224
225 // cleaning
226 memPool->FreePool(poolWithAllocAddr.GetMem(), poolWithAllocAddr.GetSize());
227 memPool->FreePool(poolWithoutAllocAddr.GetMem(), poolWithoutAllocAddr.GetSize());
228
229 delete allocatorAddr;
230 }
231
TEST_F(MMapMemPoolTest,CheckLimitsForInternalSpacesTest)232 TEST_F(MMapMemPoolTest, CheckLimitsForInternalSpacesTest)
233 {
234 #ifndef PANDA_TARGET_32
235 MmapMemPool *memPool = CreateMMapMemPool(1_GB, 1_GB, 1_GB, 1_GB, 1_GB, 1_GB);
236 Pool objectPool = memPool->AllocPool(1_GB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::BUMP_ALLOCATOR);
237 Pool internalPool = memPool->AllocPool(1_GB, SpaceType::SPACE_TYPE_COMPILER, AllocatorType::BUMP_ALLOCATOR);
238 Pool codePool = memPool->AllocPool(1_GB, SpaceType::SPACE_TYPE_CODE, AllocatorType::BUMP_ALLOCATOR);
239 Pool compilerPool = memPool->AllocPool(1_GB, SpaceType::SPACE_TYPE_INTERNAL, AllocatorType::BUMP_ALLOCATOR);
240 Pool framesPool = memPool->AllocPool(1_GB, SpaceType::SPACE_TYPE_FRAMES, AllocatorType::BUMP_ALLOCATOR);
241 Pool stacksPool = memPool->AllocPool(1_GB, SpaceType::SPACE_TYPE_NATIVE_STACKS, AllocatorType::BUMP_ALLOCATOR);
242 // Check that these pools has been created successfully
243 ASSERT_TRUE(objectPool.GetMem() != nullptr);
244 ASSERT_TRUE(internalPool.GetMem() != nullptr);
245 ASSERT_TRUE(codePool.GetMem() != nullptr);
246 ASSERT_TRUE(compilerPool.GetMem() != nullptr);
247 ASSERT_TRUE(framesPool.GetMem() != nullptr);
248 ASSERT_TRUE(stacksPool.GetMem() != nullptr);
249 // Check that part of internal pools located in 64 bits address space
250 bool internal =
251 (ToUintPtr(internalPool.GetMem()) + internalPool.GetSize() - 1L) > std::numeric_limits<uint32_t>::max();
252 bool code = (ToUintPtr(codePool.GetMem()) + codePool.GetSize() - 1L) > std::numeric_limits<uint32_t>::max();
253 bool compiler =
254 (ToUintPtr(compilerPool.GetMem()) + compilerPool.GetSize() - 1L) > std::numeric_limits<uint32_t>::max();
255 bool frame = (ToUintPtr(framesPool.GetMem()) + framesPool.GetSize() - 1L) > std::numeric_limits<uint32_t>::max();
256 bool stacks = (ToUintPtr(stacksPool.GetMem()) + stacksPool.GetSize() - 1L) > std::numeric_limits<uint32_t>::max();
257 ASSERT_TRUE(internal || code || compiler || frame || stacks);
258
259 // cleaning
260 memPool->FreePool(objectPool.GetMem(), objectPool.GetSize());
261 memPool->FreePool(internalPool.GetMem(), internalPool.GetSize());
262 memPool->FreePool(codePool.GetMem(), codePool.GetSize());
263 memPool->FreePool(compilerPool.GetMem(), compilerPool.GetSize());
264 memPool->FreePool(framesPool.GetMem(), framesPool.GetSize());
265 memPool->FreePool(stacksPool.GetMem(), stacksPool.GetSize());
266 #endif
267 }
268
TEST_F(MMapMemPoolTest,PoolReturnTest)269 TEST_F(MMapMemPoolTest, PoolReturnTest)
270 {
271 MmapMemPool *memPool = CreateMMapMemPool(8_MB);
272
273 auto pool1 = memPool->AllocPool(4_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
274 ASSERT_TRUE(pool1.GetMem() != nullptr);
275 auto pool2 = memPool->AllocPool(4_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
276 ASSERT_TRUE(pool2.GetMem() != nullptr);
277 auto pool3 = memPool->AllocPool(4_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
278 ASSERT_TRUE(pool3.GetMem() == nullptr);
279 memPool->FreePool(pool1.GetMem(), pool1.GetSize());
280 memPool->FreePool(pool2.GetMem(), pool2.GetSize());
281
282 auto pool4 = memPool->AllocPool(6_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
283 ASSERT_TRUE(pool4.GetMem() != nullptr);
284 auto pool5 = memPool->AllocPool(1_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
285 ASSERT_TRUE(pool5.GetMem() != nullptr);
286 auto pool6 = memPool->AllocPool(1_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
287 ASSERT_TRUE(pool6.GetMem() != nullptr);
288 memPool->FreePool(pool6.GetMem(), pool6.GetSize());
289 memPool->FreePool(pool4.GetMem(), pool4.GetSize());
290 memPool->FreePool(pool5.GetMem(), pool5.GetSize());
291
292 auto pool7 = memPool->AllocPool(8_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
293 ASSERT_TRUE(pool7.GetMem() != nullptr);
294 memPool->FreePool(pool7.GetMem(), pool7.GetSize());
295 }
296
TEST_F(MMapMemPoolTest,CheckEnoughPoolsTest)297 TEST_F(MMapMemPoolTest, CheckEnoughPoolsTest)
298 {
299 static constexpr size_t MMAP_MEM_POOL_SIZE = 10_MB;
300 static constexpr size_t POOL_SIZE = 4_MB;
301 MmapMemPool *memPool = CreateMMapMemPool(MMAP_MEM_POOL_SIZE);
302
303 ASSERT_TRUE(memPool->HaveEnoughPoolsInObjectSpace(2U, POOL_SIZE));
304 ASSERT_FALSE(memPool->HaveEnoughPoolsInObjectSpace(3U, POOL_SIZE));
305 auto pool1 = memPool->AllocPool(3_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
306 ASSERT_TRUE(memPool->HaveEnoughPoolsInObjectSpace(1U, POOL_SIZE));
307 ASSERT_FALSE(memPool->HaveEnoughPoolsInObjectSpace(2U, POOL_SIZE));
308 auto pool2 = memPool->AllocPool(1_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
309 memPool->FreePool(pool1.GetMem(), pool1.GetSize());
310 ASSERT_TRUE(memPool->HaveEnoughPoolsInObjectSpace(1U, POOL_SIZE));
311 ASSERT_FALSE(memPool->HaveEnoughPoolsInObjectSpace(2U, POOL_SIZE));
312 memPool->FreePool(pool2.GetMem(), pool2.GetSize());
313 ASSERT_TRUE(memPool->HaveEnoughPoolsInObjectSpace(2U, POOL_SIZE));
314 ASSERT_FALSE(memPool->HaveEnoughPoolsInObjectSpace(3U, POOL_SIZE));
315
316 auto pool3 = memPool->AllocPool(4_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
317 auto pool4 = memPool->AllocPool(1_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
318 ASSERT_TRUE(memPool->HaveEnoughPoolsInObjectSpace(1U, POOL_SIZE));
319 ASSERT_FALSE(memPool->HaveEnoughPoolsInObjectSpace(2U, POOL_SIZE));
320 memPool->FreePool(pool3.GetMem(), pool3.GetSize());
321 ASSERT_TRUE(memPool->HaveEnoughPoolsInObjectSpace(2U, POOL_SIZE));
322 ASSERT_FALSE(memPool->HaveEnoughPoolsInObjectSpace(3U, POOL_SIZE));
323 auto pool5 = memPool->AllocPool(5_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
324 ASSERT_TRUE(memPool->HaveEnoughPoolsInObjectSpace(1U, POOL_SIZE));
325 ASSERT_FALSE(memPool->HaveEnoughPoolsInObjectSpace(2U, POOL_SIZE));
326 memPool->FreePool(pool5.GetMem(), pool5.GetSize());
327 ASSERT_TRUE(memPool->HaveEnoughPoolsInObjectSpace(2U, POOL_SIZE));
328 ASSERT_FALSE(memPool->HaveEnoughPoolsInObjectSpace(3U, POOL_SIZE));
329 memPool->FreePool(pool4.GetMem(), pool4.GetSize());
330 ASSERT_TRUE(memPool->HaveEnoughPoolsInObjectSpace(2U, POOL_SIZE));
331 ASSERT_FALSE(memPool->HaveEnoughPoolsInObjectSpace(3U, POOL_SIZE));
332 }
333
TEST_F(MMapMemPoolTest,TestMergeWithFreeSpace)334 TEST_F(MMapMemPoolTest, TestMergeWithFreeSpace)
335 {
336 static constexpr size_t MMAP_MEM_POOL_SIZE = 10_MB;
337 MmapMemPool *memPool = CreateMMapMemPool(MMAP_MEM_POOL_SIZE);
338 auto pool = memPool->AllocPool(7_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
339 memPool->FreePool(pool.GetMem(), pool.GetSize());
340 pool = memPool->AllocPool(8_MB, SpaceType::SPACE_TYPE_OBJECT, AllocatorType::HUMONGOUS_ALLOCATOR);
341 ASSERT_TRUE(pool.GetMem() != nullptr);
342 ASSERT_EQ(8_MB, pool.GetSize());
343 memPool->FreePool(pool.GetMem(), pool.GetSize());
344 }
345
TEST_F(MMapMemPoolTest,ReturnedToOsPlusZeroingMemoryTest)346 TEST_F(MMapMemPoolTest, ReturnedToOsPlusZeroingMemoryTest)
347 {
348 for (OSPagesPolicy a : {OSPagesPolicy::NO_RETURN, OSPagesPolicy::IMMEDIATE_RETURN}) {
349 for (OSPagesPolicy b : {OSPagesPolicy::NO_RETURN, OSPagesPolicy::IMMEDIATE_RETURN}) {
350 for (OSPagesPolicy c : {OSPagesPolicy::NO_RETURN, OSPagesPolicy::IMMEDIATE_RETURN}) {
351 for (bool d : {false, true}) {
352 for (bool e : {false, true}) {
353 ReturnedToOsTest(a, b, c, d, e);
354 }
355 }
356 }
357 }
358 }
359 }
360
361 } // namespace ark
362