diff --git a/CMakeLists.txt b/CMakeLists.txt
index ee97c38f9..47639d222 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -632,6 +632,23 @@ if(CMAKE_GENERATOR MATCHES "Visual Studio" OR CMAKE_GENERATOR MATCHES
     set(CMAKE_UMF_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin/$<CONFIG>)
 endif()
 
+# Valgrind
+if(UMF_USE_VALGRIND)
+    if(UMF_USE_ASAN
+       OR UMF_USE_TSAN
+       OR UMF_USE_UBSAN
+       OR UMF_USE_MSAN)
+        message(FATAL_ERROR "Cannot use valgrind and sanitizers together")
+    endif()
+
+    if(PkgConfig_FOUND)
+        pkg_check_modules(VALGRIND valgrind)
+    endif()
+    if(NOT VALGRIND_FOUND)
+        find_package(VALGRIND REQUIRED valgrind)
+    endif()
+endif()
+
 # Sanitizer flags
 if(UMF_USE_ASAN)
     add_sanitizer_flag(address)
@@ -953,12 +970,11 @@ if(UMF_FORMAT_CODE_STYLE)
             COMMENT "Format C/C++, CMake, and Python files")
         message(
             STATUS
-                "  Adding convenience targets 'format-check' and 'format-apply'."
-        )
+                "Adding convenience targets 'format-check' and 'format-apply'.")
     else()
         message(
             STATUS
-                "  Convenience targets 'format-check' and 'format-apply' are "
+                "Convenience targets 'format-check' and 'format-apply' are "
                 "not available. Use commands specific for found tools (see the log above)."
         )
     endif()
diff --git a/_deps/cuda-headers-src b/_deps/cuda-headers-src
new file mode 160000
index 000000000..a63ea57e8
--- /dev/null
+++ b/_deps/cuda-headers-src
@@ -0,0 +1 @@
+Subproject commit a63ea57e87ec813c7f77c2b298a9df23a1af152a
diff --git a/_deps/googletest-src b/_deps/googletest-src
new file mode 160000
index 000000000..b514bdc89
--- /dev/null
+++ b/_deps/googletest-src
@@ -0,0 +1 @@
+Subproject commit b514bdc898e2951020cbdca1304b75f5950d1f59
diff --git a/cmake/FindCUDA.cmake b/cmake/FindCUDA.cmake
index 955fe5da5..9a9dbec9d 100644
--- a/cmake/FindCUDA.cmake
+++ b/cmake/FindCUDA.cmake
@@ -34,6 +34,6 @@ else()
     if(CUDA_FIND_REQUIRED)
         message(FATAL_ERROR ${MSG_NOT_FOUND})
     else()
-        message(WARNING ${MSG_NOT_FOUND})
+        message(STATUS ${MSG_NOT_FOUND})
     endif()
 endif()
diff --git a/cmake/FindJEMALLOC.cmake b/cmake/FindJEMALLOC.cmake
index 2dab1f383..9ee4812a2 100644
--- a/cmake/FindJEMALLOC.cmake
+++ b/cmake/FindJEMALLOC.cmake
@@ -23,7 +23,7 @@ else()
     if(JEMALLOC_FIND_REQUIRED)
         message(FATAL_ERROR ${MSG_NOT_FOUND})
     else()
-        message(WARNING ${MSG_NOT_FOUND})
+        message(STATUS ${MSG_NOT_FOUND})
     endif()
 endif()
 
@@ -41,6 +41,6 @@ else()
     if(JEMALLOC_FIND_REQUIRED)
         message(FATAL_ERROR ${MSG_NOT_FOUND})
     else()
-        message(WARNING ${MSG_NOT_FOUND})
+        message(STATUS ${MSG_NOT_FOUND})
     endif()
 endif()
diff --git a/cmake/FindLIBHWLOC.cmake b/cmake/FindLIBHWLOC.cmake
index 2efd072d4..630148476 100644
--- a/cmake/FindLIBHWLOC.cmake
+++ b/cmake/FindLIBHWLOC.cmake
@@ -76,6 +76,6 @@ else()
     if(LIBHWLOC_FIND_REQUIRED)
         message(FATAL_ERROR ${MSG_NOT_FOUND})
     else()
-        message(WARNING ${MSG_NOT_FOUND})
+        message(STATUS ${MSG_NOT_FOUND})
     endif()
 endif()
diff --git a/cmake/FindLIBNUMA.cmake b/cmake/FindLIBNUMA.cmake
index 8c23f481c..47c0658f0 100644
--- a/cmake/FindLIBNUMA.cmake
+++ b/cmake/FindLIBNUMA.cmake
@@ -1,4 +1,4 @@
-# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -15,6 +15,6 @@ else()
     if(LIBNUMA_FIND_REQUIRED)
         message(FATAL_ERROR ${MSG_NOT_FOUND})
     else()
