Add more IPC tests

Author: vinser52

test/ipcFixtures.hpp

@@ -66,6 +66,18 @@ using ipcTestParams =
 struct umfIpcTest : umf_test::test,
                     ::testing::WithParamInterface<ipcTestParams> {
     umfIpcTest() {}
+    size_t getOpenedIpcCacheSize() {
+        const char *max_size_str = getenv("UMF_MAX_OPENED_IPC_HANDLES");
+        if (max_size_str) {
+            char *endptr;
+            size_t max_size = strtoul(max_size_str, &endptr, 10);
+            EXPECT_EQ(*endptr, '\0');
+            if (*endptr == '\0') {
+                return max_size;
+            }
+        }
+        return 0;
+    }
     void SetUp() override {
         test::SetUp();
         auto [pool_ops, pool_params_create, pool_params_destroy, provider_ops,
@@ -78,6 +90,7 @@ struct umfIpcTest : umf_test::test,
         providerParamsCreate = provider_params_create;
         providerParamsDestroy = provider_params_destroy;
         memAccessor = accessor;
+        openedIpcCacheSize = getOpenedIpcCacheSize();
     }
 
     void TearDown() override { test::TearDown(); }
@@ -158,6 +171,7 @@ struct umfIpcTest : umf_test::test,
     umf_memory_provider_ops_t *providerOps = nullptr;
     pfnProviderParamsCreate providerParamsCreate = nullptr;
     pfnProviderParamsDestroy providerParamsDestroy = nullptr;
+    size_t openedIpcCacheSize = 0;
 };
 
 TEST_P(umfIpcTest, GetIPCHandleSize) {
@@ -458,7 +472,7 @@ TEST_P(umfIpcTest, ConcurrentGetPutHandles) {
     EXPECT_EQ(stat.putCount, stat.getCount);
 }
 
-TEST_P(umfIpcTest, ConcurrentOpenCloseHandles) {
+TEST_P(umfIpcTest, ConcurrentOpenConcurrentCloseHandles) {
     umf_result_t ret;
     std::vector<void *> ptrs;
     constexpr size_t ALLOC_SIZE = 100;
@@ -529,6 +543,68 @@ TEST_P(umfIpcTest, ConcurrentOpenCloseHandles) {
     EXPECT_EQ(stat.openCount, stat.closeCount);
 }
 
+TEST_P(umfIpcTest, ConcurrentOpenCloseHandles) {
+    umf_result_t ret;
+    std::vector<void *> ptrs;
+    constexpr size_t ALLOC_SIZE = 100;
+    constexpr size_t NUM_POINTERS = 100;
+    umf::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
+
+    for (size_t i = 0; i < NUM_POINTERS; ++i) {
+        void *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);
+        EXPECT_NE(ptr, nullptr);
+        ptrs.push_back(ptr);
+    }
+
+    std::array<umf_ipc_handle_t, NUM_POINTERS> ipcHandles;
+    for (size_t i = 0; i < NUM_POINTERS; ++i) {
+        umf_ipc_handle_t ipcHandle;
+        size_t handleSize;
+        ret = umfGetIPCHandle(ptrs[i], &ipcHandle, &handleSize);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ipcHandles[i] = ipcHandle;
+    }
+
+    umf_ipc_handler_handle_t ipcHandler = nullptr;
+    ret = umfPoolGetIPCHandler(pool.get(), &ipcHandler);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ipcHandler, nullptr);
+
+    umf_test::syncthreads_barrier syncthreads(NTHREADS);
+
+    auto openCloseHandlesFn = [&ipcHandles, &syncthreads, ipcHandler](size_t) {
+        syncthreads();
+        for (auto ipcHandle : ipcHandles) {
+            void *ptr;
+            umf_result_t ret = umfOpenIPCHandle(ipcHandler, ipcHandle, &ptr);
+            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+            ret = umfCloseIPCHandle(ptr);
+            EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        }
+    };
+
+    umf_test::parallel_exec(NTHREADS, openCloseHandlesFn);
+
+    for (auto ipcHandle : ipcHandles) {
+        ret = umfPutIPCHandle(ipcHandle);
+        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    }
+
+    for (void *ptr : ptrs) {
+        ret = umfPoolFree(pool.get(), ptr);
+        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    }
+
+    pool.reset(nullptr);
+    EXPECT_EQ(stat.getCount, stat.allocCount);
+    EXPECT_EQ(stat.putCount, stat.getCount);
+    if (openedIpcCacheSize == 0) {
+        EXPECT_EQ(stat.openCount, stat.allocCount);
+    }
+    EXPECT_EQ(stat.openCount, stat.closeCount);
+}
+
 TEST_P(umfIpcTest, ConcurrentDestroyIpcHandlers) {
     constexpr size_t SIZE = 100;
     constexpr size_t NUM_ALLOCS = 100;