Merge pull request #417 from ldorau/Add_proxy_lib_new_delete.h

Enable tests of proxy library on Windows Debug

Author: bratpiorka

.cmake-format

@@ -26,8 +26,7 @@ with section("parse"):
       'kwargs': {
         'NAME': '*', 
         'SRCS': '*', 
-        'LIBS': '*',
-        'CFGS': '*'}},
+        'LIBS': '*'}},
     'add_umf_library': {
       "pargs": 0,
       "flags": [],

README.md

@@ -199,6 +199,26 @@ using umfMemspaceHostAllGet.
 Memspace backed by all available NUMA nodes discovered on the platform sorted by capacity.
 Can be retrieved using umfMemspaceHighestCapacityGet.
 
+### Proxy library
+
+UMF provides the UMF proxy library (`umf_proxy`) that makes it possible
+to override the default allocator in other programs in both Linux and Windows.
+
+#### Linux
+
+In case of Linux it can be done without any code changes using the `LD_PRELOAD` environment variable:
+
+```sh
+$ LD_PRELOAD=/usr/lib/libumf_proxy.so myprogram
+```
+
+#### Windows
+
+In case of Windows it requires:
+1) explicitly linking your program dynamically with the `umf_proxy.dll` library
+2) (C++ code only) including `proxy_lib_new_delete.h` in a single(!) source file in your project
+   to override also the `new`/`delete` operations.
+
 ## Contributions
 
 All contributions to the UMF project are most welcome! Before submitting

include/umf/proxy_lib_new_delete.h

@@ -0,0 +1,153 @@
+/* ----------------------------------------------------------------------------
+Copyright (c) 2018-2020 Microsoft Research, Daan Leijen
+Copyright (C) 2024 Intel Corporation
+
+This is free software; you can redistribute it and/or modify it under the
+terms of the MIT license:
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+-----------------------------------------------------------------------------*/
+
+#ifndef UMF_PROXY_LIB_NEW_DELETE_H
+#define UMF_PROXY_LIB_NEW_DELETE_H
+
+// ----------------------------------------------------------------------------
+// This header provides convenient overrides for the new and
+// delete operations in C++.
+//
+// This header should be included in only one source file!
+//
+// On Windows, or when linking dynamically with UMF, these
+// can be more performant than the standard new-delete operations.
+// See <https://en.cppreference.com/w/cpp/memory/new/operator_new>
+// ---------------------------------------------------------------------------
+
+#if defined(__cplusplus)
+#include <new>
+
+#ifndef _WIN32
+#include <stdlib.h>
+#endif // _WIN32
+
+static inline void *internal_aligned_alloc(size_t alignment, size_t size) {
+#ifdef _WIN32
+    return _aligned_malloc(size, alignment);
+#else
+    return aligned_alloc(alignment, size);
+#endif // _WIN32
+}
+
+#if defined(_MSC_VER) && defined(_Ret_notnull_) &&                             \
+    defined(_Post_writable_byte_size_)
+// stay consistent with VCRT definitions
+#define decl_new(n) [[nodiscard]] _Ret_notnull_ _Post_writable_byte_size_(n)
+#define decl_new_nothrow(n)                                                    \
+    [[nodiscard]] _Ret_maybenull_ _Success_(return != NULL)                    \
+        _Post_writable_byte_size_(n)
+#else
+#define decl_new(n) [[nodiscard]]
+#define decl_new_nothrow(n) [[nodiscard]]
+#endif // defined(_MSC_VER) && defined(_Ret_notnull_) && defined(_Post_writable_byte_size_)
+
+void operator delete(void *p) noexcept { free(p); };
+void operator delete[](void *p) noexcept { free(p); };
+
+void operator delete(void *p, const std::nothrow_t &) noexcept { free(p); }
+void operator delete[](void *p, const std::nothrow_t &) noexcept { free(p); }
+
+decl_new(n) void *operator new(std::size_t n) noexcept(false) {
+    return malloc(n);
+}
+decl_new(n) void *operator new[](std::size_t n) noexcept(false) {
+    return malloc(n);
+}
+
+decl_new_nothrow(n) void *operator new(std::size_t n,
+                                       const std::nothrow_t &tag) noexcept {
+    (void)(tag);
+    return malloc(n);
+}
+decl_new_nothrow(n) void *operator new[](std::size_t n,
+                                         const std::nothrow_t &tag) noexcept {
+    (void)(tag);
+    return malloc(n);
+}
+
+#if (__cplusplus >= 201402L || _MSC_VER >= 1916)
+void operator delete(void *p, std::size_t n) noexcept {
+    (void)(n);
+    free(p);
+};
+void operator delete[](void *p, std::size_t n) noexcept {
+    (void)(n);
+    free(p);
+};
+#endif // (__cplusplus >= 201402L || _MSC_VER >= 1916)
+
+#if (__cplusplus > 201402L || defined(__cpp_aligned_new))
+void operator delete(void *p, std::align_val_t al) noexcept {
+    (void)(al);
+    free(p);
+}
+void operator delete[](void *p, std::align_val_t al) noexcept {
+    (void)(al);
+    free(p);
+}
+void operator delete(void *p, std::size_t n, std::align_val_t al) noexcept {
+    (void)(n);
+    (void)(al);
+    free(p);
+};
+void operator delete[](void *p, std::size_t n, std::align_val_t al) noexcept {
+    (void)(n);
+    (void)(al);
+    free(p);
+};
+void operator delete(void *p, std::align_val_t al,
+                     const std::nothrow_t &) noexcept {
+    (void)(al);
+    free(p);
+}
+void operator delete[](void *p, std::align_val_t al,
+                       const std::nothrow_t &) noexcept {
+    (void)(al);
+    free(p);
+}
+
+void *operator new(std::size_t n, std::align_val_t al) noexcept(false) {
+    return internal_aligned_alloc(static_cast<size_t>(al), n);
+}
+void *operator new[](std::size_t n, std::align_val_t al) noexcept(false) {
+    return internal_aligned_alloc(static_cast<size_t>(al), n);
+}
+void *operator new(std::size_t n, std::align_val_t al,
+                   const std::nothrow_t &) noexcept {
+    return internal_aligned_alloc(static_cast<size_t>(al), n);
+}
+void *operator new[](std::size_t n, std::align_val_t al,
+                     const std::nothrow_t &) noexcept {
+    return internal_aligned_alloc(static_cast<size_t>(al), n);
+}
+#endif // (__cplusplus > 201402L || defined(__cpp_aligned_new))
+#endif // defined(__cplusplus)
+
+#endif // UMF_PROXY_LIB_NEW_DELETE_H

