Skip to content

Commit 0939cb3

Browse files
ldorauldorau
committed
Add tests for pool from pointer
Signed-off-by: Lukasz Dorau <[email protected]>
1 parent ae1f041 commit 0939cb3

File tree

1 file changed

+223
-2
lines changed

1 file changed

+223
-2
lines changed

‎test/provider_fixed_memory.cpp

Lines changed: 223 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
// Copyright (C) 2024 Intel Corporation
1+
// Copyright (C) 2024-2025 Intel Corporation
22
// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
33
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
44

@@ -11,10 +11,12 @@
1111
#endif
1212

1313
#include <umf/memory_provider.h>
14+
#include <umf/pools/pool_proxy.h>
1415
#include <umf/providers/provider_fixed_memory.h>
1516

1617
using umf_test::test;
1718

19+
#define FIXED_BUFFER_SIZE (10 * utils_get_page_size())
1820
#define INVALID_PTR ((void *)0x01)
1921

2022
typedef enum purge_t {
@@ -59,7 +61,7 @@ struct FixedProviderTest
5961
test::SetUp();
6062

6163
// Allocate a memory buffer to use with the fixed memory provider
62-
memory_size = utils_get_page_size() * 10; // Allocate 10 pages
64+
memory_size = FIXED_BUFFER_SIZE; // Allocate 10 pages
6365
memory_buffer = malloc(memory_size);
6466
ASSERT_NE(memory_buffer, nullptr);
6567

@@ -391,3 +393,222 @@ TEST_P(FixedProviderTest, split) {
391393
umf_result = umfMemoryProviderFree(provider.get(), ptr2, size);
392394
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
393395
}
396+
397+
TEST_P(FixedProviderTest, params_set_flags_negative) {
398+
umf_result_t umf_result;
399+
400+
// Create provider parameters
401+
umf_fixed_memory_provider_params_handle_t params = nullptr;
402+
umf_result =
403+
umfFixedMemoryProviderParamsCreate(&params, memory_buffer, memory_size);
404+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
405+
ASSERT_NE(params, nullptr);
406+
407+
// params is NULL
408+
umf_result = umfFixedMemoryProviderParamsSetFlags(
409+
NULL, UMF_FIXED_FLAG_CREATE_FROM_POOL_PTR);
410+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
411+
412+
// the pointer does not belong to any UMF pool
413+
umf_result = umfFixedMemoryProviderParamsSetFlags(
414+
params, UMF_FIXED_FLAG_CREATE_FROM_POOL_PTR);
415+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
416+
417+
umfFixedMemoryProviderParamsDestroy(params);
418+
}
419+
420+
TEST_P(FixedProviderTest, pool_from_ptr_negative_wrong_ptr) {
421+
umf_result_t umf_result;
422+
size_t size_of_first_alloc;
423+
size_t size_of_pool_from_ptr;
424+
void *ptr_for_pool = nullptr;
425+
426+
umf_memory_pool_handle_t proxyFixedPool = nullptr;
427+
umf_result = umfPoolCreate(umfProxyPoolOps(), provider.get(), nullptr, 0,
428+
&proxyFixedPool);
429+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
430+
431+
size_of_first_alloc = FIXED_BUFFER_SIZE - (2 * page_size);
432+
ptr_for_pool = umfPoolMalloc(proxyFixedPool, size_of_first_alloc);
433+
ASSERT_NE(ptr_for_pool, nullptr);
434+
435+
// Create provider parameters
436+
size_of_pool_from_ptr = size_of_first_alloc; // whole size
437+
umf_fixed_memory_provider_params_handle_t params = nullptr;
438+
umf_result = umfFixedMemoryProviderParamsCreate(&params, ptr_for_pool,
439+
size_of_pool_from_ptr);
440+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
441+
ASSERT_NE(params, nullptr);
442+
443+
umf_result = umfFixedMemoryProviderParamsSetFlags(
444+
params, UMF_FIXED_FLAG_CREATE_FROM_POOL_PTR);
445+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
446+
447+
umf_result = umfPoolFree(proxyFixedPool, ptr_for_pool);
448+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
449+
450+
// the pointer (ptr_for_pool) does not belong to any UMF pool
451+
umf_memory_provider_handle_t providerFromPtr = nullptr;
452+
umf_result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
453+
&providerFromPtr);
454+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
455+
ASSERT_EQ(providerFromPtr, nullptr);
456+
457+
umfFixedMemoryProviderParamsDestroy(params);
458+
umfPoolDestroy(proxyFixedPool);
459+
}
460+
461+
TEST_P(FixedProviderTest, pool_from_ptr_negative_shrink_size_too_big) {
462+
umf_result_t umf_result;
463+
size_t size_of_first_alloc;
464+
size_t size_of_pool_from_ptr;
465+
void *ptr_for_pool = nullptr;
466+
467+
umf_memory_pool_handle_t proxyFixedPool = nullptr;
468+
umf_result = umfPoolCreate(umfProxyPoolOps(), provider.get(), nullptr, 0,
469+
&proxyFixedPool);
470+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
471+
472+
size_of_first_alloc = FIXED_BUFFER_SIZE - (2 * page_size);
473+
ptr_for_pool = umfPoolMalloc(proxyFixedPool, size_of_first_alloc);
474+
ASSERT_NE(ptr_for_pool, nullptr);
475+
476+
// Create provider parameters
477+
size_of_pool_from_ptr = size_of_first_alloc + 1; // size too big
478+
umf_fixed_memory_provider_params_handle_t params = nullptr;
479+
umf_result = umfFixedMemoryProviderParamsCreate(&params, ptr_for_pool,
480+
size_of_pool_from_ptr);
481+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
482+
ASSERT_NE(params, nullptr);
483+
484+
umf_result = umfFixedMemoryProviderParamsSetFlags(
485+
params, UMF_FIXED_FLAG_CREATE_FROM_POOL_PTR);
486+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
487+
488+
umf_memory_provider_handle_t providerFromPtr = nullptr;
489+
umf_result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
490+
&providerFromPtr);
491+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
492+
ASSERT_EQ(providerFromPtr, nullptr);
493+
494+
umfFixedMemoryProviderParamsDestroy(params);
495+
496+
umf_result = umfPoolFree(proxyFixedPool, ptr_for_pool);
497+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
498+
499+
umfPoolDestroy(proxyFixedPool);
500+
}
501+
502+
TEST_P(FixedProviderTest, pool_from_ptr_whole_size_success) {
503+
umf_result_t umf_result;
504+
size_t size_of_first_alloc;
505+
size_t size_of_pool_from_ptr;
506+
void *ptr_for_pool = nullptr;
507+
void *ptr = nullptr;
508+
509+
umf_memory_pool_handle_t proxyFixedPool = nullptr;
510+
umf_result = umfPoolCreate(umfProxyPoolOps(), provider.get(), nullptr, 0,
511+
&proxyFixedPool);
512+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
513+
514+
size_of_first_alloc = FIXED_BUFFER_SIZE - (2 * page_size);
515+
ptr_for_pool = umfPoolMalloc(proxyFixedPool, size_of_first_alloc);
516+
ASSERT_NE(ptr_for_pool, nullptr);
517+
518+
// Create provider parameters
519+
size_of_pool_from_ptr = size_of_first_alloc; // whole size
520+
umf_fixed_memory_provider_params_handle_t params = nullptr;
521+
umf_result = umfFixedMemoryProviderParamsCreate(&params, ptr_for_pool,
522+
size_of_pool_from_ptr);
523+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
524+
ASSERT_NE(params, nullptr);
525+
526+
umf_result = umfFixedMemoryProviderParamsSetFlags(
527+
params, UMF_FIXED_FLAG_CREATE_FROM_POOL_PTR);
528+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
529+
530+
umf_memory_provider_handle_t providerFromPtr = nullptr;
531+
umf_result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
532+
&providerFromPtr);
533+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
534+
ASSERT_NE(providerFromPtr, nullptr);
535+
536+
umf_memory_pool_handle_t poolFromPtr = nullptr;
537+
umf_result = umfPoolCreate(umfProxyPoolOps(), providerFromPtr, nullptr, 0,
538+
&poolFromPtr);
539+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
540+
541+
ptr = umfPoolMalloc(poolFromPtr, size_of_pool_from_ptr);
542+
ASSERT_NE(ptr, nullptr);
543+
544+
memset(ptr, 0xFF, size_of_pool_from_ptr);
545+
546+
umf_result = umfPoolFree(poolFromPtr, ptr);
547+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
548+
549+
umfPoolDestroy(poolFromPtr);
550+
umfMemoryProviderDestroy(providerFromPtr);
551+
umfFixedMemoryProviderParamsDestroy(params);
552+
553+
umf_result = umfPoolFree(proxyFixedPool, ptr_for_pool);
554+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
555+
556+
umfPoolDestroy(proxyFixedPool);
557+
}
558+
559+
TEST_P(FixedProviderTest, pool_from_ptr_half_size_success) {
560+
umf_result_t umf_result;
561+
size_t size_of_first_alloc;
562+
size_t size_of_pool_from_ptr;
563+
void *ptr_for_pool = nullptr;
564+
void *ptr = nullptr;
565+
566+
umf_memory_pool_handle_t proxyFixedPool = nullptr;
567+
umf_result = umfPoolCreate(umfProxyPoolOps(), provider.get(), nullptr, 0,
568+
&proxyFixedPool);
569+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
570+
571+
size_of_first_alloc = FIXED_BUFFER_SIZE - (2 * page_size);
572+
ptr_for_pool = umfPoolMalloc(proxyFixedPool, size_of_first_alloc);
573+
ASSERT_NE(ptr_for_pool, nullptr);
574+
575+
// Create provider parameters
576+
size_of_pool_from_ptr = size_of_first_alloc / 2; // half size
577+
umf_fixed_memory_provider_params_handle_t params = nullptr;
578+
umf_result = umfFixedMemoryProviderParamsCreate(&params, ptr_for_pool,
579+
size_of_pool_from_ptr);
580+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
581+
ASSERT_NE(params, nullptr);
582+
583+
umf_result = umfFixedMemoryProviderParamsSetFlags(
584+
params, UMF_FIXED_FLAG_CREATE_FROM_POOL_PTR);
585+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
586+
587+
umf_memory_provider_handle_t providerFromPtr = nullptr;
588+
umf_result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
589+
&providerFromPtr);
590+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
591+
ASSERT_NE(providerFromPtr, nullptr);
592+
593+
umf_memory_pool_handle_t poolFromPtr = nullptr;
594+
umf_result = umfPoolCreate(umfProxyPoolOps(), providerFromPtr, nullptr, 0,
595+
&poolFromPtr);
596+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
597+
598+
ptr = umfPoolMalloc(poolFromPtr, size_of_pool_from_ptr);
599+
ASSERT_NE(ptr, nullptr);
600+
601+
memset(ptr, 0xFF, size_of_pool_from_ptr);
602+
603+
umf_result = umfPoolFree(poolFromPtr, ptr);
604+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
605+
606+
umfPoolDestroy(poolFromPtr);
607+
umfMemoryProviderDestroy(providerFromPtr);
608+
umfFixedMemoryProviderParamsDestroy(params);
609+
610+
umf_result = umfPoolFree(proxyFixedPool, ptr_for_pool);
611+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
612+
613+
umfPoolDestroy(proxyFixedPool);
614+
}

0 commit comments

Comments
 (0)