-        message(WARNING ${MSG_NOT_FOUND})
+        message(STATUS ${MSG_NOT_FOUND})
     endif()
 endif()
diff --git a/cmake/FindTBB.cmake b/cmake/FindTBB.cmake
index 6536e8c4a..3393011c9 100644
--- a/cmake/FindTBB.cmake
+++ b/cmake/FindTBB.cmake
@@ -1,4 +1,4 @@
-# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -21,7 +21,7 @@ else()
     if(TBB_FIND_REQUIRED)
         message(FATAL_ERROR ${MSG_NOT_FOUND})
     else()
-        message(WARNING ${MSG_NOT_FOUND})
+        message(STATUS ${MSG_NOT_FOUND})
     endif()
 endif()
 
@@ -45,6 +45,6 @@ else()
     if(TBB_FIND_REQUIRED)
         message(FATAL_ERROR ${MSG_NOT_FOUND})
     else()
-        message(WARNING ${MSG_NOT_FOUND})
+        message(STATUS ${MSG_NOT_FOUND})
     endif()
 endif()
diff --git a/cmake/FindZE_LOADER.cmake b/cmake/FindZE_LOADER.cmake
index 6c071491d..81347cb7b 100644
--- a/cmake/FindZE_LOADER.cmake
+++ b/cmake/FindZE_LOADER.cmake
@@ -34,6 +34,6 @@ else()
     if(ZE_LOADER_FIND_REQUIRED)
         message(FATAL_ERROR ${MSG_NOT_FOUND})
     else()
-        message(WARNING ${MSG_NOT_FOUND})
+        message(STATUS ${MSG_NOT_FOUND})
     endif()
 endif()
diff --git a/cmake/helpers.cmake b/cmake/helpers.cmake
index 02aaf5c71..8fea0a743 100644
--- a/cmake/helpers.cmake
+++ b/cmake/helpers.cmake
@@ -225,7 +225,8 @@ endfunction()
 
 function(add_umf_target_compile_options name)
     check_add_target_compile_options(${name} "-Wno-covered-switch-default")
-
+    target_compile_definitions(${name}
+                               PRIVATE ${UMF_COMMON_COMPILE_DEFINITIONS})
     if(NOT MSVC)
         target_compile_options(
             ${name}
@@ -260,6 +261,10 @@ function(add_umf_target_compile_options name)
                                                        -g -O0)
             endif()
         endif()