src/proxy_lib/proxy_lib.c

@@ -13,8 +13,18 @@
  * - calloc()
  * - free()
  * - malloc()
- * - malloc_usable_size()
+ * - malloc_usable_size() for Linux or _msize() for Windows
  * - realloc()
+ *
+ * Additionally for Windows only:
+ * - _aligned_malloc()
+ * - _aligned_realloc()
+ * - _aligned_recalloc()
+ * - _aligned_msize()
+ * - _aligned_free()
+ * - _aligned_offset_malloc()
+ * - _aligned_offset_realloc()
+ * - _aligned_offset_recalloc()
  */
 
 #if (defined PROXY_LIB_USES_JEMALLOC_POOL)
@@ -254,13 +264,6 @@ void free(void *ptr) {
     return;
 }
 
-#ifdef _WIN32
-void _free_dbg(void *userData, int blockType) {
-    (void)blockType; // unused
-    free(userData);
-}
-#endif
-
 void *realloc(void *ptr, size_t size) {
     if (ptr == NULL) {
         return malloc(size);
@@ -318,3 +321,60 @@ size_t malloc_usable_size(void *ptr) {
 
     return 0; // unsupported in this case
 }
+
+// Add Microsoft aligned variants
+#ifdef _WIN32
+
+void *_aligned_malloc(size_t size, size_t alignment) {
+    return aligned_alloc(alignment, size);
+}
+
+void *_aligned_realloc(void *ptr, size_t size, size_t alignment) {
+    if (alignment == 0) {
+        return realloc(ptr, size);
+    }
+    return NULL; // not supported in this case
+}
+
+void *_aligned_recalloc(void *ptr, size_t num, size_t size, size_t alignment) {
+    (void)ptr;       // unused
+    (void)num;       // unused
+    (void)size;      // unused
+    (void)alignment; // unused
+    return NULL;     // not supported
+}
+
+size_t _aligned_msize(void *ptr, size_t alignment, size_t offset) {
+    (void)alignment; // unused
+    (void)offset;    // unused
+    return _msize(ptr);
+}
+
+void _aligned_free(void *ptr) { free(ptr); }
+
+void *_aligned_offset_malloc(size_t size, size_t alignment, size_t offset) {
+    if (offset == 0) {
+        return aligned_alloc(alignment, size);
+    }
+    return NULL; // not supported in this case
+}
+
+void *_aligned_offset_realloc(void *ptr, size_t size, size_t alignment,
+                              size_t offset) {
+    if (alignment == 0 && offset == 0) {
+        return realloc(ptr, size);
+    }
+    return NULL; // not supported in this case
+}
+
+void *_aligned_offset_recalloc(void *ptr, size_t num, size_t size,
+                               size_t alignment, size_t offset) {
+    (void)ptr;       // unused
+    (void)num;       // unused
+    (void)size;      // unused
+    (void)alignment; // unused
+    (void)offset;    // unused
+    return NULL;     // not supported
+}
+
+#endif

src/proxy_lib/proxy_lib.def

@@ -9,8 +9,15 @@ EXPORTS
 	DllMain
 	aligned_alloc
 	calloc
-	_free_dbg
 	free
 	malloc
 	_msize
 	realloc
+	_aligned_malloc
+	_aligned_realloc
+	_aligned_recalloc
+	_aligned_msize
+	_aligned_free
+	_aligned_offset_malloc
+	_aligned_offset_realloc
+	_aligned_offset_recalloc

test/CMakeLists.txt

@@ -30,7 +30,7 @@ function(add_umf_test)
     # * SRCS - source files
     # * LIBS - libraries to be linked with
     set(oneValueArgs NAME)
-    set(multiValueArgs SRCS LIBS CFGS)
+    set(multiValueArgs SRCS LIBS)
     cmake_parse_arguments(
         ARG
         ""
@@ -73,7 +73,6 @@ function(add_umf_test)
     add_test(
         NAME ${TEST_NAME}
         COMMAND ${TEST_TARGET_NAME}
-        CONFIGURATIONS ${ARG_CFGS}
         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
     set_tests_properties(${TEST_NAME} PROPERTIES LABELS "umf")
@@ -224,22 +223,18 @@ add_umf_test(
 
 # tests for the proxy library
 if(UMF_PROXY_LIB_ENABLED AND UMF_BUILD_SHARED_LIBRARY)
-    # The CFGS variable can be removed when the issue of running the proxy
-    # library on Windows with Debug configuration is fixed.
-    if(WINDOWS)
-        set(CONFIGS Release RelWithDebInfo MinSizeRel)
-    endif()
     add_umf_test(
         NAME proxy_lib_basic
         SRCS test_proxy_lib.cpp
-        LIBS umf_proxy
-        CFGS ${CONFIGS})
+        LIBS umf_proxy)
+
     # the memoryPool test run with the proxy library
     add_umf_test(
         NAME proxy_lib_memoryPool
         SRCS memoryPoolAPI.cpp malloc_compliance_tests.cpp
-        LIBS umf_proxy
-        CFGS ${CONFIGS})
+        LIBS umf_proxy)
+    target_compile_definitions(umf_test-proxy_lib_memoryPool
+                               PUBLIC UMF_PROXY_LIB_ENABLED=1)
 endif()
 
 if(UMF_ENABLE_POOL_TRACKING)

test/memoryPoolAPI.cpp

@@ -14,6 +14,10 @@
 #include <umf/memory_provider.h>
 #include <umf/pools/pool_proxy.h>
 
+#ifdef UMF_PROXY_LIB_ENABLED
+#include <umf/proxy_lib_new_delete.h>
+#endif
+
 #include <array>
 #include <string>
 #include <thread>

test/test_proxy_lib.cpp

@@ -11,6 +11,8 @@
 #include <malloc.h>
 #endif
 
+#include <umf/proxy_lib_new_delete.h>
+
 #include "base.hpp"
 #include "test_helpers.h"