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(SHM_ptr);
     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,45 +341,38 @@ 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);
-    if (umf_result != UMF_RESULT_SUCCESS) {
-        fprintf(stderr,
-                "[producer] ERROR: getting size of the IPC handle failed\n");
-        goto err_free_IPC_shared_memory;
-    }
+    umf_ipc_handle_t IPC_handle = NULL;
 
-    // allocate data for IPC provider
-    void *IPC_handle = malloc(IPC_handle_size);
-    if (IPC_handle == NULL) {
+    // get the IPC handle from the OS memory provider
+    umf_result =
+        umfGetIPCHandle(IPC_shared_memory, &IPC_handle, &IPC_handle_size);
+    if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr,
-                "[producer] ERROR: allocating memory for IPC handle failed\n");
+                "[producer] ERROR: getting the IPC handle from the OS memory "
+                "provider failed\n");
         goto err_free_IPC_shared_memory;
     }
 
-    // zero the IPC handle and the shared memory
-    memset(IPC_handle, 0, IPC_handle_size);
-
     // save a random number (&provider) in the shared memory
     unsigned long long SHM_number_1 = (unsigned long long)&provider;
     memcopy_callback(IPC_shared_memory, &SHM_number_1, sizeof(SHM_number_1),
@@ -382,16 +381,6 @@ int run_producer(int port, umf_memory_provider_ops_t *provider_ops,
     fprintf(stderr, "[producer] My shared memory contains a number: %llu\n",
             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);
-    if (umf_result != UMF_RESULT_SUCCESS) {
-        fprintf(stderr,
-                "[producer] ERROR: getting the IPC handle from the OS memory "
-                "provider failed\n");
-        goto err_free_IPC_handle;
-    }
-
     fprintf(stderr, "[producer] Got the IPC handle\n");
 
     producer_socket = producer_connect(port);
@@ -494,23 +483,24 @@ 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(IPC_handle);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "[producer] ERROR: putting the IPC handle failed\n");
     }
 
     fprintf(stderr, "[producer] Put the IPC handle\n");
 
-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:
+    umfPoolDestroy(pool);
     umfMemoryProviderDestroy(provider);
 
     if (ret == 0) {

test/common/ipc_common.h

@@ -8,7 +8,10 @@
 #ifndef UMF_TEST_IPC_COMMON_H
 #define UMF_TEST_IPC_COMMON_H
 
+#include <umf/ipc.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,