+        if(UMF_USE_VALGRIND)
+            target_compile_definitions(${name} PRIVATE "UMF_VG_ENABLED=1")
+            target_include_directories(${name} PRIVATE ${VALGRIND_INCLUDE_DIRS})
+        endif()
     elseif(MSVC)
         target_compile_options(
             ${name}
@@ -386,6 +391,7 @@ function(add_umf_library)
     target_include_directories(
         ${ARG_NAME}
         PRIVATE ${UMF_CMAKE_SOURCE_DIR}/include
+                ${UMF_CMAKE_SOURCE_DIR}/src
                 ${UMF_CMAKE_SOURCE_DIR}/src/utils
                 ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc
                 ${UMF_CMAKE_SOURCE_DIR}/src/coarse)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 9b4b3f0f5..d11e04c4f 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -30,38 +30,16 @@ set(UMF_COMMON_COMPILE_DEFINITIONS
     ${UMF_COMMON_COMPILE_DEFINITIONS} UMF_VERSION=${UMF_VERSION}
     UMF_ALL_CMAKE_VARIABLES="${UMF_ALL_CMAKE_VARIABLES}")
 
-set(BA_SOURCES
-    ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_linear.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_global.c)
-
 add_subdirectory(utils)
+add_subdirectory(base_alloc)
 add_subdirectory(coarse)
 
-set(UMF_LIBS $<BUILD_INTERFACE:umf_utils> $<BUILD_INTERFACE:coarse>)
-
-set(CTL_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/ctl/ctl.c)
-
-if(LINUX)
-    set(BA_SOURCES ${BA_SOURCES}
-                   ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_linux.c)
-elseif(WINDOWS)
-    set(BA_SOURCES ${BA_SOURCES}
-                   ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_windows.c)
-elseif(MACOSX)
-    set(BA_SOURCES ${BA_SOURCES}
-                   ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_linux.c)
-endif()
-
-set(BA_SOURCES
-    ${BA_SOURCES}
-    PARENT_SCOPE)
+set(UMF_LIBS umf_utils umf_ba umf_coarse)
 
 set(HWLOC_DEPENDENT_SOURCES topology.c)
 
 set(UMF_SOURCES
-    ${BA_SOURCES}
-    ${CTL_SOURCES}
+    ctl/ctl.c
     libumf.c
     ipc.c
     ipc_cache.c
@@ -178,7 +156,7 @@ target_include_directories(umf PRIVATE ${UMF_PRIVATE_INCLUDE_DIRS})
 target_link_directories(umf PRIVATE ${UMF_PRIVATE_LIBRARY_DIRS})
 target_compile_definitions(umf PRIVATE ${UMF_COMMON_COMPILE_DEFINITIONS})
 
-add_dependencies(umf coarse)
+add_dependencies(umf umf_ba umf_coarse umf_utils)
 
 if(UMF_LINK_HWLOC_STATICALLY)
     add_dependencies(umf ${UMF_HWLOC_NAME})
@@ -228,8 +206,6 @@ target_include_directories(
 
 install(TARGETS umf EXPORT ${PROJECT_NAME}-targets)
 
-add_subdirectory(pool)
-
 if(UMF_PROXY_LIB_ENABLED)
     add_subdirectory(proxy_lib)
 endif()
diff --git a/src/base_alloc/CMakeLists.txt b/src/base_alloc/CMakeLists.txt
new file mode 100644
index 000000000..ed84cc9a5
--- /dev/null
+++ b/src/base_alloc/CMakeLists.txt
@@ -0,0 +1,28 @@
+# Copyright (C) 2025 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+include(${UMF_CMAKE_SOURCE_DIR}/cmake/helpers.cmake)
+
+set(UMF_BA_SOURCES_COMMON base_alloc_global.c base_alloc.c base_alloc_linear.c)
+set(UMF_BA_SOURCES_LINUX base_alloc_linux.c)
+set(UMF_BA_SOURCES_WINDOWS base_alloc_windows.c)
+
+if(LINUX OR MACOSX)
+    set(UMF_BA_SOURCES ${UMF_BA_SOURCES_COMMON} ${UMF_BA_SOURCES_LINUX})
+elseif(WINDOWS)
+    set(UMF_BA_SOURCES ${UMF_BA_SOURCES_COMMON} ${UMF_BA_SOURCES_WINDOWS})
+endif()
+
+add_umf_library(
+    NAME umf_ba
+    TYPE STATIC
+    SRCS ${UMF_BA_SOURCES}
+    LIBS umf_utils)
+
+target_include_directories(umf_ba
+                           PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc)
+
+if(NOT UMF_BUILD_SHARED_LIBRARY)
+    install(TARGETS umf_ba EXPORT ${PROJECT_NAME}-targets)
+endif()
diff --git a/src/coarse/CMakeLists.txt b/src/coarse/CMakeLists.txt
index c211f9a7b..32465b4e4 100644
--- a/src/coarse/CMakeLists.txt
+++ b/src/coarse/CMakeLists.txt
@@ -4,23 +4,21 @@
 
 include(${UMF_CMAKE_SOURCE_DIR}/cmake/helpers.cmake)
 
-set(COARSE_SOURCES coarse.c ../ravl/ravl.c)
-
-if(UMF_BUILD_SHARED_LIBRARY AND (NOT WINDOWS))
-    set(COARSE_EXTRA_SRCS ${BA_SOURCES})
-    set(COARSE_EXTRA_LIBS $<BUILD_INTERFACE:umf_utils>)
-endif()
+set(UMF_COARSE_SOURCES coarse.c ${UMF_CMAKE_SOURCE_DIR}/src/ravl/ravl.c)
+set(UMF_COARSE_LIBS umf_utils umf_ba)
 
 add_umf_library(
-    NAME coarse
+    NAME umf_coarse
     TYPE STATIC
-    SRCS ${COARSE_SOURCES} ${COARSE_EXTRA_SRCS}
-    LIBS ${COARSE_EXTRA_LIBS})
+    SRCS ${UMF_COARSE_SOURCES}
+    LIBS ${UMF_COARSE_LIBS})
 
 target_include_directories(
-    coarse
-    PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
-            $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>
-            $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src/ravl>)
+    umf_coarse
+    PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/coarse
+            ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc
+            ${UMF_CMAKE_SOURCE_DIR}/src/ravl)
 
-add_library(${PROJECT_NAME}::coarse ALIAS coarse)
+if(NOT UMF_BUILD_SHARED_LIBRARY)
+    install(TARGETS umf_coarse EXPORT ${PROJECT_NAME}-targets)
+endif()
diff --git a/src/pool/CMakeLists.txt b/src/pool/CMakeLists.txt
deleted file mode 100644
index 22aeab783..000000000
--- a/src/pool/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-# Copyright (C) 2023-2025 Intel Corporation
-# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-if(UMF_BUILD_SHARED_LIBRARY)
-    set(POOL_EXTRA_SRCS ${BA_SOURCES})
-    set(POOL_EXTRA_LIBS $<BUILD_INTERFACE:umf_utils>)
-endif()
-
-set(POOL_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS})
diff --git a/src/proxy_lib/CMakeLists.txt b/src/proxy_lib/CMakeLists.txt
index d6b07902d..494ef1ef2 100644
--- a/src/proxy_lib/CMakeLists.txt
+++ b/src/proxy_lib/CMakeLists.txt
@@ -1,56 +1,46 @@
-# Copyright (C) 2023-2024 Intel Corporation
+# Copyright (C) 2023-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 include(${UMF_CMAKE_SOURCE_DIR}/cmake/helpers.cmake)
 
