add UMF_EXPORT for windows dll

Author: bratpiorka

include/umf/base.h

@@ -17,6 +17,12 @@
 extern "C" {
 #endif
 
+#ifdef _WIN32
+#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/memory_pool.c

@@ -15,11 +15,10 @@
 #include <assert.h>
 #include <stdlib.h>
 
-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) {
     if (!pool_ops || !provider_ops || !hPool) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }