Merge pull request #823 from bratpiorka/rrudnick_use_pools

use pools not only providers in IPC tests

Author: ldorau

test/CMakeLists.txt

@@ -397,13 +397,14 @@ function(add_umf_ipc_test)
         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
     set_tests_properties(${TEST_NAME} PROPERTIES LABELS "umf")
+    set_tests_properties(${TEST_NAME} PROPERTIES TIMEOUT 60)
     if(NOT UMF_TESTS_FAIL_ON_SKIP)
         set_tests_properties(${TEST_NAME} PROPERTIES SKIP_RETURN_CODE 125)
     endif()
 endfunction()
 
 if(LINUX)
-    if(NOT UMF_DISABLE_HWLOC)
+    if(NOT UMF_DISABLE_HWLOC AND UMF_POOL_SCALABLE_ENABLED)
         build_umf_test(
             NAME
             ipc_os_prov_consumer
@@ -457,7 +458,9 @@ if(LINUX)
 
     # TODO add IPC tests for CUDA
 
-    if(UMF_BUILD_GPU_TESTS AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
+    if(UMF_BUILD_GPU_TESTS
+       AND UMF_BUILD_LEVEL_ZERO_PROVIDER
+       AND UMF_BUILD_LIBUMF_POOL_DISJOINT)
         build_umf_test(
             NAME
             ipc_level_zero_prov_consumer
@@ -468,6 +471,7 @@ if(LINUX)
             providers/level_zero_helpers.cpp
             LIBS
             ze_loader
+            disjoint_pool
             ${UMF_UTILS_FOR_TEST})
         build_umf_test(
             NAME
@@ -479,6 +483,7 @@ if(LINUX)
             providers/level_zero_helpers.cpp
             LIBS
             ze_loader
+            disjoint_pool
             ${UMF_UTILS_FOR_TEST})
         target_include_directories(umf_test-ipc_level_zero_prov_producer
                                    PRIVATE ${LEVEL_ZERO_INCLUDE_DIRS})

test/common/ipc_common.c

@@ -110,9 +110,9 @@ int consumer_connect(int port) {
     return ret;
 }
 
-int run_consumer(int port, umf_memory_provider_ops_t *provider_ops,
-                 void *provider_params, memcopy_callback_t memcopy_callback,
-                 void *memcopy_ctx) {
+int run_consumer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
+                 umf_memory_provider_ops_t *provider_ops, void *provider_params,
+                 memcopy_callback_t memcopy_callback, void *memcopy_ctx) {
     char consumer_message[MSG_SIZE];
     int producer_socket = -1;
     int ret = -1;
@@ -131,16 +131,23 @@ int run_consumer(int port, umf_memory_provider_ops_t *provider_ops,
         return -1;
     }
 
+    umf_memory_pool_handle_t pool;
+    umf_result = umfPoolCreate(pool_ops, provider, pool_params, 0, &pool);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "[consumer] ERROR: creating memory pool failed\n");
+        goto err_umfMemoryProviderDestroy;
+    }
+
     producer_socket = consumer_connect(port);
     if (producer_socket < 0) {
-        goto err_umfMemoryProviderDestroy;
+        goto err_umfMemoryPoolDestroy;
     }
 
     // allocate the zeroed receive buffer
     char *recv_buffer = calloc(1, MSG_SIZE);
     if (!recv_buffer) {
         fprintf(stderr, "[consumer] ERROR: out of memory\n");
-        goto err_umfMemoryProviderDestroy;
+        goto err_umfMemoryPoolDestroy;
     }
 
     // get the size of the IPC handle from the producer
@@ -183,7 +190,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 +247,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");
     }
@@ -252,6 +258,9 @@ int run_consumer(int port, umf_memory_provider_ops_t *provider_ops,
 err_close_producer_socket:
     close(producer_socket);
 
+err_umfMemoryPoolDestroy:
+    umfPoolDestroy(pool);
+
 err_umfMemoryProviderDestroy:
     umfMemoryProviderDestroy(provider);
 
@@ -303,9 +312,9 @@ int producer_connect(int port) {
     return -1;
 }
 
-int run_producer(int port, umf_memory_provider_ops_t *provider_ops,
-                 void *provider_params, memcopy_callback_t memcopy_callback,
-                 void *memcopy_ctx) {
+int run_producer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
+                 umf_memory_provider_ops_t *provider_ops, void *provider_params,
+                 memcopy_callback_t memcopy_callback, void *memcopy_ctx) {
     int ret = -1;
     umf_memory_provider_handle_t provider = NULL;
     umf_result_t umf_result = UMF_RESULT_ERROR_UNKNOWN;
@@ -321,12 +330,19 @@ int run_producer(int port, umf_memory_provider_ops_t *provider_ops,
         return -1;
     }
 
+    umf_memory_pool_handle_t pool;
+    umf_result = umfPoolCreate(pool_ops, provider, pool_params, 0, &pool);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "[producer] ERROR: creating memory pool failed\n");
+        goto err_umfMemoryProviderDestroy;
+    }
+
     size_t page_size;
     umf_result = umfMemoryProviderGetMinPageSize(provider, NULL, &page_size);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr,
                 "[producer] ERROR: getting the minimum page size failed\n");
-        goto err_umfMemoryProviderDestroy;
+        goto err_umfMemoryPoolDestroy;
     }
 
     // Make 3 allocations of size: 1 page, 2 pages and 3 pages
@@ -335,45 +351,36 @@ 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;
+        goto err_umfMemoryPoolDestroy;
     }
 