-set(PROXY_SOURCES proxy_lib.c)
+set(UMF_PROXY_SOURCES_COMMON proxy_lib.c)
+set(UMF_PROXY_SOURCES_LINUX proxy_lib_linux.c)
+set(UMF_PROXY_SOURCES_WINDOWS proxy_lib_windows.c)
 
-set(PROXY_SOURCES_LINUX proxy_lib_linux.c)
-
-set(PROXY_SOURCES_WINDOWS proxy_lib_windows.c)
-
-set(PROXY_SOURCES_MACOSX proxy_lib_linux.c)
-
-if(LINUX)
-    set(PROXY_SOURCES ${PROXY_SOURCES} ${PROXY_SOURCES_LINUX})
+if(LINUX OR MACOSX)
+    set(UMF_PROXY_SOURCES ${UMF_PROXY_SOURCES_COMMON}
+                          ${UMF_PROXY_SOURCES_LINUX})
 elseif(WINDOWS)
-    set(PROXY_SOURCES ${PROXY_SOURCES} ${PROXY_SOURCES_WINDOWS})
-
+    set(UMF_PROXY_SOURCES ${UMF_PROXY_SOURCES_COMMON}
+                          ${UMF_PROXY_SOURCES_WINDOWS})
     # Add resource file needed for Windows to fill metadata in binary files
     configure_file("${CMAKE_CURRENT_SOURCE_DIR}/proxy_lib.rc.in"
                    "${CMAKE_CURRENT_BINARY_DIR}/proxy_lib.rc" IMMEDIATE @ONLY)
-    set(PROXY_SOURCES ${PROXY_SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/proxy_lib.rc)
-elseif(MACOSX)
-    set(PROXY_SOURCES ${PROXY_SOURCES} ${PROXY_SOURCES_MACOSX})
+    set(UMF_PROXY_SOURCES ${UMF_PROXY_SOURCES_COMMON}
+                          ${CMAKE_CURRENT_BINARY_DIR}/proxy_lib.rc)
 endif()
 
 add_umf_library(
     NAME umf_proxy
     TYPE SHARED
-    SRCS ${BA_SOURCES} ${PROXY_SOURCES}
-    LIBS umf_utils ${PROXY_LIBS}
+    SRCS ${UMF_PROXY_SOURCES}
+    LIBS umf umf_utils umf_ba
     LINUX_MAP_FILE ${CMAKE_CURRENT_SOURCE_DIR}/proxy_lib.map
     WINDOWS_DEF_FILE ${CMAKE_CURRENT_SOURCE_DIR}/proxy_lib.def)
-set_target_properties(umf_proxy PROPERTIES SOVERSION ${PROJECT_VERSION_MAJOR})
-
-add_library(${PROJECT_NAME}::proxy ALIAS umf_proxy)
 
-target_link_directories(umf_proxy PRIVATE ${LIBHWLOC_LIBRARY_DIRS})
-
-target_compile_definitions(umf_proxy PRIVATE ${UMF_COMMON_COMPILE_DEFINITIONS})
+set_target_properties(umf_proxy PROPERTIES SOVERSION ${PROJECT_VERSION_MAJOR})
 
 if(PROXY_LIB_USES_SCALABLE_POOL)
-    target_compile_definitions(umf_proxy PRIVATE PROXY_LIB_USES_SCALABLE_POOL=1)
+    target_compile_definitions(umf_proxy
+                               PRIVATE "PROXY_LIB_USES_SCALABLE_POOL=1")
 elseif(PROXY_LIB_USES_JEMALLOC_POOL)
-    target_compile_definitions(umf_proxy PRIVATE PROXY_LIB_USES_JEMALLOC_POOL=1)
+    target_compile_definitions(umf_proxy
+                               PRIVATE "PROXY_LIB_USES_JEMALLOC_POOL=1")
 endif()
 
 target_include_directories(
-    umf_proxy
-    PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
-           $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src/utils>
-           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-           $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
+    umf_proxy PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc
+                      ${UMF_CMAKE_SOURCE_DIR}/src/ravl)
 
 install(TARGETS umf_proxy EXPORT ${PROJECT_NAME}-targets)
diff --git a/src/utils/CMakeLists.txt b/src/utils/CMakeLists.txt
index 976a2cb62..7125d2603 100644
--- a/src/utils/CMakeLists.txt
+++ b/src/utils/CMakeLists.txt
@@ -6,32 +6,12 @@ include(${UMF_CMAKE_SOURCE_DIR}/cmake/helpers.cmake)
 include(FindThreads)
 
 set(UMF_UTILS_SOURCES_COMMON utils_common.c utils_log.c utils_load_library.c)
-
 set(UMF_UTILS_SOURCES_POSIX utils_posix_common.c utils_posix_concurrency.c)
-
 set(UMF_UTILS_SOURCES_LINUX utils_linux_common.c)
-
 set(UMF_UTILS_SOURCES_MACOSX utils_macosx_common.c)
-
 set(UMF_UTILS_SOURCES_WINDOWS utils_windows_common.c
                               utils_windows_concurrency.c)
 
-if(UMF_USE_VALGRIND)
-    if(UMF_USE_ASAN
-       OR UMF_USE_TSAN
-       OR UMF_USE_UBSAN
-       OR UMF_USE_MSAN)
-        message(FATAL_ERROR "Cannot use valgrind and sanitizers together")
-    endif()
-
-    if(PkgConfig_FOUND)
-        pkg_check_modules(VALGRIND valgrind)
-    endif()
-    if(NOT VALGRIND_FOUND)
-        find_package(VALGRIND REQUIRED valgrind)
-    endif()
-endif()
-
 if(LINUX OR MACOSX)
     set(UMF_UTILS_SOURCES ${UMF_UTILS_SOURCES_COMMON}
                           ${UMF_UTILS_SOURCES_POSIX})
@@ -48,24 +28,12 @@ elseif(WINDOWS)
                           ${UMF_UTILS_SOURCES_WINDOWS})
 endif()
 
