Merge pull request #83 from bratpiorka/rrudnick_test_shared_lib_build

add single test for building libumf.so to gha

Author: igchor

.github/workflows/basic.yml

@@ -12,13 +12,18 @@ jobs:
         build_type: [Debug, Release]
         compiler: [{c: gcc, cxx: g++}]
         pool_tracking: ['ON', 'OFF']
+        shared_library: ['OFF']
         include:
           - os: 'ubuntu-20.04'
             build_type: Release
             compiler: {c: gcc-7, cxx: g++-7}
           - os: 'ubuntu-22.04'
             build_type: Release
-            compiler: {c: clang, cxx: clang++}
+            compiler: {c: clang, cxx: clang++}            
+          - os: 'ubuntu-22.04'
+            build_type: Release
+            compiler: {c: gcc, cxx: g++}
+            shared_library: 'ON'
     runs-on: ${{matrix.os}}
 
     steps:
@@ -40,6 +45,7 @@ jobs:
           cmake
           -B ${{github.workspace}}/build
           -DCMAKE_BUILD_TYPE=${{matrix.build_type}}
+          -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}}
           -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
           -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
           -DUMF_ENABLE_POOL_TRACKING=${{matrix.pool_tracking}}
@@ -66,12 +72,18 @@ jobs:
         build_type: [Debug, Release]
         compiler: [{c: cl, cxx: cl}]
         pool_tracking: ['ON', 'OFF']
+        shared_library: ['OFF']
         include:
           - os: 'windows-2022'
             build_type: Release
             compiler: {c: clang-cl, cxx: clang-cl}
             pool_tracking: 'ON'
             toolset: "-T ClangCL"
+          - os: 'windows-2022'
+            build_type: Release
+            compiler: {c: cl, cxx: cl}
+            pool_tracking: 'ON'
+            shared_library: 'ON'
     runs-on: ${{matrix.os}}
 
     steps:
@@ -84,6 +96,7 @@ jobs:
           ${{matrix.toolset}}
           -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
           -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
+          -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}}
           -DUMF_ENABLE_POOL_TRACKING=${{matrix.pool_tracking}}
           -DUMF_FORMAT_CODE_STYLE=OFF
           -DUMF_DEVELOPER_MODE=ON

include/umf/base.h

@@ -17,6 +17,12 @@
 extern "C" {
 #endif
 
+#if defined(_WIN32) && defined(UMF_SHARED_LIBRARY)
+#define UMF_EXPORT __declspec(dllexport)
+#else
+#define UMF_EXPORT
+#endif
+
 /// @brief Generates generic 'UMF' API versions
 #define UMF_MAKE_VERSION(_major, _minor)                                       \
     ((_major << 16) | (_minor & 0x0000ffff))

include/umf/memory_pool.h

@@ -38,23 +38,24 @@ typedef struct umf_memory_pool_ops_t umf_memory_pool_ops_t;
 /// @param hPool [out] handle to the newly created memory pool
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
-umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
-                           umf_memory_provider_handle_t provider, void *params,
-                           umf_memory_pool_handle_t *hPool);
+UMF_EXPORT umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
+                                      umf_memory_provider_handle_t provider,
+                                      void *params,
+                                      umf_memory_pool_handle_t *hPool);
 
 ///
 /// @brief Destroys memory pool.
 /// @param hPool handle to the pool
 ///
-void umfPoolDestroy(umf_memory_pool_handle_t hPool);
+UMF_EXPORT void umfPoolDestroy(umf_memory_pool_handle_t hPool);
 
 ///
 /// @brief Allocates \p size bytes of uninitialized storage from \p hPool
 /// @param hPool specified memory hPool
 /// @param size number of bytes to allocate
 /// @return Pointer to the allocated memory.
 ///
-void *umfPoolMalloc(umf_memory_pool_handle_t hPool, size_t size);
+UMF_EXPORT void *umfPoolMalloc(umf_memory_pool_handle_t hPool, size_t size);
 
 ///
 /// @brief Allocates \p size bytes of uninitialized storage from the specified \p hPool
@@ -64,8 +65,8 @@ void *umfPoolMalloc(umf_memory_pool_handle_t hPool, size_t size);
 /// @param alignment alignment of the allocation in bytes
 /// @return Pointer to the allocated memory
 ///
