From 28ff4a4227635dbf386b642955046114423b73f2 Mon Sep 17 00:00:00 2001 From: Lukasz Dorau Date: Fri, 25 Oct 2024 09:46:25 +0200 Subject: [PATCH 1/7] Rename utils_align_ptr_size() to utils_align_ptr_up_size_down() Signed-off-by: Lukasz Dorau --- src/base_alloc/base_alloc.c | 6 ++++-- src/base_alloc/base_alloc_linear.c | 4 ++-- src/utils/utils_common.c | 4 ++-- src/utils/utils_common.h | 4 ++-- 4 files changed, 10 insertions(+), 8 deletions(-) diff --git a/src/base_alloc/base_alloc.c b/src/base_alloc/base_alloc.c index 353e5058d..7a98684c6 100644 --- a/src/base_alloc/base_alloc.c +++ b/src/base_alloc/base_alloc.c @@ -168,7 +168,8 @@ umf_ba_pool_t *umf_ba_create(size_t size) { char *data_ptr = (char *)&pool->data; size_t size_left = pool_size - offsetof(umf_ba_pool_t, data); - utils_align_ptr_size((void **)&data_ptr, &size_left, MEMORY_ALIGNMENT); + utils_align_ptr_up_size_down((void **)&data_ptr, &size_left, + MEMORY_ALIGNMENT); // init free_lock utils_mutex_t *mutex = utils_mutex_init(&pool->metadata.free_lock); @@ -209,7 +210,8 @@ void *umf_ba_alloc(umf_ba_pool_t *pool) { size_t size_left = pool->metadata.pool_size - offsetof(umf_ba_next_pool_t, data); - utils_align_ptr_size((void **)&data_ptr, &size_left, MEMORY_ALIGNMENT); + utils_align_ptr_up_size_down((void **)&data_ptr, &size_left, + MEMORY_ALIGNMENT); ba_divide_memory_into_chunks(pool, data_ptr, size_left); } diff --git a/src/base_alloc/base_alloc_linear.c b/src/base_alloc/base_alloc_linear.c index de4ac0b1e..8773e5cab 100644 --- a/src/base_alloc/base_alloc_linear.c +++ b/src/base_alloc/base_alloc_linear.c @@ -98,7 +98,7 @@ umf_ba_linear_pool_t *umf_ba_linear_create(size_t pool_size) { void *data_ptr = &pool->data; size_t size_left = pool_size - offsetof(umf_ba_linear_pool_t, data); - utils_align_ptr_size(&data_ptr, &size_left, MEMORY_ALIGNMENT); + utils_align_ptr_up_size_down(&data_ptr, &size_left, MEMORY_ALIGNMENT); pool->metadata.pool_size = pool_size; pool->metadata.data_ptr = data_ptr; @@ -149,7 +149,7 @@ void *umf_ba_linear_alloc(umf_ba_linear_pool_t *pool, size_t size) { void *data_ptr = &new_pool->data; size_t size_left = new_pool->pool_size - offsetof(umf_ba_next_linear_pool_t, data); - utils_align_ptr_size(&data_ptr, &size_left, MEMORY_ALIGNMENT); + utils_align_ptr_up_size_down(&data_ptr, &size_left, MEMORY_ALIGNMENT); pool->metadata.data_ptr = data_ptr; pool->metadata.size_left = size_left; diff --git a/src/utils/utils_common.c b/src/utils/utils_common.c index cf1a953df..1c62dcba9 100644 --- a/src/utils/utils_common.c +++ b/src/utils/utils_common.c @@ -12,8 +12,8 @@ #include "utils_assert.h" #include "utils_common.h" -// align a pointer and a size -void utils_align_ptr_size(void **ptr, size_t *size, size_t alignment) { +// align a pointer up and a size down +void utils_align_ptr_up_size_down(void **ptr, size_t *size, size_t alignment) { uintptr_t p = (uintptr_t)*ptr; size_t s = *size; diff --git a/src/utils/utils_common.h b/src/utils/utils_common.h index e5fea27e7..924a0ec77 100644 --- a/src/utils/utils_common.h +++ b/src/utils/utils_common.h @@ -82,8 +82,8 @@ int utils_is_running_in_proxy_lib(void); size_t utils_get_page_size(void); -// align a pointer and a size -void utils_align_ptr_size(void **ptr, size_t *size, size_t alignment); +// align a pointer up and a size down +void utils_align_ptr_up_size_down(void **ptr, size_t *size, size_t alignment); // get the current process ID int utils_getpid(void); From d72a84187e14981620aae9e24748d8960c504bad Mon Sep 17 00:00:00 2001 From: Lukasz Dorau Date: Fri, 25 Oct 2024 10:01:23 +0200 Subject: [PATCH 2/7] Add utils_align_ptr_down_size_up() Add utils_align_ptr_down_size_up() to align a pointer down and a size up (for mmap()/munmap()). Signed-off-by: Lukasz Dorau --- src/utils/utils_common.c | 30 ++++++++++++++++++++++++++---- src/utils/utils_common.h | 3 +++ 2 files changed, 29 insertions(+), 4 deletions(-) diff --git a/src/utils/utils_common.c b/src/utils/utils_common.c index 1c62dcba9..25169f6cf 100644 --- a/src/utils/utils_common.c +++ b/src/utils/utils_common.c @@ -17,15 +17,37 @@ void utils_align_ptr_up_size_down(void **ptr, size_t *size, size_t alignment) { uintptr_t p = (uintptr_t)*ptr; size_t s = *size; - // align pointer to 'alignment' bytes and adjust the size + // align the pointer up to 'alignment' bytes and adjust the size down size_t rest = p & (alignment - 1); if (rest) { - p += alignment - rest; + p = ALIGN_UP(p, alignment); s -= alignment - rest; } - ASSERT((p & (alignment - 1)) == 0); - ASSERT((s & (alignment - 1)) == 0); + ASSERT(IS_ALIGNED(p, alignment)); + ASSERT(IS_ALIGNED(s, alignment)); + + *ptr = (void *)p; + *size = s; +} + +// align a pointer down and a size up (for mmap()/munmap()) +void utils_align_ptr_down_size_up(void **ptr, size_t *size, size_t alignment) { + uintptr_t p = (uintptr_t)*ptr; + size_t s = *size; + + // align the pointer down to 'alignment' bytes and adjust the size up + size_t rest = p & (alignment - 1); + if (rest) { + p = ALIGN_DOWN(p, alignment); + s += rest; + } + + // align the size up to 'alignment' bytes + s = ALIGN_UP(s, alignment); + + ASSERT(IS_ALIGNED(p, alignment)); + ASSERT(IS_ALIGNED(s, alignment)); *ptr = (void *)p; *size = s; diff --git a/src/utils/utils_common.h b/src/utils/utils_common.h index 924a0ec77..25a840d97 100644 --- a/src/utils/utils_common.h +++ b/src/utils/utils_common.h @@ -85,6 +85,9 @@ size_t utils_get_page_size(void); // align a pointer up and a size down void utils_align_ptr_up_size_down(void **ptr, size_t *size, size_t alignment); +// align a pointer down and a size up (for mmap()/munmap()) +void utils_align_ptr_down_size_up(void **ptr, size_t *size, size_t alignment); + // get the current process ID int utils_getpid(void); From a4f1c8bf7cfc8ee212db79b4f85d2f211a6e4aa3 Mon Sep 17 00:00:00 2001 From: Lukasz Dorau Date: Mon, 28 Oct 2024 10:39:15 +0100 Subject: [PATCH 3/7] Fix devdax_open_ipc_handle() and devdax_close_ipc_handle() devdax_open_ipc_handle() has to use the path of the remote /dev/dax got from the IPC handle, not the local one. devdax_open_ipc_handle() has to use also the memory protection got from the IPC handle, so let's add the memory protection to the IPC handle. devdax_open_ipc_handle() should mmap only the required range of memory, not the whole /dev/dax device, so let's add the length of the allocation to the IPC handle. devdax_close_ipc_handle() should unmap only the required range of memory, not the whole /dev/dax device. Signed-off-by: Lukasz Dorau --- src/provider/provider_devdax_memory.c | 106 +++++++++++++------------- 1 file changed, 52 insertions(+), 54 deletions(-) diff --git a/src/provider/provider_devdax_memory.c b/src/provider/provider_devdax_memory.c index 544960995..76d5e4562 100644 --- a/src/provider/provider_devdax_memory.c +++ b/src/provider/provider_devdax_memory.c @@ -31,7 +31,8 @@ umf_memory_provider_ops_t *umfDevDaxMemoryProviderOps(void) { #include "utils_concurrency.h" #include "utils_log.h" -#define NODESET_STR_BUF_LEN 1024 +// the default alignment for the devdax mode +#define DEVDAX_ALIGNMENT_2MB (2 * 1024 * 1024) // == 2 MB #define TLS_MSG_BUF_LEN 1024 @@ -300,7 +301,8 @@ static umf_result_t devdax_get_recommended_page_size(void *provider, return UMF_RESULT_ERROR_INVALID_ARGUMENT; } - *page_size = utils_get_page_size(); + // the default alignment for the devdax mode + *page_size = DEVDAX_ALIGNMENT_2MB; return UMF_RESULT_SUCCESS; } @@ -369,9 +371,11 @@ static umf_result_t devdax_allocation_merge(void *provider, void *lowPtr, } typedef struct devdax_ipc_data_t { - char dd_path[PATH_MAX]; // path to the /dev/dax - size_t dd_size; // size of the /dev/dax - size_t offset; // offset of the data + char path[PATH_MAX]; // path to the /dev/dax + unsigned protection; // combination of OS-specific memory protection flags + // offset of the data (from the beginning of the devdax mapping) - see devdax_get_ipc_handle() + size_t offset; + size_t length; // length of the data } devdax_ipc_data_t; static umf_result_t devdax_get_ipc_handle_size(void *provider, size_t *size) { @@ -386,8 +390,6 @@ static umf_result_t devdax_get_ipc_handle_size(void *provider, size_t *size) { static umf_result_t devdax_get_ipc_handle(void *provider, const void *ptr, size_t size, void *providerIpcData) { - (void)size; // unused - if (provider == NULL || ptr == NULL || providerIpcData == NULL) { return UMF_RESULT_ERROR_INVALID_ARGUMENT; } @@ -396,11 +398,12 @@ static umf_result_t devdax_get_ipc_handle(void *provider, const void *ptr, (devdax_memory_provider_t *)provider; devdax_ipc_data_t *devdax_ipc_data = (devdax_ipc_data_t *)providerIpcData; + strncpy(devdax_ipc_data->path, devdax_provider->path, PATH_MAX - 1); + devdax_ipc_data->path[PATH_MAX - 1] = '\0'; + devdax_ipc_data->protection = devdax_provider->protection; devdax_ipc_data->offset = (size_t)((uintptr_t)ptr - (uintptr_t)devdax_provider->base); - strncpy(devdax_ipc_data->dd_path, devdax_provider->path, PATH_MAX - 1); - devdax_ipc_data->dd_path[PATH_MAX - 1] = '\0'; - devdax_ipc_data->dd_size = devdax_provider->size; + devdax_ipc_data->length = size; return UMF_RESULT_SUCCESS; } @@ -416,16 +419,9 @@ static umf_result_t devdax_put_ipc_handle(void *provider, devdax_ipc_data_t *devdax_ipc_data = (devdax_ipc_data_t *)providerIpcData; // verify the path of the /dev/dax - if (strncmp(devdax_ipc_data->dd_path, devdax_provider->path, PATH_MAX)) { + if (strncmp(devdax_ipc_data->path, devdax_provider->path, PATH_MAX)) { LOG_ERR("devdax path mismatch (local: %s, ipc: %s)", - devdax_provider->path, devdax_ipc_data->dd_path); - return UMF_RESULT_ERROR_INVALID_ARGUMENT; - } - - // verify the size of the /dev/dax - if (devdax_ipc_data->dd_size != devdax_provider->size) { - LOG_ERR("devdax size mismatch (local: %zu, ipc: %zu)", - devdax_provider->size, devdax_ipc_data->dd_size); + devdax_provider->path, devdax_ipc_data->path); return UMF_RESULT_ERROR_INVALID_ARGUMENT; } @@ -438,58 +434,56 @@ static umf_result_t devdax_open_ipc_handle(void *provider, return UMF_RESULT_ERROR_INVALID_ARGUMENT; } - devdax_memory_provider_t *devdax_provider = - (devdax_memory_provider_t *)provider; devdax_ipc_data_t *devdax_ipc_data = (devdax_ipc_data_t *)providerIpcData; - // verify it is the same devdax - first verify the path - if (strncmp(devdax_ipc_data->dd_path, devdax_provider->path, PATH_MAX)) { - LOG_ERR("devdax path mismatch (local: %s, ipc: %s)", - devdax_provider->path, devdax_ipc_data->dd_path); - return UMF_RESULT_ERROR_INVALID_ARGUMENT; - } - - // verify the size of the /dev/dax - if (devdax_ipc_data->dd_size != devdax_provider->size) { - LOG_ERR("devdax size mismatch (local: %zu, ipc: %zu)", - devdax_provider->size, devdax_ipc_data->dd_size); - return UMF_RESULT_ERROR_INVALID_ARGUMENT; - } - - umf_result_t ret = UMF_RESULT_SUCCESS; - int fd = utils_devdax_open(devdax_provider->path); + int fd = utils_devdax_open(devdax_ipc_data->path); if (fd == -1) { - LOG_PERR("opening a devdax (%s) failed", devdax_provider->path); + LOG_PERR("opening the devdax (%s) failed", devdax_ipc_data->path); return UMF_RESULT_ERROR_INVALID_ARGUMENT; } unsigned map_sync_flag = 0; utils_translate_mem_visibility_flag(UMF_MEM_MAP_SYNC, &map_sync_flag); + // get the page size + size_t page_size; + (void)devdax_get_recommended_page_size(provider, devdax_ipc_data->length, + &page_size); + + // length and offset passed to mmap() have to be page-aligned in case of /dev/dax device + size_t offset_aligned = devdax_ipc_data->offset; + size_t length_aligned = devdax_ipc_data->length; + utils_align_ptr_down_size_up((void **)&offset_aligned, &length_aligned, + page_size); + // mmap /dev/dax with the MAP_SYNC xor MAP_SHARED flag (if MAP_SYNC fails) - char *base = utils_mmap_file(NULL, devdax_provider->size, - devdax_provider->protection, map_sync_flag, fd, - 0 /* offset */); - if (base == NULL) { + char *addr = + utils_mmap_file(NULL, length_aligned, devdax_ipc_data->protection, + map_sync_flag, fd, offset_aligned); + if (addr == NULL) { devdax_store_last_native_error(UMF_DEVDAX_RESULT_ERROR_ALLOC_FAILED, errno); LOG_PERR("devdax mapping failed (path: %s, size: %zu, protection: %i, " - "fd: %i)", - devdax_provider->path, devdax_provider->size, - devdax_provider->protection, fd); - ret = UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC; + "fd: %i, offset: %zu)", + devdax_ipc_data->path, length_aligned, + devdax_ipc_data->protection, fd, offset_aligned); + + *ptr = NULL; + (void)utils_close_fd(fd); + + return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC; } LOG_DEBUG("devdax mapped (path: %s, size: %zu, protection: %i, fd: %i, " "offset: %zu)", - devdax_provider->path, devdax_provider->size, - devdax_provider->protection, fd, devdax_ipc_data->offset); + devdax_ipc_data->path, length_aligned, + devdax_ipc_data->protection, fd, offset_aligned); - (void)utils_close_fd(fd); + *ptr = addr + (devdax_ipc_data->offset - offset_aligned); - *ptr = base + devdax_ipc_data->offset; + (void)utils_close_fd(fd); - return ret; + return UMF_RESULT_SUCCESS; } static umf_result_t devdax_close_ipc_handle(void *provider, void *ptr, @@ -498,11 +492,15 @@ static umf_result_t devdax_close_ipc_handle(void *provider, void *ptr, return UMF_RESULT_ERROR_INVALID_ARGUMENT; } - devdax_memory_provider_t *devdax_provider = - (devdax_memory_provider_t *)provider; + // get the page size + size_t page_size; + (void)devdax_get_recommended_page_size(provider, size, &page_size); + + // ptr and size passed to munmap() have to be page-aligned in case of /dev/dax device + utils_align_ptr_down_size_up(&ptr, &size, page_size); errno = 0; - int ret = utils_munmap(devdax_provider->base, devdax_provider->size); + int ret = utils_munmap(ptr, size); // ignore error when size == 0 if (ret && (size > 0)) { devdax_store_last_native_error(UMF_DEVDAX_RESULT_ERROR_FREE_FAILED, From 28057992765ff083fbfd5fef1bea81df78888db5 Mon Sep 17 00:00:00 2001 From: Lukasz Dorau Date: Mon, 28 Oct 2024 11:38:59 +0100 Subject: [PATCH 4/7] Add IPC tests for umfPoolMalloc() after umfCloseIPCHandle() Signed-off-by: Lukasz Dorau --- test/ipcFixtures.hpp | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/test/ipcFixtures.hpp b/test/ipcFixtures.hpp index 78e085a19..74bbb115e 100644 --- a/test/ipcFixtures.hpp +++ b/test/ipcFixtures.hpp @@ -220,6 +220,21 @@ TEST_P(umfIpcTest, BasicFlow) { ret = umfPoolFree(pool.get(), ptr); EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + void *ptr1 = umfPoolMalloc(pool.get(), SIZE); + EXPECT_NE(ptr1, nullptr); + + void *ptr2 = umfPoolMalloc(pool.get(), SIZE); + EXPECT_NE(ptr2, nullptr); + + // fill ptr1 with data from ptr2 + memAccessor->copy(ptr1, ptr2, SIZE); + + ret = umfPoolFree(pool.get(), ptr1); + EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + + ret = umfPoolFree(pool.get(), ptr2); + EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + pool.reset(nullptr); EXPECT_EQ(stat.getCount, 1); EXPECT_EQ(stat.putCount, stat.getCount); @@ -328,8 +343,22 @@ TEST_P(umfIpcTest, AllocFreeAllocTest) { ret = umfPoolFree(pool.get(), ptr); EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + void *ptr1 = umfPoolMalloc(pool.get(), SIZE); + ASSERT_NE(ptr1, nullptr); + + void *ptr2 = umfPoolMalloc(pool.get(), SIZE); + ASSERT_NE(ptr2, nullptr); + + // fill ptr1 with data from ptr2 + memAccessor->copy(ptr1, ptr2, SIZE); + + ret = umfPoolFree(pool.get(), ptr1); + EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + + ret = umfPoolFree(pool.get(), ptr2); + 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); From 63372322d72f33565fd520141b0e963195946bd2 Mon Sep 17 00:00:00 2001 From: Lukasz Dorau Date: Mon, 28 Oct 2024 11:01:00 +0100 Subject: [PATCH 5/7] Enable running umfIpcTest tests when free() is not supported Some memory providers (currently the devdax and the file providers) do not support the free() operation (free() always returns the UMF_RESULT_ERROR_NOT_SUPPORTED error). Add the UMF_TEST_PROVIDER_FREE_NOT_SUPPORTED define and the get_umf_result_of_free macro() to ipcFixtures.hpp to enable running umfIpcTest tests when free() is not supported. Signed-off-by: Lukasz Dorau --- test/ipcFixtures.hpp | 30 ++++++++++++++++++------------ 1 file changed, 18 insertions(+), 12 deletions(-) diff --git a/test/ipcFixtures.hpp b/test/ipcFixtures.hpp index 74bbb115e..6a406b4e6 100644 --- a/test/ipcFixtures.hpp +++ b/test/ipcFixtures.hpp @@ -19,6 +19,12 @@ #include #include +#ifdef UMF_TEST_PROVIDER_FREE_NOT_SUPPORTED +#define get_umf_result_of_free(expected_result) UMF_RESULT_ERROR_NOT_SUPPORTED +#else +#define get_umf_result_of_free(expected_result) (expected_result) +#endif + class MemoryAccessor { public: virtual void fill(void *ptr, size_t size, const void *pattern, @@ -163,7 +169,7 @@ TEST_P(umfIpcTest, GetIPCHandleInvalidArgs) { EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT); ret = umfFree(ptr); - EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + EXPECT_EQ(ret, get_umf_result_of_free(UMF_RESULT_SUCCESS)); } TEST_P(umfIpcTest, BasicFlow) { @@ -218,7 +224,7 @@ TEST_P(umfIpcTest, BasicFlow) { EXPECT_EQ(ret, UMF_RESULT_SUCCESS); ret = umfPoolFree(pool.get(), ptr); - EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + EXPECT_EQ(ret, get_umf_result_of_free(UMF_RESULT_SUCCESS)); void *ptr1 = umfPoolMalloc(pool.get(), SIZE); EXPECT_NE(ptr1, nullptr); @@ -230,10 +236,10 @@ TEST_P(umfIpcTest, BasicFlow) { memAccessor->copy(ptr1, ptr2, SIZE); ret = umfPoolFree(pool.get(), ptr1); - EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + EXPECT_EQ(ret, get_umf_result_of_free(UMF_RESULT_SUCCESS)); ret = umfPoolFree(pool.get(), ptr2); - EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + EXPECT_EQ(ret, get_umf_result_of_free(UMF_RESULT_SUCCESS)); pool.reset(nullptr); EXPECT_EQ(stat.getCount, 1); @@ -297,7 +303,7 @@ TEST_P(umfIpcTest, GetPoolByOpenedHandle) { for (size_t i = 0; i < NUM_ALLOCS; ++i) { umf_result_t ret = umfFree(ptrs[i]); - EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + EXPECT_EQ(ret, get_umf_result_of_free(UMF_RESULT_SUCCESS)); } } @@ -323,7 +329,7 @@ TEST_P(umfIpcTest, AllocFreeAllocTest) { EXPECT_EQ(ret, UMF_RESULT_SUCCESS); ret = umfPoolFree(pool.get(), ptr); - EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + EXPECT_EQ(ret, get_umf_result_of_free(UMF_RESULT_SUCCESS)); ptr = umfPoolMalloc(pool.get(), SIZE); ASSERT_NE(ptr, nullptr); @@ -341,7 +347,7 @@ TEST_P(umfIpcTest, AllocFreeAllocTest) { EXPECT_EQ(ret, UMF_RESULT_SUCCESS); ret = umfPoolFree(pool.get(), ptr); - EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + EXPECT_EQ(ret, get_umf_result_of_free(UMF_RESULT_SUCCESS)); void *ptr1 = umfPoolMalloc(pool.get(), SIZE); ASSERT_NE(ptr1, nullptr); @@ -353,10 +359,10 @@ TEST_P(umfIpcTest, AllocFreeAllocTest) { memAccessor->copy(ptr1, ptr2, SIZE); ret = umfPoolFree(pool.get(), ptr1); - EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + EXPECT_EQ(ret, get_umf_result_of_free(UMF_RESULT_SUCCESS)); ret = umfPoolFree(pool.get(), ptr2); - EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + EXPECT_EQ(ret, get_umf_result_of_free(UMF_RESULT_SUCCESS)); pool.reset(nullptr); EXPECT_EQ(stat.getCount, stat.putCount); @@ -407,7 +413,7 @@ TEST_P(umfIpcTest, openInTwoPools) { EXPECT_EQ(ret, UMF_RESULT_SUCCESS); ret = umfPoolFree(pool1.get(), ptr); - EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + EXPECT_EQ(ret, get_umf_result_of_free(UMF_RESULT_SUCCESS)); pool1.reset(nullptr); pool2.reset(nullptr); @@ -458,7 +464,7 @@ TEST_P(umfIpcTest, ConcurrentGetPutHandles) { for (void *ptr : ptrs) { umf_result_t ret = umfPoolFree(pool.get(), ptr); - EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + EXPECT_EQ(ret, get_umf_result_of_free(UMF_RESULT_SUCCESS)); } pool.reset(nullptr); @@ -520,7 +526,7 @@ TEST_P(umfIpcTest, ConcurrentOpenCloseHandles) { for (void *ptr : ptrs) { umf_result_t ret = umfPoolFree(pool.get(), ptr); - EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + EXPECT_EQ(ret, get_umf_result_of_free(UMF_RESULT_SUCCESS)); } pool.reset(nullptr); From 48c24612c873251468cc674e49dafc37df84b530 Mon Sep 17 00:00:00 2001 From: Lukasz Dorau Date: Fri, 25 Oct 2024 12:49:36 +0200 Subject: [PATCH 6/7] Add IPC tests (umfIpcTest) to the devdax provider Signed-off-by: Lukasz Dorau --- test/provider_devdax_memory.cpp | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/test/provider_devdax_memory.cpp b/test/provider_devdax_memory.cpp index 6ed5f241e..d872bf26a 100644 --- a/test/provider_devdax_memory.cpp +++ b/test/provider_devdax_memory.cpp @@ -14,6 +14,10 @@ #include "cpp_helpers.hpp" #include "test_helpers.h" +#define UMF_TEST_PROVIDER_FREE_NOT_SUPPORTED 1 +#include "ipcFixtures.hpp" +#undef UMF_TEST_PROVIDER_FREE_NOT_SUPPORTED + #include #include @@ -179,14 +183,15 @@ TEST_F(test, test_if_mapped_with_MAP_SYNC) { // positive tests using test_alloc_free_success -auto defaultParams = umfDevDaxMemoryProviderParamsDefault( +auto defaultDevDaxParams = umfDevDaxMemoryProviderParamsDefault( getenv("UMF_TESTS_DEVDAX_PATH"), atol(getenv("UMF_TESTS_DEVDAX_SIZE") ? getenv("UMF_TESTS_DEVDAX_SIZE") : "0")); INSTANTIATE_TEST_SUITE_P(devdaxProviderTest, umfProviderTest, ::testing::Values(providerCreateExtParams{ - umfDevDaxMemoryProviderOps(), &defaultParams})); + umfDevDaxMemoryProviderOps(), + &defaultDevDaxParams})); TEST_P(umfProviderTest, create_destroy) {} @@ -343,3 +348,15 @@ TEST_F(test, create_wrong_size_0) { EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT); EXPECT_EQ(hProvider, nullptr); } + +HostMemoryAccessor hostAccessor; + +static std::vector ipcProxyPoolTestParamsList = { + {umfProxyPoolOps(), nullptr, umfDevDaxMemoryProviderOps(), + &defaultDevDaxParams, &hostAccessor}, +}; + +GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest); + +INSTANTIATE_TEST_SUITE_P(DevDaxProviderProxyPoolTest, umfIpcTest, + ::testing::ValuesIn(ipcProxyPoolTestParamsList)); From 4e0e3aa98bf445be7ed863557567e7a64cc2cda0 Mon Sep 17 00:00:00 2001 From: Lukasz Dorau Date: Fri, 25 Oct 2024 17:10:12 +0200 Subject: [PATCH 7/7] [DEBUG] only DAX CI Signed-off-by: Lukasz Dorau --- .github/workflows/pr_push.yml | 59 ------------------------------ .github/workflows/reusable_dax.yml | 29 ++++++--------- 2 files changed, 11 insertions(+), 77 deletions(-) diff --git a/.github/workflows/pr_push.yml b/.github/workflows/pr_push.yml index 8b78ce3d0..9e2249e58 100644 --- a/.github/workflows/pr_push.yml +++ b/.github/workflows/pr_push.yml @@ -16,64 +16,5 @@ permissions: contents: read jobs: - CodeChecks: - uses: ./.github/workflows/reusable_checks.yml - DocsBuild: - uses: ./.github/workflows/reusable_docs_build.yml - FastBuild: - name: Fast builds - needs: [CodeChecks, DocsBuild] - uses: ./.github/workflows/reusable_fast.yml - Build: - name: Basic builds - needs: [FastBuild] - uses: ./.github/workflows/reusable_basic.yml DevDax: - needs: [FastBuild] uses: ./.github/workflows/reusable_dax.yml - Sanitizers: - needs: [FastBuild] - uses: ./.github/workflows/reusable_sanitizers.yml - Qemu: - needs: [FastBuild] - uses: ./.github/workflows/reusable_qemu.yml - Benchmarks: - needs: [Build] - uses: ./.github/workflows/reusable_benchmarks.yml - ProxyLib: - needs: [Build] - uses: ./.github/workflows/reusable_proxy_lib.yml - GPU: - needs: [Build] - uses: ./.github/workflows/reusable_gpu.yml - Valgrind: - needs: [Build] - uses: ./.github/workflows/reusable_valgrind.yml - MultiNuma: - needs: [Build] - uses: ./.github/workflows/reusable_multi_numa.yml - Coverage: - # total coverage (on upstream only) - if: github.repository == 'oneapi-src/unified-memory-framework' - needs: [Build, DevDax, GPU, MultiNuma, Qemu, ProxyLib] - uses: ./.github/workflows/reusable_coverage.yml - secrets: inherit - with: - trigger: "${{github.event_name}}" - Coverage_partial: - # partial coverage (on forks) - if: github.repository != 'oneapi-src/unified-memory-framework' - needs: [Build, Qemu, ProxyLib] - uses: ./.github/workflows/reusable_coverage.yml - CodeQL: - needs: [Build] - permissions: - contents: read - security-events: write - uses: ./.github/workflows/reusable_codeql.yml - Trivy: - needs: [Build] - permissions: - contents: read - security-events: write - uses: ./.github/workflows/reusable_trivy.yml diff --git a/.github/workflows/reusable_dax.yml b/.github/workflows/reusable_dax.yml index 24e5a1bdb..8f2a7db00 100644 --- a/.github/workflows/reusable_dax.yml +++ b/.github/workflows/reusable_dax.yml @@ -39,7 +39,7 @@ jobs: if: github.repository == 'oneapi-src/unified-memory-framework' strategy: matrix: - build_type: [Debug, Release] + build_type: [Debug] shared_library: ['ON', 'OFF'] runs-on: ["DSS-DEVDAX", "DSS-Ubuntu"] @@ -92,11 +92,20 @@ jobs: - name: Build UMF run: cmake --build ${{env.BUILD_DIR}} --config ${{matrix.build_type}} -j $(nproc) - - name: Run the DEVDAX tests + - name: Run the DEVDAX test test/umf_test-provider_devdax_memory working-directory: ${{env.BUILD_DIR}} run: > UMF_TESTS_DEVDAX_PATH="/dev/dax${{env.DEVDAX_NAMESPACE}}" UMF_TESTS_DEVDAX_SIZE="$(ndctl list --namespace=namespace${{env.DEVDAX_NAMESPACE}} | grep size | cut -d':' -f2 | cut -d',' -f1)" + UMF_LOG="level:debug;flush:debug;output:stderr;pid:yes" + ./test/umf_test-provider_devdax_memory + + - name: Run all DEVDAX tests + working-directory: ${{env.BUILD_DIR}} + run: > + UMF_TESTS_DEVDAX_PATH="/dev/dax${{env.DEVDAX_NAMESPACE}}" + UMF_TESTS_DEVDAX_SIZE="$(ndctl list --namespace=namespace${{env.DEVDAX_NAMESPACE}} | grep size | cut -d':' -f2 | cut -d',' -f1)" + UMF_LOG="level:debug;flush:debug;output:stderr;pid:yes" ctest -C ${{matrix.build_type}} -R devdax -V - name: Run the FSDAX tests @@ -105,19 +114,3 @@ jobs: UMF_TESTS_FSDAX_PATH=${{env.UMF_TESTS_FSDAX_PATH}} UMF_TESTS_FSDAX_PATH_2=${{env.UMF_TESTS_FSDAX_PATH_2}} ctest -C ${{matrix.build_type}} -R umf-provider_file_memory -V UMF_TESTS_FSDAX_PATH=${{env.UMF_TESTS_FSDAX_PATH}} UMF_TESTS_FSDAX_PATH_2=${{env.UMF_TESTS_FSDAX_PATH_2}} ctest -C ${{matrix.build_type}} -R umf_example_dram_and_fsdax -V UMF_TESTS_FSDAX_PATH=${{env.UMF_TESTS_FSDAX_PATH}} UMF_TESTS_FSDAX_PATH_2=${{env.UMF_TESTS_FSDAX_PATH_2}} ctest -C ${{matrix.build_type}} -R umf-ipc_file_prov_fsdax -V - - - name: Check coverage - if: ${{ matrix.build_type == 'Debug' }} - working-directory: ${{env.BUILD_DIR}} - run: | - export COVERAGE_FILE_NAME=${{env.COVERAGE_NAME}}-shared-${{matrix.shared_library}} - echo "COVERAGE_FILE_NAME: $COVERAGE_FILE_NAME" - ../scripts/coverage/coverage_capture.sh $COVERAGE_FILE_NAME - mkdir -p ${{env.COVERAGE_DIR}} - mv ./$COVERAGE_FILE_NAME ${{env.COVERAGE_DIR}} - - - uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808 # v4.3.3 - if: ${{ matrix.build_type == 'Debug' }} - with: - name: ${{env.COVERAGE_NAME}}-shared-${{matrix.shared_library}} - path: ${{env.COVERAGE_DIR}}