-add_library(umf_utils INTERFACE)
-add_library(${PROJECT_NAME}::utils ALIAS umf_utils)
-
-target_sources(umf_utils INTERFACE ${UMF_UTILS_SOURCES})
-target_link_libraries(umf_utils INTERFACE ${CMAKE_THREAD_LIBS_INIT}
-                                          ${UMF_UTILS_LIBS})
+add_umf_library(
+    NAME umf_utils
+    TYPE STATIC
+    SRCS ${UMF_UTILS_SOURCES}
+    LIBS ${UMF_UTILS_LIBS} ${CMAKE_THREAD_LIBS_INIT})
 
-target_include_directories(
-    umf_utils
-    INTERFACE ${VALGRIND_INCLUDE_DIRS}
-              $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
-              $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
-
-if(UMF_USE_VALGRIND)
-    set(UMF_UTILS_INTERFACE_DEFS "UMF_VG_ENABLED=1")
+if(NOT UMF_BUILD_SHARED_LIBRARY)
+    install(TARGETS umf_utils EXPORT ${PROJECT_NAME}-targets)
 endif()
-
-set(UMF_UTILS_INTERFACE_DEFS ${UMF_UTILS_INTERFACE_DEFS}
-                             ${UMF_COMMON_COMPILE_DEFINITIONS})
-
-target_compile_definitions(umf_utils INTERFACE ${UMF_UTILS_INTERFACE_DEFS})
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 1f5242a92..41c5b8dc3 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -29,6 +29,7 @@ enable_testing()
 
 set(UMF_TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(UMF_UTILS_DIR ${UMF_CMAKE_SOURCE_DIR}/src/utils)
+set(UMF_BA_DIR ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc)
 
 function(build_umf_test)
     # Parameters:
@@ -72,12 +73,7 @@ function(build_umf_test)
         set(CPL_DEFS ${CPL_DEFS} UMF_POOL_SCALABLE_ENABLED=1)
     endif()
 
-    set(TEST_LIBS
-        umf_test_common
-        ${ARG_LIBS}
-        GTest::gtest_main
-        ${LIBS_OPTIONAL}
-        umf)
+    set(TEST_LIBS umf_test_common ${ARG_LIBS} GTest::gtest_main umf)
 
     add_umf_executable(
         NAME ${TEST_TARGET_NAME}
@@ -162,8 +158,10 @@ endfunction()
 add_subdirectory(common)
 
 if(UMF_BUILD_SHARED_LIBRARY)
-    # if build as shared library, utils symbols won't be visible in tests
+    # if build as shared library, utils and Base Alloc symbols won't be visible
+    # in tests
     set(UMF_UTILS_FOR_TEST umf_utils)
+    set(UMF_BA_FOR_TEST umf_ba)
     if(LINUX OR MACOSX)
         set(UMF_UTILS_SOURCES
             ${UMF_UTILS_DIR}/utils_common.c
@@ -185,20 +183,18 @@ if(UMF_BUILD_SHARED_LIBRARY)
     endif()
 endif()
 
-if(UMF_BUILD_SHARED_LIBRARY)
-    # if build as shared library, ba symbols won't be visible in tests
-    set(BA_SOURCES_FOR_TEST ${BA_SOURCES})
-endif()
-
 add_umf_test(NAME base SRCS base.cpp)
+
 add_umf_test(
     NAME memoryPool
-    SRCS memoryPoolAPI.cpp malloc_compliance_tests.cpp ${BA_SOURCES_FOR_TEST}
-    LIBS ${UMF_UTILS_FOR_TEST})
+    SRCS memoryPoolAPI.cpp malloc_compliance_tests.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+
 add_umf_test(
     NAME memoryProvider
-    SRCS memoryProviderAPI.cpp ${BA_SOURCES_FOR_TEST}
-    LIBS ${UMF_UTILS_FOR_TEST})
+    SRCS memoryProviderAPI.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+
 add_umf_test(
     NAME logger
     SRCS utils/utils_log.cpp ${UMF_UTILS_SOURCES}
@@ -207,12 +203,11 @@ add_umf_test(
 add_umf_test(
     NAME ctl_unittest
     SRCS ctl/ctl_unittest.cpp ctl/ctl_debug.c ../src/ctl/ctl.c
-         ${BA_SOURCES_FOR_TEST}
-    LIBS ${UMF_UTILS_FOR_TEST})
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 
 add_umf_test(
     NAME ctl_api
-    SRCS ctl/ctl_api.cpp ${BA_SOURCES_FOR_TEST}
+    SRCS ctl/ctl_api.cpp
     LIBS ${UMF_UTILS_FOR_TEST})
 
 add_umf_test(
@@ -229,26 +224,25 @@ endif()
 
 add_umf_test(
     NAME coarse_lib
-    SRCS coarse_lib.cpp ${BA_SOURCES_FOR_TEST}
-    LIBS ${UMF_UTILS_FOR_TEST} coarse)
+    SRCS coarse_lib.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} umf_coarse)
 
 add_umf_test(
     NAME disjoint_pool
     SRCS pools/disjoint_pool.cpp malloc_compliance_tests.cpp
-         ${BA_SOURCES_FOR_TEST}
-    LIBS ${UMF_UTILS_FOR_TEST})
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 
 add_umf_test(
     NAME c_api_disjoint_pool
-    SRCS c_api/disjoint_pool.c ${BA_SOURCES_FOR_TEST}
+    SRCS c_api/disjoint_pool.c
     LIBS ${UMF_UTILS_FOR_TEST})
 
 if(LINUX AND (NOT UMF_DISABLE_HWLOC))
     # this test uses the file provider
     add_umf_test(
         NAME disjoint_pool_file_prov
-        SRCS disjoint_pool_file_prov.cpp ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        SRCS disjoint_pool_file_prov.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 endif()
 
 if(UMF_POOL_JEMALLOC_ENABLED
@@ -261,16 +255,14 @@ if(UMF_POOL_JEMALLOC_ENABLED AND (NOT UMF_DISABLE_HWLOC))
     add_umf_test(
         NAME jemalloc_pool
         SRCS pools/jemalloc_pool.cpp malloc_compliance_tests.cpp
-             ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 endif()
 
 if(UMF_POOL_SCALABLE_ENABLED AND (NOT UMF_DISABLE_HWLOC))
     add_umf_test(
         NAME scalable_pool
         SRCS pools/scalable_pool.cpp malloc_compliance_tests.cpp
-             ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 endif()
 
 if(LINUX AND (NOT UMF_DISABLE_HWLOC)) # OS-specific functions are implemented
@@ -284,40 +276,46 @@ if(LINUX AND (NOT UMF_DISABLE_HWLOC)) # OS-specific functions are implemented
 
     add_umf_test(
         NAME provider_os_memory
-        SRCS provider_os_memory.cpp ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        SRCS provider_os_memory.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_os_memory_multiple_numa_nodes
         SRCS provider_os_memory_multiple_numa_nodes.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES})
     add_umf_test(
         NAME memspace_numa
         SRCS memspaces/memspace_numa.cpp
-        LIBS ${LIBNUMA_LIBRARIES} ${UMF_HWLOC_NAME})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME provider_os_memory_config
         SRCS provider_os_memory_config.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES} ${UMF_HWLOC_NAME})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME memspace_host_all
         SRCS memspaces/memspace_host_all.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES} ${UMF_HWLOC_NAME})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME memspace_highest_capacity
         SRCS memspaces/memspace_highest_capacity.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES} ${UMF_HWLOC_NAME})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME memspace_highest_bandwidth
         SRCS memspaces/memspace_highest_bandwidth.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES} ${UMF_HWLOC_NAME})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME memspace_lowest_latency
         SRCS memspaces/memspace_lowest_latency.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES} ${UMF_HWLOC_NAME})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME mempolicy
         SRCS memspaces/mempolicy.cpp
