Skip to content

Add more IPC tests #724

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Sep 16, 2024
Merged

Add more IPC tests #724

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
0252728
Add more IPC tests
vinser52 Sep 11, 2024
47aa449
Add umIpcTest.AllocFreeAllocTest test
vinser52 Sep 16, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
7 changes: 5 additions & 2 deletions test/ipcAPI.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand Down Expand Up @@ -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<provider_mock_ipc, void>();

Expand Down
140 changes: 133 additions & 7 deletions test/ipcFixtures.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -53,7 +53,16 @@ using ipcTestParams =
struct umfIpcTest : umf_test::test,
::testing::WithParamInterface<ipcTestParams> {
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(); }

Expand All @@ -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) {
Expand All @@ -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);
}

Expand All @@ -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) {
Expand All @@ -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;
Expand Down Expand Up @@ -209,6 +228,113 @@ 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<umf::pool_unique_handle_t> 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, 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<void *> ptrs;
constexpr size_t ALLOC_SIZE = 100;
Expand Down
Loading