From 0252728ba4ab8262913a36dac3b4d15fb14dbbf9 Mon Sep 17 00:00:00 2001 From: "Vinogradov, Sergei" Date: Thu, 12 Sep 2024 00:49:41 +0200 Subject: [PATCH 1/2] Add more IPC tests --- test/ipcAPI.cpp | 7 +++- test/ipcFixtures.hpp | 91 ++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 89 insertions(+), 9 deletions(-) diff --git a/test/ipcAPI.cpp b/test/ipcAPI.cpp index 524c26d4b..8f8448b62 100644 --- a/test/ipcAPI.cpp +++ b/test/ipcAPI.cpp @@ -25,8 +25,8 @@ struct provider_mock_ipc : public umf_test::provider_base_t { }; umf_test::provider_malloc helper_prov; - allocations_mutex_type alloc_mutex; - allocations_map_type allocations; + static allocations_mutex_type alloc_mutex; + static allocations_map_type allocations; umf_result_t alloc(size_t size, size_t align, void **ptr) noexcept { auto ret = helper_prov.alloc(size, align, ptr); @@ -105,6 +105,9 @@ struct provider_mock_ipc : public umf_test::provider_base_t { } }; +provider_mock_ipc::allocations_mutex_type provider_mock_ipc::alloc_mutex; +provider_mock_ipc::allocations_map_type provider_mock_ipc::allocations; + static umf_memory_provider_ops_t IPC_MOCK_PROVIDER_OPS = umf::providerMakeCOps(); diff --git a/test/ipcFixtures.hpp b/test/ipcFixtures.hpp index ce16e8f79..4c9ebd549 100644 --- a/test/ipcFixtures.hpp +++ b/test/ipcFixtures.hpp @@ -53,7 +53,16 @@ using ipcTestParams = struct umfIpcTest : umf_test::test, ::testing::WithParamInterface { umfIpcTest() {} - void SetUp() override { test::SetUp(); } + void SetUp() override { + test::SetUp(); + auto [pool_ops, pool_params, provider_ops, provider_params, accessor] = + this->GetParam(); + poolOps = pool_ops; + poolParams = pool_params; + providerOps = provider_ops; + providerParams = provider_params; + memAccessor = accessor; + } void TearDown() override { test::TearDown(); } @@ -62,11 +71,9 @@ struct umfIpcTest : umf_test::test, // from memoryPool.hpp umf_memory_provider_handle_t hProvider; umf_memory_pool_handle_t hPool; - auto [pool_ops, pool_params, provider_ops, provider_params, accessor] = - this->GetParam(); auto ret = - umfMemoryProviderCreate(provider_ops, provider_params, &hProvider); + umfMemoryProviderCreate(providerOps, providerParams, &hProvider); EXPECT_EQ(ret, UMF_RESULT_SUCCESS); auto trace = [](void *trace_context, const char *name) { @@ -87,12 +94,10 @@ struct umfIpcTest : umf_test::test, umf_memory_provider_handle_t hTraceProvider = traceProviderCreate(hProvider, true, (void *)&stat, trace); - ret = umfPoolCreate(pool_ops, hTraceProvider, pool_params, + ret = umfPoolCreate(poolOps, hTraceProvider, poolParams, UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &hPool); EXPECT_EQ(ret, UMF_RESULT_SUCCESS); - memAccessor = accessor; - return umf::pool_unique_handle_t(hPool, &umfPoolDestroy); } @@ -111,6 +116,10 @@ struct umfIpcTest : umf_test::test, static constexpr int NTHREADS = 10; stats_type stat; MemoryAccessor *memAccessor = nullptr; + umf_memory_pool_ops_t *poolOps = nullptr; + void *poolParams = nullptr; + umf_memory_provider_ops_t *providerOps = nullptr; + void *providerParams = nullptr; }; TEST_P(umfIpcTest, GetIPCHandleSize) { @@ -122,6 +131,16 @@ TEST_P(umfIpcTest, GetIPCHandleSize) { EXPECT_GT(size, 0); } +TEST_P(umfIpcTest, GetIPCHandleSizeInvalidArgs) { + size_t size = 0; + umf_result_t ret = umfPoolGetIPCHandleSize(nullptr, &size); + EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT); + + umf::pool_unique_handle_t pool = makePool(); + ret = umfPoolGetIPCHandleSize(pool.get(), nullptr); + EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT); +} + TEST_P(umfIpcTest, GetIPCHandleInvalidArgs) { constexpr size_t SIZE = 100; umf_ipc_handle_t ipcHandle = nullptr; @@ -209,6 +228,64 @@ TEST_P(umfIpcTest, BasicFlow) { EXPECT_EQ(stat.closeCount, stat.openCount); } +TEST_P(umfIpcTest, GetPoolByOpenedHandle) { + constexpr size_t SIZE = 100; + constexpr size_t NUM_ALLOCS = 100; + constexpr size_t NUM_POOLS = 4; + void *ptrs[NUM_ALLOCS]; + void *openedPtrs[NUM_POOLS][NUM_ALLOCS]; + std::vector pools_to_open; + umf::pool_unique_handle_t pool = makePool(); + + for (size_t i = 0; i < NUM_POOLS; ++i) { + pools_to_open.push_back(makePool()); + } + + for (size_t i = 0; i < NUM_ALLOCS; ++i) { + void *ptr = umfPoolMalloc(pool.get(), SIZE); + ASSERT_NE(ptr, nullptr); + ptrs[i] = ptr; + } + + for (size_t i = 0; i < NUM_ALLOCS; ++i) { + umf_ipc_handle_t ipcHandle = nullptr; + size_t handleSize = 0; + umf_result_t ret = umfGetIPCHandle(ptrs[i], &ipcHandle, &handleSize); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + + for (size_t pool_id = 0; pool_id < NUM_POOLS; pool_id++) { + void *ptr = nullptr; + ret = + umfOpenIPCHandle(pools_to_open[pool_id].get(), ipcHandle, &ptr); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + openedPtrs[pool_id][i] = ptr; + } + + ret = umfPutIPCHandle(ipcHandle); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + } + + for (size_t pool_id = 0; pool_id < NUM_POOLS; pool_id++) { + for (size_t i = 0; i < NUM_ALLOCS; ++i) { + umf_memory_pool_handle_t openedPool = + umfPoolByPtr(openedPtrs[pool_id][i]); + EXPECT_EQ(openedPool, pools_to_open[pool_id].get()); + } + } + + for (size_t pool_id = 0; pool_id < NUM_POOLS; pool_id++) { + for (size_t i = 0; i < NUM_ALLOCS; ++i) { + umf_result_t ret = umfCloseIPCHandle(openedPtrs[pool_id][i]); + EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + } + } + + for (size_t i = 0; i < NUM_ALLOCS; ++i) { + umf_result_t ret = umfFree(ptrs[i]); + EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + } +} + TEST_P(umfIpcTest, ConcurrentGetPutHandles) { std::vector ptrs; constexpr size_t ALLOC_SIZE = 100; From 47aa4491407a2dff626025391c9c83193649ae51 Mon Sep 17 00:00:00 2001 From: "Vinogradov, Sergei" Date: Mon, 16 Sep 2024 17:50:46 +0200 Subject: [PATCH 2/2] Add umIpcTest.AllocFreeAllocTest test --- test/ipcFixtures.hpp | 49 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/test/ipcFixtures.hpp b/test/ipcFixtures.hpp index 4c9ebd549..cd8905008 100644 --- a/test/ipcFixtures.hpp +++ b/test/ipcFixtures.hpp @@ -286,6 +286,55 @@ TEST_P(umfIpcTest, GetPoolByOpenedHandle) { } } +TEST_P(umfIpcTest, AllocFreeAllocTest) { + constexpr size_t SIZE = 64 * 1024; + umf::pool_unique_handle_t pool = makePool(); + void *ptr = umfPoolMalloc(pool.get(), SIZE); + EXPECT_NE(ptr, nullptr); + + umf_ipc_handle_t ipcHandle = nullptr; + size_t handleSize = 0; + umf_result_t ret = umfGetIPCHandle(ptr, &ipcHandle, &handleSize); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + + void *opened_ptr = nullptr; + ret = umfOpenIPCHandle(pool.get(), ipcHandle, &opened_ptr); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + + ret = umfCloseIPCHandle(opened_ptr); + EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + + ret = umfPutIPCHandle(ipcHandle); + EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + + ret = umfPoolFree(pool.get(), ptr); + EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + + ptr = umfPoolMalloc(pool.get(), SIZE); + ASSERT_NE(ptr, nullptr); + + ret = umfGetIPCHandle(ptr, &ipcHandle, &handleSize); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + + ret = umfOpenIPCHandle(pool.get(), ipcHandle, &opened_ptr); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + + ret = umfCloseIPCHandle(opened_ptr); + EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + + ret = umfPutIPCHandle(ipcHandle); + EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + + ret = umfPoolFree(pool.get(), ptr); + EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + + pool.reset(nullptr); + EXPECT_EQ(stat.allocCount, stat.getCount); + EXPECT_EQ(stat.getCount, stat.putCount); + EXPECT_EQ(stat.openCount, stat.getCount); + EXPECT_EQ(stat.openCount, stat.closeCount); +} + TEST_P(umfIpcTest, ConcurrentGetPutHandles) { std::vector ptrs; constexpr size_t ALLOC_SIZE = 100;