-        LIBS ${LIBNUMA_LIBRARIES})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES})
     add_umf_test(
         NAME memspace
         SRCS memspaces/memspace.cpp
@@ -329,45 +327,42 @@ if(LINUX AND (NOT UMF_DISABLE_HWLOC)) # OS-specific functions are implemented
     add_umf_test(
         NAME provider_devdax_memory
         SRCS provider_devdax_memory.cpp
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_devdax_memory_ipc
-        SRCS provider_devdax_memory_ipc.cpp ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        SRCS provider_devdax_memory_ipc.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_file_memory
         SRCS provider_file_memory.cpp
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_file_memory_ipc
-        SRCS provider_file_memory_ipc.cpp ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        SRCS provider_file_memory_ipc.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_fixed_memory
         SRCS provider_fixed_memory.cpp
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_tracking
         SRCS provider_tracking.cpp
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_tracking_fixture_tests
         SRCS provider_tracking_fixture_tests.cpp malloc_compliance_tests.cpp
-             ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 
     # This test requires Linux-only file memory provider
     if(UMF_POOL_JEMALLOC_ENABLED)
         add_umf_test(
             NAME jemalloc_coarse_file
             SRCS pools/jemalloc_coarse_file.cpp malloc_compliance_tests.cpp
-                 ${BA_SOURCES_FOR_TEST}
-            LIBS ${UMF_UTILS_FOR_TEST})
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
         add_umf_test(
             NAME jemalloc_coarse_devdax
             SRCS pools/jemalloc_coarse_devdax.cpp malloc_compliance_tests.cpp
-                 ${BA_SOURCES_FOR_TEST}
-            LIBS ${UMF_UTILS_FOR_TEST})
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     endif()
 
     # This test requires Linux-only file memory provider
@@ -375,13 +370,11 @@ if(LINUX AND (NOT UMF_DISABLE_HWLOC)) # OS-specific functions are implemented
         add_umf_test(
             NAME scalable_coarse_file
             SRCS pools/scalable_coarse_file.cpp malloc_compliance_tests.cpp
-                 ${BA_SOURCES_FOR_TEST}
-            LIBS ${UMF_UTILS_FOR_TEST})
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
         add_umf_test(
             NAME scalable_coarse_devdax
             SRCS pools/scalable_coarse_devdax.cpp malloc_compliance_tests.cpp
-                 ${BA_SOURCES_FOR_TEST}
-            LIBS ${UMF_UTILS_FOR_TEST})
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     endif()
 
     if(UMF_BUILD_FUZZTESTS)
@@ -391,18 +384,18 @@ else()
     add_umf_test(
         NAME provider_file_memory_not_impl
         SRCS provider_file_memory_not_impl.cpp
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_devdax_memory_not_impl
         SRCS provider_devdax_memory_not_impl.cpp
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 endif()
 
 if(UMF_DISABLE_HWLOC)
     add_umf_test(
         NAME provider_os_memory_not_impl
         SRCS provider_os_memory_not_impl.cpp
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 endif()
 
 if(UMF_BUILD_GPU_TESTS AND UMF_LEVEL_ZERO_ENABLED)
@@ -412,22 +405,22 @@ if(UMF_BUILD_GPU_TESTS AND UMF_LEVEL_ZERO_ENABLED)
     add_umf_test(
         NAME provider_level_zero
         SRCS providers/provider_level_zero.cpp
-             ${UMF_UTILS_DIR}/utils_level_zero.cpp ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST} ze_loader)
+             ${UMF_UTILS_DIR}/utils_level_zero.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ze_loader)
 
     add_umf_test(
         NAME provider_level_zero_dlopen_global
         SRCS providers/provider_level_zero.cpp
-             ${UMF_UTILS_DIR}/utils_level_zero.cpp ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+             ${UMF_UTILS_DIR}/utils_level_zero.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     target_compile_definitions(test_provider_level_zero_dlopen_global
                                PUBLIC USE_DLOPEN=1 OPEN_ZE_LIBRARY_GLOBAL=1)
 
     add_umf_test(
         NAME provider_level_zero_dlopen_local
         SRCS providers/provider_level_zero.cpp
-             ${UMF_UTILS_DIR}/utils_level_zero.cpp ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+             ${UMF_UTILS_DIR}/utils_level_zero.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     target_compile_definitions(test_provider_level_zero_dlopen_local
                                PUBLIC USE_DLOPEN=1 OPEN_ZE_LIBRARY_GLOBAL=0)
 endif()
@@ -447,22 +440,19 @@ if(UMF_BUILD_GPU_TESTS AND UMF_BUILD_CUDA_PROVIDER)
         add_umf_test(
             NAME provider_cuda
             SRCS providers/provider_cuda.cpp providers/cuda_helpers.cpp
-                 ${BA_SOURCES_FOR_TEST}
-            LIBS ${UMF_UTILS_FOR_TEST} cuda)
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} cuda)
 
         add_umf_test(
             NAME provider_cuda_dlopen_global
             SRCS providers/provider_cuda.cpp providers/cuda_helpers.cpp
-                 ${BA_SOURCES_FOR_TEST}
-            LIBS ${UMF_UTILS_FOR_TEST})
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
         target_compile_definitions(test_provider_cuda_dlopen_global
                                    PUBLIC USE_DLOPEN=1 OPEN_CU_LIBRARY_GLOBAL=1)
 
         add_umf_test(
             NAME provider_cuda_dlopen_local
             SRCS providers/provider_cuda.cpp providers/cuda_helpers.cpp
-                 ${BA_SOURCES_FOR_TEST}
-            LIBS ${UMF_UTILS_FOR_TEST})
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
         target_compile_definitions(test_provider_cuda_dlopen_local
                                    PUBLIC USE_DLOPEN=1 OPEN_CU_LIBRARY_GLOBAL=0)
     else()
@@ -482,31 +472,30 @@ endif()
 
 add_umf_test(
     NAME base_alloc
-    SRCS ${BA_SOURCES_FOR_TEST} test_base_alloc.cpp
-    LIBS ${UMF_UTILS_FOR_TEST})
+    SRCS test_base_alloc.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 add_umf_test(
     NAME base_alloc_linear
-    SRCS ${BA_SOURCES_FOR_TEST} test_base_alloc_linear.cpp
-    LIBS ${UMF_UTILS_FOR_TEST})
+    SRCS test_base_alloc_linear.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 
 add_umf_test(
     NAME base_alloc_global
-    SRCS ${BA_SOURCES_FOR_TEST} pools/pool_base_alloc.cpp
-         malloc_compliance_tests.cpp
-    LIBS ${UMF_UTILS_FOR_TEST})
+    SRCS pools/pool_base_alloc.cpp malloc_compliance_tests.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 
 # tests for the proxy library
 if(UMF_PROXY_LIB_ENABLED AND UMF_BUILD_SHARED_LIBRARY)
     add_umf_test(
         NAME proxy_lib_basic
-        SRCS ${BA_SOURCES_FOR_TEST} test_proxy_lib.cpp
+        SRCS test_proxy_lib.cpp
         LIBS ${UMF_UTILS_FOR_TEST} umf_proxy)
 
     # TODO enable this test on Windows
     if(LINUX)
         add_umf_test(
             NAME proxy_lib_size_threshold
-            SRCS ${BA_SOURCES_FOR_TEST} test_proxy_lib_size_threshold.cpp
+            SRCS test_proxy_lib_size_threshold.cpp
             LIBS ${UMF_UTILS_FOR_TEST} umf_proxy)
         set_property(TEST test_proxy_lib_size_threshold
                      PROPERTY ENVIRONMENT UMF_PROXY="size.threshold=64")
@@ -515,22 +504,21 @@ if(UMF_PROXY_LIB_ENABLED AND UMF_BUILD_SHARED_LIBRARY)
     # the memoryPool test run with the proxy library
     add_umf_test(
         NAME proxy_lib_memoryPool
-        SRCS ${BA_SOURCES_FOR_TEST} memoryPoolAPI.cpp
-             malloc_compliance_tests.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} umf_proxy)
+        SRCS memoryPoolAPI.cpp malloc_compliance_tests.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} umf_proxy)
     target_compile_definitions(test_proxy_lib_memoryPool
                                PUBLIC UMF_PROXY_LIB_ENABLED=1)
 endif()
 
 add_umf_test(
     NAME ipc
-    SRCS ipcAPI.cpp ${BA_SOURCES_FOR_TEST}
-    LIBS ${UMF_UTILS_FOR_TEST})
+    SRCS ipcAPI.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 
 add_umf_test(
     NAME ipc_max_opened_limit
-    SRCS ipcAPI.cpp ${BA_SOURCES_FOR_TEST}
-    LIBS ${UMF_UTILS_FOR_TEST}
+    SRCS ipcAPI.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST}
     ENVS "UMF_MAX_OPENED_IPC_HANDLES=10")
 
 add_umf_test(NAME ipc_negative SRCS ipc_negative.cpp)
diff --git a/test/test_installation.py b/test/test_installation.py
index 5c686e935..cba8a4fb3 100644
--- a/test/test_installation.py
+++ b/test/test_installation.py
@@ -125,6 +125,9 @@ def _create_match_list(self) -> List[str]:
                 )
                 lib.append(f"lib/{lib_prefix}umf.{self.umf_version}.{lib_ext_shared}")
         else:
+            lib.append(f"lib/{lib_prefix}umf_ba.{lib_ext_static}")
+            lib.append(f"lib/{lib_prefix}umf_coarse.{lib_ext_static}")
+            lib.append(f"lib/{lib_prefix}umf_utils.{lib_ext_static}")
             lib.append(f"lib/{lib_prefix}umf.{lib_ext_static}")
             if self.umfd_lib and platform.system() == "Windows":
                 lib.append(f"lib/{lib_prefix}umfd.{lib_ext_static}")