-void *umfPoolAlignedMalloc(umf_memory_pool_handle_t hPool, size_t size,
-                           size_t alignment);
+UMF_EXPORT void *umfPoolAlignedMalloc(umf_memory_pool_handle_t hPool,
+                                      size_t size, size_t alignment);
 
 ///
 /// @brief Allocates memory from \p hPool for an array of \p num elements
@@ -76,7 +77,8 @@ void *umfPoolAlignedMalloc(umf_memory_pool_handle_t hPool, size_t size,
 /// @param size number of bytes to allocate for each object
 /// @return Pointer to the allocated memory
 ///
-void *umfPoolCalloc(umf_memory_pool_handle_t hPool, size_t num, size_t size);
+UMF_EXPORT void *umfPoolCalloc(umf_memory_pool_handle_t hPool, size_t num,
+                               size_t size);
 
 ///
 /// @brief Reallocates memory from \p hPool
@@ -85,15 +87,17 @@ void *umfPoolCalloc(umf_memory_pool_handle_t hPool, size_t num, size_t size);
 /// @param size new size for the memory block in bytes
 /// @return Pointer to the allocated memory
 ///
-void *umfPoolRealloc(umf_memory_pool_handle_t hPool, void *ptr, size_t size);
+UMF_EXPORT void *umfPoolRealloc(umf_memory_pool_handle_t hPool, void *ptr,
+                                size_t size);
 
 ///
 /// @brief Obtains size of block of memory allocated from the \p hPool for a given \p ptr
 /// @param hPool specified memory hPool
 /// @param ptr pointer to the allocated memory
 /// @return size of the memory block allocated from the \p hPool
 ///
-size_t umfPoolMallocUsableSize(umf_memory_pool_handle_t hPool, void *ptr);
+UMF_EXPORT size_t umfPoolMallocUsableSize(umf_memory_pool_handle_t hPool,
+                                          void *ptr);
 
 ///
 /// @brief Frees the memory space of the specified \p hPool pointed by \p ptr
@@ -103,7 +107,7 @@ size_t umfPoolMallocUsableSize(umf_memory_pool_handle_t hPool, void *ptr);
 ///         Whether any status other than UMF_RESULT_SUCCESS can be returned
 ///         depends on the memory provider used by the \p hPool.
 ///
-umf_result_t umfPoolFree(umf_memory_pool_handle_t hPool, void *ptr);
+UMF_EXPORT umf_result_t umfPoolFree(umf_memory_pool_handle_t hPool, void *ptr);
 
 ///
 /// @brief Frees the memory space pointed by ptr if it belongs to UMF pool, does nothing otherwise.
@@ -112,7 +116,7 @@ umf_result_t umfPoolFree(umf_memory_pool_handle_t hPool, void *ptr);
 ///         Whether any status other than UMF_RESULT_SUCCESS can be returned
 ///         depends on the memory provider used by the pool.
 ///
-umf_result_t umfFree(void *ptr);
+UMF_EXPORT umf_result_t umfFree(void *ptr);
 
 ///
 /// @brief Retrieve \p umf_result_t representing the error of the last failed allocation
@@ -132,15 +136,16 @@ umf_result_t umfFree(void *ptr);
 /// @return Error code desciribng the failure of the last failed allocation operation.
 ///         The value is undefined if the previous allocation was successful.
 ///
-umf_result_t umfPoolGetLastAllocationError(umf_memory_pool_handle_t hPool);
+UMF_EXPORT umf_result_t
+umfPoolGetLastAllocationError(umf_memory_pool_handle_t hPool);
 
 ///
 /// @brief Retrieve memory pool associated with a given ptr. Only memory allocated
 ///        with the usage of a memory provider is being tracked.
 /// @param ptr pointer to memory belonging to a memory pool
 /// @return Handle to a memory pool that contains ptr or NULL if pointer does not belong to any UMF pool.
 ///
-umf_memory_pool_handle_t umfPoolByPtr(const void *ptr);
+UMF_EXPORT umf_memory_pool_handle_t umfPoolByPtr(const void *ptr);
 
 ///
 /// @brief Retrieve memory provider associated with a given pool.
@@ -149,8 +154,8 @@ umf_memory_pool_handle_t umfPoolByPtr(const void *ptr);
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///         UMF_RESULT_ERROR_INVALID_ARGUMENT if hProvider is NULL
 ///
-umf_result_t umfPoolGetMemoryProvider(umf_memory_pool_handle_t hPool,
-                                      umf_memory_provider_handle_t *hProvider);
+UMF_EXPORT umf_result_t umfPoolGetMemoryProvider(
+    umf_memory_pool_handle_t hPool, umf_memory_provider_handle_t *hProvider);
 
 #ifdef __cplusplus
 }

