Skip to content

Commit 12d7244

Browse files
vinser52vinser52
committed
Update umfOpenIPCHandle API to use IPC handler isntead of pool
1 parent fb53918 commit 12d7244

File tree

9 files changed

+124
-27
lines changed

9 files changed

+124
-27
lines changed

‎examples/ipc_ipcapi/ipc_ipcapi_consumer.c‎

Lines changed: 8 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -142,6 +142,13 @@ int main(int argc, char *argv[]) {
142142
goto err_destroy_OS_memory_provider;
143143
}
144144

145+
umf_ipc_handler_handle_t ipc_handler;
146+
umf_result = umfPoolGetIPCHandler(scalable_pool, &ipc_handler);
147+
if (umf_result != UMF_RESULT_SUCCESS) {
148+
fprintf(stderr, "[producer] ERROR: get IPC handler failed\n");
149+
goto err_destroy_scalable_pool;
150+
}
151+
145152
// connect to the producer
146153
producer_socket = consumer_connect_to_producer(port);
147154
if (producer_socket < 0) {
@@ -209,7 +216,7 @@ int main(int argc, char *argv[]) {
209216
len);
210217

211218
void *SHM_ptr;
212-
umf_result = umfOpenIPCHandle(scalable_pool, IPC_handle, &SHM_ptr);
219+
umf_result = umfOpenIPCHandle(ipc_handler, IPC_handle, &SHM_ptr);
213220
if (umf_result == UMF_RESULT_ERROR_NOT_SUPPORTED) {
214221
fprintf(stderr,
215222
"[consumer] SKIP: opening the IPC handle is not supported\n");

‎examples/ipc_level_zero/ipc_level_zero.c‎

Lines changed: 9 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -180,14 +180,21 @@ int main(void) {
180180

181181
fprintf(stdout, "Consumer pool created.\n");
182182

183+
umf_ipc_handler_handle_t ipc_handler = 0;
184+
umf_result = umfPoolGetIPCHandler(consumer_pool, &ipc_handler);
185+
if (umf_result != UMF_RESULT_SUCCESS) {
186+
fprintf(stderr, "ERROR: Failed to get IPC handler!\n");
187+
return -1;
188+
}
189+
183190
void *mapped_buf = NULL;
184-
umf_result = umfOpenIPCHandle(consumer_pool, ipc_handle, &mapped_buf);
191+
umf_result = umfOpenIPCHandle(ipc_handler, ipc_handle, &mapped_buf);
185192
if (umf_result != UMF_RESULT_SUCCESS) {
186193
fprintf(stderr, "ERROR: Failed to open IPC handle!\n");
187194
return -1;
188195
}
189196

190-
fprintf(stdout, "IPC handle opened in the consumer pool.\n");
197+
fprintf(stdout, "IPC handle opened.\n");
191198

192199
size_t *tmp_buf = malloc(BUFFER_SIZE);
193200
ret = level_zero_copy(consumer_context, device, tmp_buf, mapped_buf,

‎include/umf/ipc.h‎

Lines changed: 11 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,8 @@ extern "C" {
1919

2020
typedef struct umf_ipc_data_t *umf_ipc_handle_t;
2121

22+
typedef void *umf_ipc_handler_handle_t;
23+
2224
///
2325
/// @brief Returns the size of IPC handles for the specified pool.
2426
/// @param hPool [in] Pool handle
@@ -44,11 +46,11 @@ umf_result_t umfPutIPCHandle(umf_ipc_handle_t ipcHandle);
4446

4547
///
4648
/// @brief Open IPC handle retrieved by umfGetIPCHandle.
47-
/// @param hPool [in] Pool handle where to open the the IPC handle.
49+
/// @param hIPCHandler [in] IPC Handler handle used to open the IPC handle.
4850
/// @param ipcHandle [in] IPC handle.
4951
/// @param ptr [out] pointer to the memory in the current process.
5052
/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
51-
umf_result_t umfOpenIPCHandle(umf_memory_pool_handle_t hPool,
53+
umf_result_t umfOpenIPCHandle(umf_ipc_handler_handle_t hIPCHandler,
5254
umf_ipc_handle_t ipcHandle, void **ptr);
5355

5456
///
@@ -57,6 +59,13 @@ umf_result_t umfOpenIPCHandle(umf_memory_pool_handle_t hPool,
5759
/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
5860
umf_result_t umfCloseIPCHandle(void *ptr);
5961

62+
/// @brief Get handle to the IPC handler from existing pool.
63+
/// @param hPool [in] Pool handle
64+
/// @param hIPCHandler [out] handle to the IPC handler
65+
/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
66+
umf_result_t umfPoolGetIPCHandler(umf_memory_pool_handle_t hPool,
67+
umf_ipc_handler_handle_t *hIPCHandler);
68+
6069
#ifdef __cplusplus
6170
}
6271
#endif

‎src/ipc.c‎

Lines changed: 33 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -119,12 +119,18 @@ umf_result_t umfPutIPCHandle(umf_ipc_handle_t umfIPCHandle) {
119119
return ret;
120120
}
121121

122-
umf_result_t umfOpenIPCHandle(umf_memory_pool_handle_t hPool,
122+
umf_result_t umfOpenIPCHandle(umf_ipc_handler_handle_t hIPCHandler,
123123
umf_ipc_handle_t umfIPCHandle, void **ptr) {
124124

125-
// We cannot use umfPoolGetMemoryProvider function because it returns
126-
// upstream provider but we need tracking one
127-
umf_memory_provider_handle_t hProvider = hPool->provider;
125+
// IPC handler is an instance of tracking memory provider
126+
if (*(uint32_t *)hIPCHandler != UMF_VERSION_CURRENT) {
127+
// It is a temporary hack to verify that user passes correct IPC handler,
128+
// not a pool handle, as it was required in previous version.
129+
LOG_ERR("Invalid IPC handler.");
130+
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
131+
}
132+
133+
umf_memory_provider_handle_t hProvider = hIPCHandler;
128134
void *base = NULL;
129135

130136
umf_result_t ret = umfMemoryProviderOpenIPCHandle(
@@ -153,3 +159,26 @@ umf_result_t umfCloseIPCHandle(void *ptr) {
153159
return umfMemoryProviderCloseIPCHandle(hProvider, allocInfo.base,
154160
allocInfo.baseSize);
155161
}
162+
163+
umf_result_t umfPoolGetIPCHandler(umf_memory_pool_handle_t hPool,
164+
umf_ipc_handler_handle_t *hIPCHandler) {
165+
if (hPool == NULL) {
166+
LOG_ERR("Pool handle is NULL.");
167+
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
168+
}
169+
170+
if (hIPCHandler == NULL) {
171+
LOG_ERR("hIPCHandler is NULL.");
172+
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
173+
}
174+
175+
// We cannot use umfPoolGetMemoryProvider function because it returns
176+
// upstream provider but we need tracking one
177+
umf_memory_provider_handle_t hProvider = hPool->provider;
178+
179+
// We are using tracking provider as an IPC handler because
180+
// it is doing IPC caching.
181+
*hIPCHandler = (umf_ipc_handler_handle_t)hProvider;
182+
183+
return UMF_RESULT_SUCCESS;
184+
}

‎src/libumf.def‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -106,6 +106,7 @@ EXPORTS
106106
umfPoolCreateFromMemspace
107107
umfPoolDestroy
108108
umfPoolFree
109+
umfPoolGetIPCHandler
109110
umfPoolGetIPCHandleSize
110111
umfPoolGetLastAllocationError
111112
umfPoolGetMemoryProvider

‎src/libumf.map‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -100,6 +100,7 @@ UMF_1.0 {
100100
umfPoolCreateFromMemspace;
101101
umfPoolDestroy;
102102
umfPoolFree;
103+
umfPoolGetIPCHandler;
103104
umfPoolGetIPCHandleSize;
104105
umfPoolGetLastAllocationError;
105106
umfPoolGetMemoryProvider;

‎test/common/ipc_common.c‎

Lines changed: 8 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -138,6 +138,13 @@ int run_consumer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
138138
goto err_umfMemoryProviderDestroy;
139139
}
140140

141+
umf_ipc_handler_handle_t ipc_handler;
142+
umf_result = umfPoolGetIPCHandler(pool, &ipc_handler);
143+
if (umf_result != UMF_RESULT_SUCCESS) {
144+
fprintf(stderr, "[consumer] ERROR: get IPC handler failed\n");
145+
goto err_umfMemoryPoolDestroy;
146+
}
147+
141148
producer_socket = consumer_connect(port);
142149
if (producer_socket < 0) {
143150
goto err_umfMemoryPoolDestroy;
@@ -195,7 +202,7 @@ int run_consumer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
195202
len);
196203

197204
void *SHM_ptr;
198-
umf_result = umfOpenIPCHandle(pool, IPC_handle, &SHM_ptr);
205+
umf_result = umfOpenIPCHandle(ipc_handler, IPC_handle, &SHM_ptr);
199206
if (umf_result == UMF_RESULT_ERROR_NOT_SUPPORTED) {
200207
fprintf(stderr,
201208
"[consumer] SKIP: opening the IPC handle is not supported\n");

‎test/ipcFixtures.hpp‎

Lines changed: 47 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -194,12 +194,17 @@ TEST_P(umfIpcTest, BasicFlow) {
194194
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
195195
ASSERT_EQ(handleFullSize, handleHalfSize);
196196

197+
umf_ipc_handler_handle_t ipcHandler = nullptr;
198+
ret = umfPoolGetIPCHandler(pool.get(), &ipcHandler);
199+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
200+
ASSERT_NE(ipcHandler, nullptr);
201+
197202
void *fullArray = nullptr;
198-
ret = umfOpenIPCHandle(pool.get(), ipcHandleFull, &fullArray);
203+
ret = umfOpenIPCHandle(ipcHandler, ipcHandleFull, &fullArray);
199204
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
200205

201206
void *halfArray = nullptr;
202-
ret = umfOpenIPCHandle(pool.get(), ipcHandleHalf, &halfArray);
207+
ret = umfOpenIPCHandle(ipcHandler, ipcHandleHalf, &halfArray);
203208
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
204209

205210
std::vector<int> actual_data(SIZE);
@@ -262,8 +267,13 @@ TEST_P(umfIpcTest, GetPoolByOpenedHandle) {
262267

263268
for (size_t pool_id = 0; pool_id < NUM_POOLS; pool_id++) {
264269
void *ptr = nullptr;
270+
umf_ipc_handler_handle_t ipcHandler = nullptr;
265271
ret =
266-
umfOpenIPCHandle(pools_to_open[pool_id].get(), ipcHandle, &ptr);
272+
umfPoolGetIPCHandler(pools_to_open[pool_id].get(), &ipcHandler);
273+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
274+
ASSERT_NE(ipcHandler, nullptr);
275+
276+
ret = umfOpenIPCHandle(ipcHandler, ipcHandle, &ptr);
267277
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
268278
openedPtrs[pool_id][i] = ptr;
269279
}
@@ -296,16 +306,22 @@ TEST_P(umfIpcTest, GetPoolByOpenedHandle) {
296306
TEST_P(umfIpcTest, AllocFreeAllocTest) {
297307
constexpr size_t SIZE = 64 * 1024;
298308
umf::pool_unique_handle_t pool = makePool();
309+
umf_ipc_handler_handle_t ipcHandler = nullptr;
310+
311+
umf_result_t ret = umfPoolGetIPCHandler(pool.get(), &ipcHandler);
312+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
313+
ASSERT_NE(ipcHandler, nullptr);
314+
299315
void *ptr = umfPoolMalloc(pool.get(), SIZE);
300316
EXPECT_NE(ptr, nullptr);
301317

302318
umf_ipc_handle_t ipcHandle = nullptr;
303319
size_t handleSize = 0;
304-
umf_result_t ret = umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
320+
ret = umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
305321
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
306322

307323
void *opened_ptr = nullptr;
308-
ret = umfOpenIPCHandle(pool.get(), ipcHandle, &opened_ptr);
324+
ret = umfOpenIPCHandle(ipcHandler, ipcHandle, &opened_ptr);
309325
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
310326

311327
ret = umfCloseIPCHandle(opened_ptr);
@@ -327,7 +343,7 @@ TEST_P(umfIpcTest, AllocFreeAllocTest) {
327343
ret = umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
328344
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
329345

330-
ret = umfOpenIPCHandle(pool.get(), ipcHandle, &opened_ptr);
346+
ret = umfOpenIPCHandle(ipcHandler, ipcHandle, &opened_ptr);
331347
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
332348

333349
ret = umfCloseIPCHandle(opened_ptr);
@@ -345,11 +361,22 @@ TEST_P(umfIpcTest, AllocFreeAllocTest) {
345361
EXPECT_EQ(stat.openCount, stat.closeCount);
346362
}
347363

348-
TEST_P(umfIpcTest, openInTwoPools) {
364+
TEST_P(umfIpcTest, openInTwoIpcHandlers) {
349365
constexpr size_t SIZE = 100;
350366
std::vector<int> expected_data(SIZE);
351367
umf::pool_unique_handle_t pool1 = makePool();
352368
umf::pool_unique_handle_t pool2 = makePool();
369+
umf_ipc_handler_handle_t ipcHandler1 = nullptr;
370+
umf_ipc_handler_handle_t ipcHandler2 = nullptr;
371+
372+
umf_result_t ret = umfPoolGetIPCHandler(pool1.get(), &ipcHandler1);
373+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
374+
ASSERT_NE(ipcHandler1, nullptr);
375+
376+
ret = umfPoolGetIPCHandler(pool2.get(), &ipcHandler2);
377+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
378+
ASSERT_NE(ipcHandler2, nullptr);
379+
353380
void *ptr = umfPoolMalloc(pool1.get(), sizeof(expected_data[0]) * SIZE);
354381
EXPECT_NE(ptr, nullptr);
355382

@@ -358,15 +385,15 @@ TEST_P(umfIpcTest, openInTwoPools) {
358385

359386
umf_ipc_handle_t ipcHandle = nullptr;
360387
size_t handleSize = 0;
361-
umf_result_t ret = umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
388+
ret = umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
362389
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
363390

364391
void *openedPtr1 = nullptr;
365-
ret = umfOpenIPCHandle(pool1.get(), ipcHandle, &openedPtr1);
392+
ret = umfOpenIPCHandle(ipcHandler1, ipcHandle, &openedPtr1);
366393
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
367394

368395
void *openedPtr2 = nullptr;
369-
ret = umfOpenIPCHandle(pool2.get(), ipcHandle, &openedPtr2);
396+
ret = umfOpenIPCHandle(ipcHandler2, ipcHandle, &openedPtr2);
370397
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
371398

372399
ret = umfPutIPCHandle(ipcHandle);
@@ -447,6 +474,7 @@ TEST_P(umfIpcTest, ConcurrentGetPutHandles) {
447474
}
448475

449476
TEST_P(umfIpcTest, ConcurrentOpenCloseHandles) {
477+
umf_result_t ret;
450478
std::vector<void *> ptrs;
451479
constexpr size_t ALLOC_SIZE = 100;
452480
constexpr size_t NUM_POINTERS = 100;
@@ -462,21 +490,25 @@ TEST_P(umfIpcTest, ConcurrentOpenCloseHandles) {
462490
for (size_t i = 0; i < NUM_POINTERS; ++i) {
463491
umf_ipc_handle_t ipcHandle;
464492
size_t handleSize;
465-
umf_result_t ret = umfGetIPCHandle(ptrs[i], &ipcHandle, &handleSize);
493+
ret = umfGetIPCHandle(ptrs[i], &ipcHandle, &handleSize);
466494
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
467495
ipcHandles[i] = ipcHandle;
468496
}
469497

470498
std::array<std::vector<void *>, NTHREADS> openedIpcHandles;
499+
umf_ipc_handler_handle_t ipcHandler = nullptr;
500+
ret = umfPoolGetIPCHandler(pool.get(), &ipcHandler);
501+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
502+
ASSERT_NE(ipcHandler, nullptr);
471503

472504
umf_test::syncthreads_barrier syncthreads(NTHREADS);
473505

474506
auto openHandlesFn = [&ipcHandles, &openedIpcHandles, &syncthreads,
475-
&pool](size_t tid) {
507+
ipcHandler](size_t tid) {
476508
syncthreads();
477509
for (auto ipcHandle : ipcHandles) {
478510
void *ptr;
479-
umf_result_t ret = umfOpenIPCHandle(pool.get(), ipcHandle, &ptr);
511+
umf_result_t ret = umfOpenIPCHandle(ipcHandler, ipcHandle, &ptr);
480512
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
481513
openedIpcHandles[tid].push_back(ptr);
482514
}
@@ -495,12 +527,12 @@ TEST_P(umfIpcTest, ConcurrentOpenCloseHandles) {
495527
umf_test::parallel_exec(NTHREADS, closeHandlesFn);
496528

497529
for (auto ipcHandle : ipcHandles) {
498-
umf_result_t ret = umfPutIPCHandle(ipcHandle);
530+
ret = umfPutIPCHandle(ipcHandle);
499531
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
500532
}
501533

502534
for (void *ptr : ptrs) {
503-
umf_result_t ret = umfPoolFree(pool.get(), ptr);
535+
ret = umfPoolFree(pool.get(), ptr);
504536
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
505537
}
506538

‎test/ipc_negative.cpp‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,11 @@ TEST_F(IpcNotSupported, OpenIPCHandleNotSupported) {
4747
// This data doesn't matter, as the ipc call is no-op
4848
std::array<uint8_t, 128> ipc_data = {};
4949
void *ptr;
50-
auto ret = umfOpenIPCHandle(
51-
pool, reinterpret_cast<umf_ipc_handle_t>(&ipc_data), &ptr);
50+
umf_ipc_handler_handle_t ipc_handler;
51+
auto ret = umfPoolGetIPCHandler(pool, &ipc_handler);
52+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
53+
54+
ret = umfOpenIPCHandle(ipc_handler,
55+
reinterpret_cast<umf_ipc_handle_t>(&ipc_data), &ptr);
5256
EXPECT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
5357
}

0 commit comments

Comments
 (0)