use Pool instead of Provider IPC API in tests

Author: bratpiorka

test/common/ipc_common.c

@@ -131,6 +131,9 @@ int run_consumer(int port, umf_memory_provider_ops_t *provider_ops,
         return -1;
     }
 
+    umf_memory_pool_handle_t pool;
+    umf_result = umfPoolCreate(umfScalablePoolOps(), provider, NULL, 0, &pool);
+
     producer_socket = consumer_connect(port);
     if (producer_socket < 0) {
         goto err_umfMemoryProviderDestroy;
@@ -183,7 +186,7 @@ int run_consumer(int port, umf_memory_provider_ops_t *provider_ops,
         len);
 
     void *SHM_ptr;
-    umf_result = umfMemoryProviderOpenIPCHandle(provider, IPC_handle, &SHM_ptr);
+    umf_result = umfOpenIPCHandle(pool, IPC_handle, &SHM_ptr);
     if (umf_result == UMF_RESULT_ERROR_NOT_SUPPORTED) {
         fprintf(stderr,
                 "[consumer] SKIP: opening the IPC handle is not supported\n");
@@ -240,8 +243,7 @@ int run_consumer(int port, umf_memory_provider_ops_t *provider_ops,
 
 err_closeIPCHandle:
     // we do not know the exact size of the remote shared memory
-    umf_result = umfMemoryProviderCloseIPCHandle(provider, SHM_ptr,
-                                                 sizeof(unsigned long long));
+    umf_result = umfCloseIPCHandle(pool, SHM_ptr, sizeof(unsigned long long));
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "[consumer] ERROR: closing the IPC handle failed\n");
     }
@@ -254,6 +256,7 @@ int run_consumer(int port, umf_memory_provider_ops_t *provider_ops,
 
 err_umfMemoryProviderDestroy:
     umfMemoryProviderDestroy(provider);
+    umfPoolDestroy(pool);
 
     if (ret == 0) {
         fprintf(stderr, "[consumer] Shutting down (status OK) ...\n");
@@ -321,6 +324,9 @@ int run_producer(int port, umf_memory_provider_ops_t *provider_ops,
         return -1;
     }
 
+    umf_memory_pool_handle_t pool;
+    umf_result = umfPoolCreate(umfScalablePoolOps(), provider, NULL, 0, &pool);
+
     size_t page_size;
     umf_result = umfMemoryProviderGetMinPageSize(provider, NULL, &page_size);
     if (umf_result != UMF_RESULT_SUCCESS) {
@@ -335,28 +341,27 @@ int run_producer(int port, umf_memory_provider_ops_t *provider_ops,
     size_t ptr2_size = 2 * page_size;
     size_t size_IPC_shared_memory = 3 * page_size;
 
-    umf_result = umfMemoryProviderAlloc(provider, ptr1_size, 0, &ptr1);
-    if (umf_result != UMF_RESULT_SUCCESS) {
+    ptr1 = umfPoolMalloc(pool, ptr1_size);
+    if (ptr1 == NULL) {
         fprintf(stderr, "[producer] ERROR: allocating 1 page failed\n");
         goto err_umfMemoryProviderDestroy;
     }
 
-    umf_result = umfMemoryProviderAlloc(provider, ptr2_size, 0, &ptr2);
-    if (umf_result != UMF_RESULT_SUCCESS) {
+    ptr2 = umfPoolMalloc(pool, ptr2_size);
+    if (ptr2 == NULL) {
         fprintf(stderr, "[producer] ERROR: allocating 2 pages failed\n");
         goto err_free_ptr1;
     }
 
-    umf_result = umfMemoryProviderAlloc(provider, size_IPC_shared_memory, 0,
-                                        &IPC_shared_memory);
-    if (umf_result != UMF_RESULT_SUCCESS) {
+    IPC_shared_memory = umfPoolMalloc(pool, size_IPC_shared_memory);
+    if (IPC_shared_memory == NULL) {
         fprintf(stderr, "[producer] ERROR: allocating 3 pages failed\n");
         goto err_free_ptr2;
     }
 
     // get size of the IPC handle
     size_t IPC_handle_size;
-    umf_result = umfMemoryProviderGetIPCHandleSize(provider, &IPC_handle_size);
+    umf_result = umfPoolGetIPCHandleSize(pool, &IPC_handle_size);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr,
                 "[producer] ERROR: getting size of the IPC handle failed\n");
@@ -383,8 +388,8 @@ int run_producer(int port, umf_memory_provider_ops_t *provider_ops,
             SHM_number_1);
 
     // get the IPC handle from the OS memory provider
-    umf_result = umfMemoryProviderGetIPCHandle(
-        provider, IPC_shared_memory, size_IPC_shared_memory, IPC_handle);
+    umf_result = umfGetIPCHandle(pool, IPC_shared_memory,
+                                 size_IPC_shared_memory, IPC_handle);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr,
                 "[producer] ERROR: getting the IPC handle from the OS memory "
@@ -494,7 +499,7 @@ int run_producer(int port, umf_memory_provider_ops_t *provider_ops,
     close(producer_socket);
 
 err_PutIPCHandle:
-    umf_result = umfMemoryProviderPutIPCHandle(provider, IPC_handle);
+    umf_result = umfPutIPCHandle(provider, IPC_handle);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "[producer] ERROR: putting the IPC handle failed\n");
     }
@@ -503,15 +508,19 @@ int run_producer(int port, umf_memory_provider_ops_t *provider_ops,
 
 err_free_IPC_handle:
     free(IPC_handle);
+
 err_free_IPC_shared_memory:
-    (void)umfMemoryProviderFree(provider, IPC_shared_memory,
-                                size_IPC_shared_memory);
+    (void)umfFree(IPC_shared_memory);
+
 err_free_ptr2:
-    (void)umfMemoryProviderFree(provider, ptr2, ptr2_size);
+    (void)umfFree(ptr2);
+
 err_free_ptr1:
-    (void)umfMemoryProviderFree(provider, ptr1, ptr1_size);
+    (void)umfFree(ptr1);
+
 err_umfMemoryProviderDestroy:
     umfMemoryProviderDestroy(provider);
+    umfPoolDestroy(pool);
 
     if (ret == 0) {
         fprintf(stderr, "[producer] Shutting down (status OK) ...\n");

test/common/ipc_common.h

@@ -8,7 +8,9 @@
 #ifndef UMF_TEST_IPC_COMMON_H
 #define UMF_TEST_IPC_COMMON_H
 
+#include <umf/memory_pool.h>
 #include <umf/memory_provider.h>
+#include <umf/pools/pool_scalable.h>
 
 // pointer to the function that returns void and accept two int values
 typedef void (*memcopy_callback_t)(void *dst, const void *src, size_t size,