include/umf/memory_provider.h

@@ -27,15 +27,16 @@ typedef struct umf_memory_provider_t *umf_memory_provider_handle_t;
 /// @param hProvider [out] pointer to the newly created memory provider
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
-umf_result_t umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops,
-                                     void *params,
-                                     umf_memory_provider_handle_t *hProvider);
+UMF_EXPORT umf_result_t
+umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops, void *params,
+                        umf_memory_provider_handle_t *hProvider);
 
 ///
 /// @brief Destroys memory provider.
 /// @param hProvider handle to the memory provider
 ///
-void umfMemoryProviderDestroy(umf_memory_provider_handle_t hProvider);
+UMF_EXPORT void
+umfMemoryProviderDestroy(umf_memory_provider_handle_t hProvider);
 
 ///
 /// @brief Allocates \p size bytes of uninitialized storage from memory \p hProvider
@@ -46,8 +47,9 @@ void umfMemoryProviderDestroy(umf_memory_provider_handle_t hProvider);
 /// @param ptr [out] pointer to the allocated memory
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure
 ///
-umf_result_t umfMemoryProviderAlloc(umf_memory_provider_handle_t hProvider,
-                                    size_t size, size_t alignment, void **ptr);
+UMF_EXPORT umf_result_t
+umfMemoryProviderAlloc(umf_memory_provider_handle_t hProvider, size_t size,
+                       size_t alignment, void **ptr);
 
 ///
 /// @brief Frees the memory space pointed by \p ptr from the memory \p hProvider
