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