-    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) {
-        fprintf(stderr,
-                "[producer] ERROR: allocating memory for IPC handle failed\n");
+    // get the IPC handle
+    umf_result =
+        umfGetIPCHandle(IPC_shared_memory, &IPC_handle, &IPC_handle_size);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "[producer] ERROR: getting the IPC handle 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 +389,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,22 +491,25 @@ 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_umfMemoryPoolDestroy:
+    umfPoolDestroy(pool);
+
 err_umfMemoryProviderDestroy:
     umfMemoryProviderDestroy(provider);
 

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,
@@ -17,11 +20,12 @@ typedef void (*memcopy_callback_t)(void *dst, const void *src, size_t size,
 int producer_connect(int port);
 int consumer_connect(int port);
 
-int run_producer(int port, umf_memory_provider_ops_t *provider_ops,
-                 void *provider_params, memcopy_callback_t memcopy_callback,
-                 void *memcopy_ctx);
-int run_consumer(int port, umf_memory_provider_ops_t *provider_ops,
-                 void *provider_params, memcopy_callback_t memcopy_callback,
-                 void *memcopy_ctx);
+int run_producer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
+                 umf_memory_provider_ops_t *provider_ops, void *provider_params,
+                 memcopy_callback_t memcopy_callback, void *memcopy_ctx);
+
+int run_consumer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
+                 umf_memory_provider_ops_t *provider_ops, void *provider_params,
+                 memcopy_callback_t memcopy_callback, void *memcopy_ctx);
 
 #endif // UMF_TEST_IPC_COMMON_H

test/ipc_devdax_prov_consumer.c

@@ -36,6 +36,9 @@ int main(int argc, char *argv[]) {
     umf_devdax_memory_provider_params_t devdax_params =
         umfDevDaxMemoryProviderParamsDefault(path, atol(size));
 
-    return run_consumer(port, umfDevDaxMemoryProviderOps(), &devdax_params,
-                        memcopy, NULL);
+    void *pool_params = NULL;
+
+    return run_consumer(port, umfScalablePoolOps(), pool_params,
+                        umfDevDaxMemoryProviderOps(), &devdax_params, memcopy,
+                        NULL);
 }

test/ipc_devdax_prov_producer.c

@@ -36,6 +36,9 @@ int main(int argc, char *argv[]) {
     umf_devdax_memory_provider_params_t devdax_params =
         umfDevDaxMemoryProviderParamsDefault(path, atol(size));
 
-    return run_producer(port, umfDevDaxMemoryProviderOps(), &devdax_params,
-                        memcopy, NULL);
+    void *pool_params = NULL;
+
+    return run_producer(port, umfScalablePoolOps(), pool_params,
+                        umfDevDaxMemoryProviderOps(), &devdax_params, memcopy,
+                        NULL);
 }

test/ipc_file_prov_consumer.c

@@ -43,6 +43,9 @@ int main(int argc, char *argv[]) {
         file_params.visibility = UMF_MEM_MAP_SHARED;
     }
 
-    return run_consumer(port, umfFileMemoryProviderOps(), &file_params, memcopy,
+    void *pool_params = NULL;
+
+    return run_consumer(port, umfScalablePoolOps(), pool_params,
+                        umfFileMemoryProviderOps(), &file_params, memcopy,
                         NULL);
 }

test/ipc_file_prov_producer.c

@@ -43,6 +43,9 @@ int main(int argc, char *argv[]) {
         file_params.visibility = UMF_MEM_MAP_SHARED;
     }
 
-    return run_producer(port, umfFileMemoryProviderOps(), &file_params, memcopy,
+    void *pool_params = NULL;
+
+    return run_producer(port, umfScalablePoolOps(), pool_params,
+                        umfFileMemoryProviderOps(), &file_params, memcopy,
                         NULL);
 }

test/ipc_os_prov_consumer.c

@@ -29,6 +29,8 @@ int main(int argc, char *argv[]) {
         os_params.shm_name = argv[2];
     }
 
-    return run_consumer(port, umfOsMemoryProviderOps(), &os_params, memcopy,
-                        NULL);
+    void *pool_params = NULL;
+
+    return run_consumer(port, umfScalablePoolOps(), pool_params,
+                        umfOsMemoryProviderOps(), &os_params, memcopy, NULL);
 }

test/ipc_os_prov_producer.c

@@ -29,6 +29,8 @@ int main(int argc, char *argv[]) {
         os_params.shm_name = argv[2];
     }
 
-    return run_producer(port, umfOsMemoryProviderOps(), &os_params, memcopy,
-                        NULL);
+    void *pool_params = NULL;
+
+    return run_producer(port, umfScalablePoolOps(), pool_params,
+                        umfOsMemoryProviderOps(), &os_params, memcopy, NULL);
 }

test/providers/ipc_level_zero_prov_consumer.c

@@ -8,6 +8,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <umf/pools/pool_disjoint.h>
 #include <umf/providers/provider_level_zero.h>
 
 #include "ipc_common.h"
@@ -25,6 +26,9 @@ int main(int argc, char *argv[]) {
     level_zero_memory_provider_params_t l0_params =
         create_level_zero_prov_params(UMF_MEMORY_TYPE_DEVICE);
 
-    return run_consumer(port, umfLevelZeroMemoryProviderOps(), &l0_params,
-                        memcopy, &l0_params);
+    umf_disjoint_pool_params_t pool_params = umfDisjointPoolParamsDefault();
+
+    return run_consumer(port, umfDisjointPoolOps(), &pool_params,
+                        umfLevelZeroMemoryProviderOps(), &l0_params, memcopy,
+                        &l0_params);
 }