@@ -56,8 +58,8 @@ umf_result_t umfMemoryProviderAlloc(umf_memory_provider_handle_t hProvider,
 /// @param size size of the allocation
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure
 ///
-umf_result_t umfMemoryProviderFree(umf_memory_provider_handle_t hProvider,
-                                   void *ptr, size_t size);
+UMF_EXPORT umf_result_t umfMemoryProviderFree(
+    umf_memory_provider_handle_t hProvider, void *ptr, size_t size);
 
 ///
 /// @brief Retrieve string representation of the underlying provider specific
@@ -83,9 +85,9 @@ umf_result_t umfMemoryProviderFree(umf_memory_provider_handle_t hProvider,
 ///        result in string representation
 /// @param pError [out] pointer to an integer where the adapter specific error code will be stored
 ///
-void umfMemoryProviderGetLastNativeError(umf_memory_provider_handle_t hProvider,
-                                         const char **ppMessage,
-                                         int32_t *pError);
+UMF_EXPORT void
+umfMemoryProviderGetLastNativeError(umf_memory_provider_handle_t hProvider,
+                                    const char **ppMessage, int32_t *pError);
 
 ///
 /// @brief Retrieve recommended page size for a given allocation size.
@@ -94,9 +96,8 @@ void umfMemoryProviderGetLastNativeError(umf_memory_provider_handle_t hProvider,
 /// @param pageSize [out] pointer to the recommended page size
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
-umf_result_t
-umfMemoryProviderGetRecommendedPageSize(umf_memory_provider_handle_t hProvider,
-                                        size_t size, size_t *pageSize);
+UMF_EXPORT umf_result_t umfMemoryProviderGetRecommendedPageSize(
+    umf_memory_provider_handle_t hProvider, size_t size, size_t *pageSize);
 
 ///
 /// @brief Retrieve minimum possible page size used by memory region referenced by a given \p ptr
@@ -106,9 +107,8 @@ umfMemoryProviderGetRecommendedPageSize(umf_memory_provider_handle_t hProvider,
 /// @param pageSize [out] pointer to the minimum possible page size
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
-umf_result_t
-umfMemoryProviderGetMinPageSize(umf_memory_provider_handle_t hProvider,
-                                void *ptr, size_t *pageSize);
+UMF_EXPORT umf_result_t umfMemoryProviderGetMinPageSize(
+    umf_memory_provider_handle_t hProvider, void *ptr, size_t *pageSize);
 
 ///
 /// @brief Discard physical pages within the virtual memory mapping associated at the given addr
@@ -120,8 +120,8 @@ umfMemoryProviderGetMinPageSize(umf_memory_provider_handle_t hProvider,
 ///         UMF_RESULT_ERROR_INVALID_ALIGNMENT if ptr or size is not page-aligned.
 ///         UMF_RESULT_ERROR_NOT_SUPPORTED if operation is not supported by this provider.
 ///
-umf_result_t umfMemoryProviderPurgeLazy(umf_memory_provider_handle_t hProvider,
-                                        void *ptr, size_t size);
+UMF_EXPORT umf_result_t umfMemoryProviderPurgeLazy(
+    umf_memory_provider_handle_t hProvider, void *ptr, size_t size);
 
 ///
 /// @brief Discard physical pages within the virtual memory mapping associated at the given addr and \p size.
@@ -133,15 +133,16 @@ umf_result_t umfMemoryProviderPurgeLazy(umf_memory_provider_handle_t hProvider,
 ///         UMF_RESULT_ERROR_INVALID_ALIGNMENT if ptr or size is not page-aligned.
 ///         UMF_RESULT_ERROR_NOT_SUPPORTED if operation is not supported by this provider.
 ///
-umf_result_t umfMemoryProviderPurgeForce(umf_memory_provider_handle_t hProvider,
-                                         void *ptr, size_t size);
+UMF_EXPORT umf_result_t umfMemoryProviderPurgeForce(
+    umf_memory_provider_handle_t hProvider, void *ptr, size_t size);
 
 ///
 /// @brief Retrieve name of a given memory \p hProvider.
 /// @param hProvider handle to the memory provider
 /// @return pointer to a string containing the name of the \p hProvider
 ///
-const char *umfMemoryProviderGetName(umf_memory_provider_handle_t hProvider);
+UMF_EXPORT const char *
+umfMemoryProviderGetName(umf_memory_provider_handle_t hProvider);
 
 ///
 /// @brief Retrieve handle to the last memory provider that returned status other
@@ -153,7 +154,7 @@ const char *umfMemoryProviderGetName(umf_memory_provider_handle_t hProvider);
 ///
 /// @return Handle to the memory provider
 ///
-umf_memory_provider_handle_t umfGetLastFailedMemoryProvider(void);
+UMF_EXPORT umf_memory_provider_handle_t umfGetLastFailedMemoryProvider(void);
 
 #ifdef __cplusplus
 }

src/CMakeLists.txt

@@ -20,6 +20,7 @@ set(UMF_SOURCES_LINUX
 )
 
 set(UMF_SOURCES_WINDOWS
+    provider/provider_os_memory_windows.c
     provider/provider_tracking_windows.cpp
     utils/utils_windows_concurrency.c
     utils/utils_windows_math.c
@@ -50,6 +51,8 @@ if(UMF_BUILD_SHARED_LIBRARY)
                     SRCS ${UMF_SOURCES}
                     LIBS ${UMF_LIBS})
     target_compile_definitions(umf PUBLIC UMF_SHARED_LIBRARY)
+    set_target_properties(umf PROPERTIES
+        RUNTIME_OUTPUT_DIRECTORY ${CMAKE_UMF_OUTPUT_DIRECTORY})
 else()
     add_umf_library(NAME umf
                     TYPE STATIC 

src/memory_pool_internal.h

@@ -31,11 +31,10 @@ typedef struct umf_memory_pool_t {
     bool own_provider;
 } umf_memory_pool_t;
 
-umf_result_t umfPoolCreateEx(const umf_memory_pool_ops_t *pool_ops,
-                             void *pool_params,
-                             const umf_memory_provider_ops_t *provider_ops,
-                             void *provider_params,
-                             umf_memory_pool_handle_t *hPool);
+UMF_EXPORT umf_result_t
+umfPoolCreateEx(const umf_memory_pool_ops_t *pool_ops, void *pool_params,
+                const umf_memory_provider_ops_t *provider_ops,
+                void *provider_params, umf_memory_pool_handle_t *hPool);
 
 #ifdef __cplusplus
 }

src/provider/provider_os_memory_linux.c

@@ -105,9 +105,8 @@ static int os_translate_purge_advise(umf_purge_advise_t advise) {
     return -1;
 }
 
-long os_mbind(void *addr, unsigned long len, int mode,
-              const unsigned long *nodemask, unsigned long maxnode,
-              unsigned flags) {
+long os_mbind(void *addr, size_t len, int mode, const unsigned long *nodemask,
+              unsigned long maxnode, unsigned flags) {
     return mbind(addr, len, mode, nodemask, maxnode, flags);
 }