diff --git a/.cmake-format b/.cmake-format
index 57ad821ef8..ed478467a3 100644
--- a/.cmake-format
+++ b/.cmake-format
@@ -9,31 +9,33 @@ with section("parse"):
       "pargs": 0,
       "flags": [],
       'kwargs': {
-        'NAME': '*', 
-        'SRCS': '*', 
-        'LIBS': '*' , 
-        'LIBDIRS': '*'}},
+        'NAME': '*',
+        'SRCS': '*',
+        'LIBS': '*' ,
+        'LIBDIRS': '*',
+        'TESTARGS': '*'}},
     'add_umf_executable': {
       "pargs": 0,
       "flags": [],
       'kwargs': {
-        'NAME': '*', 
-        'SRCS': '*', 
+        'NAME': '*',
+        'SRCS': '*',
         'LIBS': '*'}},
     'add_umf_test': {
       "pargs": 0,
       "flags": [],
       'kwargs': {
-        'NAME': '*', 
-        'SRCS': '*', 
-        'LIBS': '*'}},
+        'NAME': '*',
+        'SRCS': '*',
+        'LIBS': '*',
+        'ENVS': '*'}},
     'add_umf_library': {
       "pargs": 0,
       "flags": [],
       'kwargs': {
-        'NAME': '*', 
-        'TYPE': '*', 
-        'SRCS': '*', 
+        'NAME': '*',
+        'TYPE': '*',
+        'SRCS': '*',
         'LIBS': '*',
         'LINUX_MAP_FILE': '*',
         'WINDOWS_DEF_FILE': '*'}},
@@ -43,7 +45,20 @@ with section("parse"):
       'kwargs': {
         'LABELS': '*', 
         'PASS_REGULAR_EXPRESSION': '*'}},
-  }    
+    'build_umf_test': {
+      "pargs": 0,
+      "flags": [],
+      'kwargs': {
+        'NAME': '*',
+        'SRCS': '*',
+        'LIBS': '*' }},
+    'add_umf_ipc_test': {
+      "pargs": 0,
+      "flags": [],
+      'kwargs': {
+        'TEST': '*',
+        'SRC_DIR': '*'}},
+  }
 
   # Override configurations per-command where available
   override_spec = {}
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
new file mode 100644
index 0000000000..a897ef815b
--- /dev/null
+++ b/.github/copilot-instructions.md
@@ -0,0 +1,127 @@
+# UMF (Unified Memory Framework) - AI Coding Guide
+
+## Project Architecture
+
+UMF is a C library for constructing memory allocators and pools, built around a two-layer architecture:
+
+- **Memory Providers** (`src/provider/`): Handle coarse-grained OS-level memory allocation (mmap, CUDA, Level Zero, etc.)
+- **Memory Pools** (`src/pool/`): Handle fine-grained allocation using providers as backing store (jemalloc, scalable, disjoint)
+
+Key architectural patterns:
+- Provider/pool separation enables mixing any provider with any pool allocator
+- Operations structures (`*_ops_t`) define plugin interfaces for extensibility
+- Handle-based API (`*_handle_t`) abstracts implementation details
+- Result codes (`umf_result_t`) for consistent error handling
+
+## Development Workflows
+
+### Build System
+```bash
+# Standard build
+cmake -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build -j $(nproc)
+
+# Enable all features for development
+# GPU tests will work only in an environment with proper hardware and drivers
+cmake -B build -DCMAKE_BUILD_TYPE=Debug \
+  -DUMF_BUILD_TESTS=ON -DUMF_BUILD_GPU_TESTS=OFF \
+  -DUMF_BUILD_EXAMPLES=ON -DUMF_DEVELOPER_MODE=ON \
+  -DUMF_FORMAT_CODE_STYLE=ON
+```
+
+### Version Management
+- Version determined by:
+  1. `git describe` (preferred)
+  2. `VERSION` file fallback
+  3. "0.0.0" default
+- `set_version_variables()` in `cmake/helpers.cmake` handles version detection
+- For releases: create `VERSION` file with semver format (e.g., "1.0.3")
+
+### Code Formatting
+- **Always format code before committing**: `make format-apply`
+- Requires build with `-DUMF_FORMAT_CODE_STYLE=ON`
+- Uses clang-format-15.0, cmake-format-0.6, and black for Python
+
+### Testing Patterns
+- Use `build_umf_test()` CMake function in `test/CMakeLists.txt`
+- GPU tests require `UMF_BUILD_GPU_TESTS=ON` and hardware/drivers
+- IPC tests use producer/consumer pattern with shell scripts
+- Platform-specific tests: `.c` files for portability, `.cpp` for C++ features, utils, and selected tests
+
+### CI/CD Structure
+- `pr_push.yml`: Main workflow calling reusable workflows. It's called for each PR change or push to main/stable branches
+- Separate workflows for different configurations: `reusable_gpu.yml`, `reusable_sanitizers.yml`, etc.
+- Provider-specific testing: Level Zero, CUDA runners with actual hardware
+
+## Coding Conventions
+
+### Naming Patterns
+- Public API: `umf*` prefix (e.g., `umfMemoryProviderCreate`)
+- Internal functions: `snake_case` without prefix
+- Structures: `*_t` suffix for types, `*_handle_t` for opaque handles
+- Constants: `UMF_*` uppercase with underscores
+
+### Memory Management Patterns
+- Always pair create/destroy functions (e.g., `umfMemoryProviderCreate`/`umfMemoryProviderDestroy`)
+- Use `umf_result_t` return codes, never throw exceptions
+- Provider params have separate create/destroy lifecycle
+- Thread-local storage (`__TLS`) for error state in providers
+
+### Provider Implementation Pattern
+```c
+// Standard provider structure
+typedef struct my_provider_t {
+    // Provider-specific state
+} my_provider_t;
+
+static umf_result_t my_initialize(const void *params, void **provider);
+static umf_result_t my_finalize(void *provider);
+static umf_result_t my_alloc(void *provider, size_t size, size_t alignment, void **ptr);
+static umf_result_t my_free(void *provider, void *ptr, size_t size);
+
+static const umf_memory_provider_ops_t MY_PROVIDER_OPS = {
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
+    .initialize = my_initialize,
+    .finalize = my_finalize,
+    .alloc = my_alloc,
+    .free = my_free,
+    // ... other required ops
+};
+```
+
+## Key Files and Patterns
+
+### Core APIs
+- `include/umf.h`: Main header, include this for basic usage
+- `include/umf/memory_provider_ops.h`: Provider plugin interface
+- `include/umf/memory_pool_ops.h`: Pool plugin interface
+
+### Common Utilities
+- `src/utils/`: Logging (`utils_log.h`), concurrency (`utils_concurrency.h`), assertions
+- `src/critnib/`: Concurrent radix tree for address tracking
+- `src/base_alloc/`: Base allocation utilities
+
+### Platform Abstractions
+- `libumf_linux.c`/`libumf_windows.c`: OS-specific implementations
+- `topology.c`: HWLOC integration for NUMA topology discovery
+- Provider files handle platform-specific allocation (CUDA, Level Zero, OS memory)
+
+## Integration Points
+
+### NUMA Support
+- Uses HWLOC for topology discovery (`topology.c`, `umf_hwloc.h`)
+- NUMA policies in `mempolicy.c`: bind, interleave, split modes
+- Memory spaces (`memspace.c`) and targets (`memtarget.c`) for NUMA abstraction
+
+### GPU Integration
+- Level Zero provider: `provider_level_zero.c` for Intel GPUs
+- CUDA provider: `provider_cuda.c` for NVIDIA GPUs
+- Examples in `examples/level_zero_shared_memory/` and `examples/cuda_shared_memory/`
+
+### IPC (Inter-Process Communication)
+- Linux-specific implementation using file descriptor passing
+- Requires `PTRACE_MODE_ATTACH_REALCREDS` permission
+- Uses `memfd_create()` or `memfd_secret()` for anonymous shared memory
+
+When implementing new providers or pools, follow the existing patterns in
+`src/provider/provider_os_memory.c` and `src/pool/pool_scalable.c` as reference implementations.
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index f00070d215..26262ec8a7 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -4,7 +4,7 @@ updates:
   - package-ecosystem: "pip"
     directory: "/third_party" # Location of package manifests
     schedule:
-      interval: "daily"
+      interval: "monthly"
     ignore:
       - dependency-name: "clang-format"
       - dependency-name: "cmake-format"
@@ -14,3 +14,12 @@ updates:
         applies-to: version-updates
         patterns:
           - "*"
+  - package-ecosystem: "github-actions"
+    directory: "/.github/workflows/"
+    schedule:
+      interval: "monthly"
+    groups:
+      actions-dependencies:
+        applies-to: version-updates
+        patterns:
+          - "*"
diff --git a/.github/docker/alpine-3.21.Dockerfile b/.github/docker/alpine-3.21.Dockerfile
new file mode 100644
index 0000000000..fef9810703
--- /dev/null
+++ b/.github/docker/alpine-3.21.Dockerfile
@@ -0,0 +1,46 @@
+# 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
+
+#
+# Dockerfile - a 'recipe' for Docker to build an image of Alpine
+#              environment for building the Unified Memory Framework project.
+#
+
+# Pull base Alpine image version 3.21
+FROM registry.hub.docker.com/library/alpine@sha256:a8560b36e8b8210634f77d9f7f9efd7ffa463e380b75e2e74aff4511df3ef88c
+
+# Set environment variables
+ENV OS=alpine
+ENV OS_VER=3.21
+
+# Base development packages
+ARG BASE_DEPS="\
+	bash \
+	cmake \
+	git \
+	g++ \
+	make \
+	sudo"
+
+# UMF's dependencies
+ARG UMF_DEPS="\
+	hwloc-dev"
+
+# Dependencies for tests
+ARG TEST_DEPS="\
+	numactl-dev"
+
+# Update and install required packages
+RUN apk update \
+ && apk add --no-cache \
+	${BASE_DEPS} \
+	${TEST_DEPS} \
+	${UMF_DEPS}
+
+# Add a new (non-root) 'test_user'
+ENV USER=test_user
+RUN adduser -D -G wheel ${USER}
+RUN echo '%wheel ALL=(ALL) NOPASSWD: ALL' >> /etc/sudoers
+
+USER test_user
diff --git a/.github/docker/ubuntu-20.04.Dockerfile b/.github/docker/ubuntu-20.04.Dockerfile
index 069deeac93..9de50673fa 100644
--- a/.github/docker/ubuntu-20.04.Dockerfile
+++ b/.github/docker/ubuntu-20.04.Dockerfile
@@ -1,20 +1,20 @@
-# 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
 
 #
 # Dockerfile - a 'recipe' for Docker to build an image of ubuntu-based
-#              environment for building the Unified Memory Framework project.
+#	  environment for building the Unified Memory Framework project.
 #
 
 # Pull base image ("20.04")
 FROM registry.hub.docker.com/library/ubuntu@sha256:f2034e7195f61334e6caff6ecf2e965f92d11e888309065da85ff50c617732b8
 
 # Set environment variables
-ENV OS ubuntu
-ENV OS_VER 20.04
-ENV NOTTY 1
-ENV DEBIAN_FRONTEND noninteractive
+ENV OS=ubuntu
+ENV OS_VER=20.04
+ENV NOTTY=1
+ENV DEBIAN_FRONTEND=noninteractive
 
 # Base development packages
 ARG BASE_DEPS="\
@@ -22,43 +22,50 @@ ARG BASE_DEPS="\
 	cmake \
 	git"
 
-# UMF's dependencies
-ARG UMF_DEPS="\
-	libjemalloc-dev \
-	libhwloc-dev \
-	libtbb-dev"
+# Hwloc installation dependencies
+ARG HWLOC_DEPS="\
+	libtool"
 
 # Dependencies for tests (optional)
 ARG TEST_DEPS="\
-	libnuma-dev"
+	libnuma-dev \
+	libtbb-dev \
+	valgrind"
 
 # Miscellaneous for our builds/CI (optional)
 ARG MISC_DEPS="\
+	automake \
 	clang \
 	g++-7 \
+	lcov \
 	python3-pip \
 	sudo \
 	whois"
 
+# libhwloc-dev is required - installed via script because hwloc version is too old on this OS
+COPY .github/scripts/install_hwloc.sh /opt/umf/install_hwloc.sh
+
 # Update and install required packages
 RUN apt-get update \
  && apt-get install -y --no-install-recommends \
 	${BASE_DEPS} \
-	${UMF_DEPS} \
 	${TEST_DEPS} \
 	${MISC_DEPS} \
+	${HWLOC_DEPS} \
+ && /opt/umf/install_hwloc.sh \
  && rm -rf /var/lib/apt/lists/* \
  && apt-get clean all
 
 # Prepare a dir (accessible by anyone)
-RUN mkdir --mode 777 /opt/umf/
+RUN mkdir -p --mode 777 /opt/umf/
 
 # Additional dependencies (installed via pip)
+# It's actively used and tested only on selected distros. Be aware
+# they may not work, because pip packages list differ from OS to OS.
 COPY third_party/requirements.txt /opt/umf/requirements.txt
-RUN pip3 install --no-cache-dir -r /opt/umf/requirements.txt
 
 # Add a new (non-root) 'test_user'
-ENV USER test_user
-ENV USERPASS pass
-RUN useradd -m "${USER}" -g sudo -p "$(mkpasswd ${USERPASS})"
+ENV USER=test_user
+ENV USERPASS=pass
+RUN useradd -m -u 1001 "${USER}" -g sudo -p "$(mkpasswd ${USERPASS})"
 USER test_user
diff --git a/.github/docker/ubuntu-22.04.Dockerfile b/.github/docker/ubuntu-22.04.Dockerfile
index 08d546083d..748a2d544c 100644
--- a/.github/docker/ubuntu-22.04.Dockerfile
+++ b/.github/docker/ubuntu-22.04.Dockerfile
@@ -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
 
@@ -11,30 +11,38 @@
 FROM registry.hub.docker.com/library/ubuntu@sha256:e6173d4dc55e76b87c4af8db8821b1feae4146dd47341e4d431118c7dd060a74
 
 # Set environment variables
-ENV OS ubuntu
-ENV OS_VER 22.04
-ENV NOTTY 1
-ENV DEBIAN_FRONTEND noninteractive
+ENV OS=ubuntu
+ENV OS_VER=22.04
+ENV NOTTY=1
+ENV DEBIAN_FRONTEND=noninteractive
 
 # Base development packages
+# 'libtool' is required when hwloc is statically linked and built from source
 ARG BASE_DEPS="\
 	build-essential \
 	cmake \
-	git"
+	git \
+	libtool \
+	wget"
 
 # UMF's dependencies
 ARG UMF_DEPS="\
-	libjemalloc-dev \
-	libhwloc-dev \
-	libtbb-dev"
+	libhwloc-dev"
 
 # Dependencies for tests (optional)
 ARG TEST_DEPS="\
-	libnuma-dev"
+	libnuma-dev \
+	libtbb-dev \
+	valgrind"
 
 # Miscellaneous for our builds/CI (optional)
+# 'pkg-config' is added only on one Ubuntu image to test both:
+# 	find_library and pkg-config methods of finding libraries.
 ARG MISC_DEPS="\
+	automake \
 	clang \
+	lcov \
+	pkg-config \
 	python3-pip \
 	sudo \
 	whois"
@@ -43,21 +51,21 @@ ARG MISC_DEPS="\
 RUN apt-get update \
  && apt-get install -y --no-install-recommends \
 	${BASE_DEPS} \
-	${UMF_DEPS} \
 	${TEST_DEPS} \
 	${MISC_DEPS} \
+	${UMF_DEPS} \
  && rm -rf /var/lib/apt/lists/* \
  && apt-get clean all
 
 # Prepare a dir (accessible by anyone)
-RUN mkdir --mode 777 /opt/umf/
+RUN mkdir -p --mode 777 /opt/umf/
 
 # Additional dependencies (installed via pip)
 COPY third_party/requirements.txt /opt/umf/requirements.txt
 RUN pip3 install --no-cache-dir -r /opt/umf/requirements.txt
 
 # Add a new (non-root) 'test_user'
-ENV USER test_user
-ENV USERPASS pass
-RUN useradd -m "${USER}" -g sudo -p "$(mkpasswd ${USERPASS})"
+ENV USER=test_user
+ENV USERPASS=pass
+RUN useradd -m -u 1001 "${USER}" -g sudo -p "$(mkpasswd ${USERPASS})"
 USER test_user
diff --git a/.github/docker/ubuntu-24.04.Dockerfile b/.github/docker/ubuntu-24.04.Dockerfile
new file mode 100644
index 0000000000..21e7f01602
--- /dev/null
+++ b/.github/docker/ubuntu-24.04.Dockerfile
@@ -0,0 +1,68 @@
+# 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
+
+#
+# Dockerfile - a 'recipe' for Docker to build an image of ubuntu-based
+#              environment for building the Unified Memory Framework project.
+#
+
+# Pull base image ("24.04")
+FROM registry.hub.docker.com/library/ubuntu@sha256:72297848456d5d37d1262630108ab308d3e9ec7ed1c3286a32fe09856619a782
+
+# Set environment variables
+ENV OS=ubuntu
+ENV OS_VER=24.04
+ENV NOTTY=1
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Base development packages
+# 'libtool' is required when hwloc is statically linked and built from source
+ARG BASE_DEPS="\
+	build-essential \
+	cmake \
+	git \
+	libtool \
+	wget"
+
+# UMF's dependencies
+ARG UMF_DEPS="\
+	libhwloc-dev"
+
+# Dependencies for tests (optional)
+ARG TEST_DEPS="\
+	libnuma-dev \
+	libtbb-dev \
+	valgrind"
+
+# Miscellaneous for our builds/CI (optional)
+ARG MISC_DEPS="\
+	automake \
+	clang \
+	lcov \
+	python3-pip \
+	sudo \
+	whois"
+
+# Update and install required packages
+RUN apt-get update \
+ && apt-get install -y --no-install-recommends \
+	${BASE_DEPS} \
+	${TEST_DEPS} \
+	${MISC_DEPS} \
+	${UMF_DEPS} \
+ && rm -rf /var/lib/apt/lists/* \
+ && apt-get clean all
+
+# Prepare a dir (accessible by anyone)
+RUN mkdir -p --mode 777 /opt/umf/
+
+# Additional dependencies (installed via pip)
+COPY third_party/requirements.txt /opt/umf/requirements.txt
+RUN pip3 install --no-cache-dir --break-system-packages -r /opt/umf/requirements.txt
+
+# Add a new (non-root) 'test_user'
+ENV USER=test_user
+ENV USERPASS=pass
+RUN useradd -m "${USER}" -g sudo -p "$(mkpasswd ${USERPASS})"
+USER test_user
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 89e8148565..35a7f05b65 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -36,3 +36,4 @@ Before checking all the boxes please mark the PR as draft.
 - [ ] All newly added source files have a license
 - [ ] All newly added source files are referenced in CMake files
 - [ ] Logger (with debug/info/... messages) is used
+- [ ] All API changes are reflected in docs and def/map files, and are tested
diff --git a/.github/scripts/alpine_build.sh b/.github/scripts/alpine_build.sh
new file mode 100755
index 0000000000..4bfdb44616
--- /dev/null
+++ b/.github/scripts/alpine_build.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+# 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
+
+# alpine_build.sh - Script for building UMF on Alpine image
+
+set -e
+
+UMF_BUILD_TYPE=$1
+WORKDIR=$2
+
+sudo chown $USER $WORKDIR
+cd unified-memory-framework
+
+cmake -B build -DCMAKE_BUILD_TYPE=$UMF_BUILD_TYPE -DUMF_BUILD_TESTS=ON -DUMF_BUILD_EXAMPLES=ON
+cmake --build build
diff --git a/.github/scripts/get_system_info.sh b/.github/scripts/get_system_info.sh
index 595d5e31ae..2aa19a298e 100755
--- a/.github/scripts/get_system_info.sh
+++ b/.github/scripts/get_system_info.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
-# 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
 
@@ -7,7 +7,7 @@
 
 function check_L0_version {
     if command -v dpkg &> /dev/null; then
-        dpkg -l | grep level-zero && return
+        dpkg -l | grep -iE "level-zero|libze|Compute Runtime|Level Zero" && return
     fi
 
     if command -v rpm &> /dev/null; then
@@ -15,7 +15,7 @@ function check_L0_version {
     fi
 
     if command -v zypper &> /dev/null; then
-        zypper se level-zero && return
+        zypper -n se level-zero || true
     fi
 
     echo "level-zero not installed"
@@ -26,32 +26,32 @@ function system_info {
 	cat /etc/os-release | grep -oP "PRETTY_NAME=\K.*"
 	cat /proc/version
 
-	# echo "**********SYCL-LS**********"
-	# source /opt/intel/oneapi/setvars.sh
-	# sycl-ls
+	echo "**********SYCL-LS**********"
+	source /opt/intel/oneapi/setvars.sh
+	sycl-ls
 
 	echo "**********numactl topology**********"
 	numactl -H
 
 	echo "**********VGA info**********"
-	lspci | grep -i VGA
+	lspci | grep -iE "vga|display|gpu"
 
-	# echo "**********CUDA Version**********"
-	# if command -v nvidia-smi &> /dev/null; then
-	# 	nvidia-smi
-	# else
-	# 	echo "CUDA not installed"
-	# fi
+	echo "**********CUDA Version**********"
+	if command -v nvidia-smi &> /dev/null; then
+		nvidia-smi
+	else
+		echo "CUDA not installed"
+	fi
 
 	echo "**********L0 Version**********"
 	check_L0_version
 
-	# echo "**********ROCm Version**********"
-	# if command -v rocminfo &> /dev/null; then
-	# 	rocminfo
-	# else
-	# 	echo "ROCm not installed"
-	# fi
+	echo "**********ROCm Version**********"
+	if command -v rocminfo &> /dev/null; then
+		rocminfo
+	else
+		echo "ROCm not installed"
+	fi
 
 	echo "******OpenCL*******"
 	# The driver version of OpenCL Graphics is the compute-runtime version
@@ -67,11 +67,15 @@ function system_info {
 	cat /proc/meminfo
 
 	echo "**********env variables**********"
-	echo "PATH=${PATH}"
-	echo "CPATH=${CPATH}"
-	echo "LD_LIBRARY_PATH=${LD_LIBRARY_PATH}"
-	echo "LIBRARY_PATH=${LIBRARY_PATH}"
-	echo "PKG_CONFIG_PATH=${PKG_CONFIG_PATH}"
+	echo "PATH=$PATH"
+	echo
+	echo "CPATH=$CPATH"
+	echo
+	echo "LD_LIBRARY_PATH=$LD_LIBRARY_PATH"
+	echo
+	echo "LIBRARY_PATH=$LIBRARY_PATH"
+	echo
+	echo "PKG_CONFIG_PATH=$PKG_CONFIG_PATH"
 	echo
 
 	echo "******build tools versions*******"
@@ -89,7 +93,7 @@ function system_info {
 
 	echo "***************all installed packages***************"
 	# Instructions below will return some minor errors, as they are dependent on the Linux distribution.
-	zypper se --installed-only 2>/dev/null || true
+	zypper -n se --installed-only 2>/dev/null || true
 	apt list --installed 2>/dev/null || true
 	yum list installed 2>/dev/null || true
 }
diff --git a/.github/scripts/install_oneAPI.sh b/.github/scripts/install_oneAPI.sh
new file mode 100755
index 0000000000..f2331e2eb7
--- /dev/null
+++ b/.github/scripts/install_oneAPI.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+# 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
+
+# install_oneAPI.sh - Script for installing Intel oneAPI from the official repository
+
+apt-get update
+apt-get install -y gpg-agent gnupg wget
+wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB | gpg --dearmor -o /usr/share/keyrings/oneapi-archive-keyring.gpg
+echo 'deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main' > /etc/apt/sources.list.d/oneAPI.list
+apt-get update
+apt-get install -y intel-oneapi-ippcp-devel intel-oneapi-ipp-devel intel-oneapi-common-oneapi-vars intel-oneapi-compiler-dpcpp-cpp
diff --git a/.github/scripts/run-codespell.py b/.github/scripts/run-codespell.py
new file mode 100644
index 0000000000..b87bf37bd5
--- /dev/null
+++ b/.github/scripts/run-codespell.py
@@ -0,0 +1,40 @@
+"""
+ Copyright (C) 2024 Intel Corporation
+
+ Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""
+
+import subprocess  # nosec B404
+import logging
+import sys
+
+logging.basicConfig(
+    level=logging.INFO, format="[%(levelname)s]: [%(asctime)s] %(message)s"
+)
+
+
+def codespell_scan():
+    try:
+        codespell_result = subprocess.run(  # nosec
+            [
+                "codespell",
+                "-H",
+                "--quiet-level=3",
+                "--skip=./.git,./.venv,./.github/workflows/.spellcheck-conf.toml",
+            ],
+            text=True,
+            stdout=subprocess.PIPE,
+        )
+        if codespell_result.returncode != 0:
+            for line in codespell_result.stdout.splitlines():
+                logging.error(line.strip())
+            sys.exit(1)
+        else:
+            logging.info("No spelling errors found")
+    except subprocess.CalledProcessError as ex:
+        logging.error(ex)
+        sys.exit(1)
+
+
+codespell_scan()
diff --git a/.github/workflows/.spellcheck-conf.toml b/.github/workflows/.spellcheck-conf.toml
index 24b9023fe3..bb0f480d69 100644
--- a/.github/workflows/.spellcheck-conf.toml
+++ b/.github/workflows/.spellcheck-conf.toml
@@ -1,6 +1,6 @@
 [default]
 # Don't correct the following words:
-extend-ignore-words-re = ["ASSER", "Tne", "ba", "BA"]
+extend-ignore-words-re = ["ASSER", "Tne", "ba", "BA", "PN", "usm"]
 
 [files]
 # completely exclude those files from consideration:
diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml
new file mode 100644
index 0000000000..080b8f777f
--- /dev/null
+++ b/.github/workflows/benchmarks.yml
@@ -0,0 +1,45 @@
+name: Compute Benchmarks
+
+on:
+  workflow_dispatch:
+    inputs:
+      pr_no:
+        description: PR number (if 0, it'll run on the main)
+        type: number
+      bench_script_params:
+        # If you want to save the results of the manual run in 'benchmark-results' branch,
+        # you have to pass '--save XXX', where XXX is the label of your results.
+        description: Parameters passed to script executing benchmark
+        type: string
+        required: false
+        default: ''
+      bench_script_compare:
+        description: Compare label, passed to script executing benchmark as '--compare <label>'
+        type: choice
+        required: false
+        default: 'Baseline_PVC'
+        options:
+          - 'Baseline_PVC'
+      runner:
+        description: Runner
+        type: choice
+        required: true
+        default: 'L0_PERF_PVC'
+        options:
+          - L0_PERF_PVC
+
+permissions:
+  contents: read
+
+jobs:
+  manual:
+    permissions:
+      contents: write
+      pull-requests: write
+    name: Compute Benchmarks
+    uses: ./.github/workflows/reusable_benchmarks.yml
+    with:
+      pr_no: ${{ inputs.pr_no }}
+      bench_script_params: ${{ inputs.bench_script_params }} --filter umf-benchmark
+      bench_script_compare: ${{ inputs.bench_script_compare }}
+      runner: ${{ inputs.runner }}
diff --git a/.github/workflows/coverity.yml b/.github/workflows/coverity.yml
index dfa03fc4f4..22394723ef 100644
--- a/.github/workflows/coverity.yml
+++ b/.github/workflows/coverity.yml
@@ -1,4 +1,4 @@
-# Coverity check
+# Coverity - static analysis build. It requires Coverity's token (set in CI's secret).
 name: Coverity
 
 on:
@@ -7,7 +7,7 @@ on:
       cov_push_tarball:
           description: 'Send Coverity tarball'
           required: true
-          default: 'true'
+          default: true
           type: boolean
   schedule:
     - cron: '0 0 * * *'
@@ -18,12 +18,12 @@ permissions:
 jobs:
   coverity:
     name: Coverity
-    # run only on upstream; forks do not know Username/Password
+    # run only on upstream; forks don't have token for upstream's cov project
     if: github.repository == 'oneapi-src/unified-memory-framework'
     runs-on: ubuntu-latest
     steps:
     - name: Checkout repository
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with: 
         ref: ${{ github.ref }}
         fetch-depth: 0
@@ -31,15 +31,17 @@ jobs:
     - name: Install apt packages
       run: |
         sudo apt-get update
-        sudo apt-get install -y cmake hwloc libhwloc-dev libjemalloc-dev libnuma-dev libtbb-dev
+        sudo apt-get install -y cmake hwloc libhwloc-dev libnuma-dev libtbb-dev
 
     - name: Download Coverity
-      run: |
-        wget -nv https://scan.coverity.com/download/linux64 --post-data "token=${{ secrets.COVERITY_SCAN_TOKEN }}&project=oneapi-src%2Funified-memory-framework" -O coverity_tool.tgz
+      run: >
+        wget
+        -O coverity_tool.tgz
+        -nv https://scan.coverity.com/download/linux64
+        --post-data "token=${{ secrets.COVERITY_SCAN_TOKEN }}&project=oneapi-src%2Funified-memory-framework"
 
     - name: Extract Coverity
-      run: |
-        tar xzf coverity_tool.tgz
+      run: tar xzf coverity_tool.tgz
 
     - name: Configure CMake
       run: >
@@ -49,7 +51,6 @@ jobs:
         -DUMF_FORMAT_CODE_STYLE=OFF
         -DUMF_DEVELOPER_MODE=OFF
         -DUMF_TESTS_FAIL_ON_SKIP=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
 
     - name: Build
@@ -61,8 +62,7 @@ jobs:
         cov-build --dir ${{github.workspace}}/cov-int cmake --build ${{github.workspace}}/build --config Release -j$(nproc)
 
     - name: Create tarball to analyze
-      run: >
-        tar czvf cov-int_umf.tgz cov-int
+      run: tar czvf cov-int_umf.tgz cov-int
 
     - name: Push to Coverity Scan
       if: ${{ github.event_name == 'schedule' || github.event.inputs.cov_push_tarball == 'true' }}
diff --git a/.github/workflows/detect_changes.yml b/.github/workflows/detect_changes.yml
new file mode 100644
index 0000000000..3458c4e4d3
--- /dev/null
+++ b/.github/workflows/detect_changes.yml
@@ -0,0 +1,45 @@
+name: DetectChanges
+
+on:
+  pull_request:
+    paths:
+      - '.github/docker/*.Dockerfile'
+      - '.github/scripts/*'
+  push:
+    paths:
+      - '.github/docker/*.Dockerfile'
+      - '.github/scripts/*'
+
+permissions:
+  contents: read
+  packages: read
+
+jobs:
+  DetectChanges:
+    runs-on: ubuntu-latest
+    outputs:
+      changed_files: ${{ steps.changed-files.outputs.all_changed_files }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        with:
+          fetch-depth: 0
+
+      - name: Get changed files
+        id: changed-files
+        uses: tj-actions/changed-files@24d32ffd492484c1d75e0c0b894501ddb9d30d62 #v47.0.0
+
+      - name: List all changed files
+        env:
+          ALL_CHANGED_FILES: ${{ steps.changed-files.outputs.all_changed_files }}
+        run: |
+          echo "Changed files: $ALL_CHANGED_FILES"
+
+  BuildDocker:
+    needs: DetectChanges
+    if: ${{ contains(join(needs.DetectChanges.outputs.changed_files, ' '), '.github/docker/') }}
+    uses: ./.github/workflows/reusable_dockers_build.yml
+    permissions:
+      contents: read
+      packages: write
+    secrets: inherit
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 3d9bfc29b4..196fae1094 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -4,6 +4,7 @@ name: GitHubPages
 on:
   push:
     branches: ["main"]
+  workflow_dispatch:
 
 # Cancel previous in-progress workflow, only the latest run is relevant
 concurrency:
@@ -14,44 +15,14 @@ permissions:
   contents: read
 
 jobs:
-  build:
-    name: Build docs
-    runs-on: ${{ github.repository_owner == 'oneapi-src' && 'intel-ubuntu-22.04' || 'ubuntu-latest' }}
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      with:
-        fetch-depth: 0
-
-    - name: Install doxygen
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y doxygen
-
-    # Latest distros do not allow global pip installation
-    - name: Install Python requirements in venv
-      run: |
-        python3 -m venv .venv
-        . .venv/bin/activate
-        echo "$PATH" >> $GITHUB_PATH
-        python3 -m pip install -r third_party/requirements.txt
-
-    - name: Setup PATH for python
-      run: echo "$HOME/.local/bin" >> $GITHUB_PATH
-
-    - name: Build the documentation
-      working-directory: scripts
-      run: python3 generate_docs.py
-
-    - name: Upload artifact
-      uses: actions/upload-pages-artifact@0252fc4ba7626f0298f0cf00902a25c6afc77fa8 # v3.0.0
-      with:
-        path: docs/html
+  DocsBuild:
+    uses: ./.github/workflows/reusable_docs_build.yml
+    with:
+      upload: true
 
-  deploy:
+  DocsDeploy:
     name: Deploy docs to GitHub Pages
-    needs: build
+    needs: DocsBuild
 
     permissions:
       pages: write
@@ -66,4 +37,4 @@ jobs:
     steps:
     - name: Deploy the documentation to GitHub Pages
       id: deployment
-      uses: actions/deploy-pages@87c3283f01cd6fe19a0ab93a23b2f6fcba5a8e42 # v4.0.3
+      uses: actions/deploy-pages@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e # v4.0.5
diff --git a/.github/workflows/docs_pr_push.yml b/.github/workflows/docs_pr_push.yml
new file mode 100644
index 0000000000..58280e53e3
--- /dev/null
+++ b/.github/workflows/docs_pr_push.yml
@@ -0,0 +1,36 @@
+# This workflow is strictly for documentation updates. It triggers only when files related
+# to documentation or specific workflows are edited, ensuring that the job runs only for
+# relevant changes.
+
+name: Documentation PR/push
+
+on:
+  push:
+    branches-ignore:
+      - 'dependabot/**'
+      - 'main'  # Ignore main branch as it's handled by docs.yml
+    paths:
+      - 'docs/**'
+      - 'include/**'
+      - .github/workflows/reusable_docs_build.yml
+      - .github/workflows/docs_pr_push.yml
+      - 'third_party/requirements.txt'
+
+  pull_request:
+    paths:
+      - 'docs/**'
+      - 'include/**'
+      - .github/workflows/reusable_docs_build.yml
+      - .github/workflows/docs_pr_push.yml
+      - 'third_party/requirements.txt'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  DocsBuild:
+    uses: ./.github/workflows/reusable_docs_build.yml
diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
index 281ae00615..3f13e8d133 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -1,73 +1,92 @@
 # Various non-standard tests, requiring e.g. longer run
 name: Nightly
 
-# This job is run at 00:00 UTC every day or on demand.
+# This job is run at 04:00 UTC every day or on demand.
 on:
   workflow_dispatch:
   schedule:
-    - cron:  '0 0 * * *'
+    - cron: '0 4 * * *'
 
 permissions:
   contents: read
+  pull-requests: read
+
+env:
+  BUILD_DIR : "${{github.workspace}}/build"
+  INSTALL_DIR: "${{github.workspace}}/build/install"
 
 jobs:
-  fuzz-test:
-      name: Fuzz test
-      strategy:
-        fail-fast: false
-        matrix:
-          build_type: [Debug, Release]
-          compiler: [{c: clang, cxx: clang++}]
-      
-      runs-on: ubuntu-latest
-
-      steps:
-      - name: Checkout repository
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-        with:
-          fetch-depth: 0
-
-      - name: Install apt packages
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y cmake hwloc libhwloc-dev libnuma-dev libtbb-dev
-
-      - name: Configure CMake
-        run: >
-          cmake
-          -B ${{github.workspace}}/build
-          -DCMAKE_BUILD_TYPE=${{matrix.build_type}}
-          -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
-          -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
-          -DUMF_TESTS_FAIL_ON_SKIP=ON
-          -DUMF_DEVELOPER_MODE=ON
-          -DUMF_BUILD_FUZZTESTS=ON
+  Fuzzing:
+    strategy:
+      fail-fast: false
+      matrix:
+        build_type: [Debug, Release]
+        compiler: [{c: clang, cxx: clang++}]
+    name: Fuzzing (ubuntu-latest, build_type=${{matrix.build_type}}, compilers=${{matrix.compiler.c}}/${{matrix.compiler.cxx}})
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        fetch-depth: 0
+
+    - name: Install apt packages
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y cmake hwloc libhwloc-dev libnuma-dev libtbb-dev
+
+    - name: Find Clang fuzzer lib
+      run: |
+        CLANG_LIBS_DIR=$(find /usr/lib -name "libclang_rt.fuzzer_no_main-x86_64.a" -exec dirname {} \; | head -n 1)
+        echo "CLANG_LIBS_DIR=${CLANG_LIBS_DIR}" >> $GITHUB_ENV
+
+    - name: Configure CMake
+      run: >
+        cmake
+        -B ${{github.workspace}}/build
+        -DCMAKE_PREFIX_PATH=${{env.CLANG_LIBS_DIR}}
+        -DCMAKE_BUILD_TYPE=${{matrix.build_type}}
+        -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
+        -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_FUZZTESTS=ON
+
+    - name: Build
+      run: cmake --build ${{github.workspace}}/build --config ${{matrix.build_type}} --verbose -j$(nproc)
 
-      - name: Build
-        run: cmake --build ${{github.workspace}}/build --config ${{matrix.build_type}} --verbose -j$(nproc)
+    - name: Run regular tests
+      working-directory: ${{github.workspace}}/build
+      run: ctest -C ${{matrix.build_type}} --output-on-failure -E "fuzz"
 
-      - name: Fuzz long test
-        working-directory: ${{github.workspace}}/build
-        run: ctest -C ${{matrix.build_type}} --output-on-failure --verbose -L "fuzz-long"
+    - name: Run regular tests with proxy library
+      working-directory: ${{env.BUILD_DIR}}
+      run: LD_PRELOAD=./lib/libumf_proxy.so ctest -C ${{matrix.build_type}} --output-on-failure -E "fuzz"
 
-  valgrind:
-    name: Valgrind
+    - name: Fuzz long test
+      working-directory: ${{github.workspace}}/build
+      run: ctest -C ${{matrix.build_type}} --output-on-failure --verbose -L "fuzz-long"
+
+  Valgrind:
     strategy:
       fail-fast: false
       matrix:
           tool: ['memcheck', 'drd', 'helgrind']
+    name: Valgrind (${{matrix.tool}})
     runs-on: ubuntu-latest
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
 
     - name: Install apt packages
       run: |
         sudo apt-get update
-        sudo apt-get install -y cmake hwloc libhwloc-dev libjemalloc-dev libnuma-dev libtbb-dev valgrind
+        sudo apt-get install -y cmake hwloc libhwloc-dev libnuma-dev libtbb-dev valgrind
 
     - name: Configure CMake
       run: >
@@ -75,8 +94,7 @@ jobs:
         -B ${{github.workspace}}/build
         -DCMAKE_BUILD_TYPE=Debug
         -DUMF_FORMAT_CODE_STYLE=OFF
-        -DUMF_DEVELOPER_MODE=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
+        -DUMF_DEVELOPER_MODE=OFF
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
         -DUMF_BUILD_CUDA_PROVIDER=OFF
@@ -89,102 +107,370 @@ jobs:
     - name: Run tests under valgrind
       run: ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{github.workspace}}/build ${{matrix.tool}}
 
-  # TODO fix #843
-  #icx:
-  #  name: ICX
-  #  env:
-  #    VCPKG_PATH: "${{github.workspace}}/build/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows"
-  #    BUILD_DIR : "${{github.workspace}}/build"
-  #  strategy:
-  #    matrix:
-  #      os: ['windows-2019', 'windows-2022']
-  #      build_type: [Debug]
-  #      compiler: [{c: icx, cxx: icx}]
-  #      shared_library: ['ON', 'OFF']
-  #      include:
-  #        - os: windows-2022
-  #          build_type: Release
-  #          compiler: {c: icx, cxx: icx}
-  #          shared_library: 'ON'
-  #
-  #  runs-on: ${{matrix.os}}
-  #
-  #  steps:
-  #  - name: Checkout
-  #    uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-  #    with:
-  #      fetch-depth: 0
-  #
-  #  - name: Initialize vcpkg
-  #    uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
-  #    with:
-  #      vcpkgGitCommitId: 3dd44b931481d7a8e9ba412621fa810232b66289
-  #      vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
-  #      vcpkgJsonGlob: '**/vcpkg.json'
-  #
-  #  - name: Install dependencies
-  #    run: vcpkg install
-  #
-  #  - name: Install Ninja
-  #    uses: seanmiddleditch/gha-setup-ninja@96bed6edff20d1dd61ecff9b75cc519d516e6401 # v5
-  #
-  #  - name: Download icx compiler
-  #    env:
-  #      # Link source: https://www.intel.com/content/www/us/en/developer/tools/oneapi/dpc-compiler-download.html
-  #      CMPLR_LINK: "https://registrationcenter-download.intel.com/akdlm/IRC_NAS/15a35578-2f9a-4f39-804b-3906e0a5f8fc/w_dpcpp-cpp-compiler_p_2024.2.1.83_offline.exe"
-  #    run: |
-  #      Invoke-WebRequest -Uri "${{ env.CMPLR_LINK }}" -OutFile compiler_install.exe
-  #
-  #  - name: Install icx compiler
-  #    shell: cmd
-  #    run: |
-  #      start /b /wait .\compiler_install.exe -s -x -f extracted --log extract.log
-  #      extracted\bootstrapper.exe -s --action install --eula=accept -p=NEED_VS2017_INTEGRATION=0 ^
-  #        -p=NEED_VS2019_INTEGRATION=0 -p=NEED_VS2022_INTEGRATION=0 --log-dir=.
-  #
-  #  - name: Configure build
-  #    shell: cmd
-  #    run: |
-  #      call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-  #      call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
-  #      cmake ^
-  #        -B ${{env.BUILD_DIR}} ^
-  #        -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}" ^
-  #        -DCMAKE_C_COMPILER=${{matrix.compiler.c}} ^
-  #        -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}} ^
-  #        -G Ninja ^
-  #        -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}} ^
-  #        -DUMF_FORMAT_CODE_STYLE=OFF ^
-  #        -DUMF_DEVELOPER_MODE=ON ^
-  #        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON ^
-  #        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON ^
-  #        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON ^
-  #        -DUMF_BUILD_CUDA_PROVIDER=ON ^
-  #        -DUMF_TESTS_FAIL_ON_SKIP=ON
-  #
-  #  - name: Build UMF
-  #    shell: cmd
-  #    run: |
-  #      call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-  #      call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
-  #      cmake --build ${{env.BUILD_DIR}} --config ${{matrix.build_type}} -j %NUMBER_OF_PROCESSORS%
-  #
-  #  - name: Run tests
-  #    shell: cmd
-  #    working-directory: ${{env.BUILD_DIR}}
-  #    run: |
-  #      call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-  #      call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
-  #      ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
+  # Build and test UMF with different CMake generators on Windows
+  Windows-generators:
+    env:
+      VCPKG_PATH: "${{github.workspace}}/build/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows"
+      VCPKG_PATH_NO_HWLOC: "${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows"
+    strategy:
+      matrix:
+        build_type: [Debug, Release]
+        compiler: [{c: cl, cxx: cl}]
+        shared_library: ['ON', 'OFF']
+        static_hwloc: ['ON', 'OFF']
+        generator: ['Ninja', 'NMake Makefiles']
+        umfd_lib: ['ON', 'OFF']
+    name: Windows (generator=${{matrix.generator}}, compilers=${{matrix.compiler.c}}/${{matrix.compiler.cxx}}, build_type=${{matrix.build_type}}, shared_library=${{matrix.shared_library}}, static_hwloc=${{matrix.static_hwloc}}, umfd_lib=${{matrix.umfd_lib}})
+
+    runs-on: windows-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        fetch-depth: 0
+
+    - name: Restore vcpkg cache
+      uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+      id: cache
+      with:
+        path: vcpkg_pkgs_cache.zip
+        key: vcpkg-generators-windows-latest-${{ hashFiles('vcpkg.json') }}
+
+    - name: Unpack vcpkg cache
+      if: steps.cache.outputs.cache-hit == 'true'
+      run: |
+        Expand-Archive -Path ${{github.workspace}}/vcpkg_pkgs_cache.zip -DestinationPath ${{env.BUILD_DIR}}/vcpkg -Force
+
+    - name: Initialize vcpkg
+      if: steps.cache.outputs.cache-hit != 'true'
+      uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
+      with:
+        vcpkgGitCommitId: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
+        vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
+        vcpkgJsonGlob: '**/vcpkg.json'
+
+    - name: Install dependencies
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: vcpkg install --triplet x64-windows
+
+    - name: Set VCPKG_PATH without hwloc
+      if: matrix.static_hwloc == 'ON'
+      run: echo "VCPKG_PATH=${{env.VCPKG_PATH_NO_HWLOC}}" >> $env:GITHUB_ENV
+
+    - name: Install Ninja
+      if: matrix.generator == 'Ninja'
+      uses: seanmiddleditch/gha-setup-ninja@3b1f8f94a2f8254bd26914c4ab9474d4f0015f67 # v6
+
+    - name: Configure MSVC environment
+      uses: ilammy/msvc-dev-cmd@0b201ec74fa43914dc39ae48a89fd1d8cb592756 # v1.13.0
+
+    - name: Configure build
+      run: >
+        cmake
+        -B ${{env.BUILD_DIR}}
+        -DCMAKE_BUILD_TYPE=${{matrix.build_type}}
+        -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
+        -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
+        -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
+        -G "${{matrix.generator}}"
+        -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}}
+        -DUMF_LINK_HWLOC_STATICALLY=${{matrix.static_hwloc}}
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+        ${{ matrix.umfd_lib == 'ON' && '-DUMF_USE_DEBUG_POSTFIX=ON' || '' }}
+
+    - name: Build UMF
+      shell: cmd
+      run: cmake --build ${{env.BUILD_DIR}} --config ${{matrix.build_type}} -j %NUMBER_OF_PROCESSORS%
+
+    - name: Run tests
+      shell: cmd
+      working-directory: ${{env.BUILD_DIR}}
+      run: ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
+
+    - name: Get UMF version
+      run: |
+        $version = (git describe --tags --abbrev=0 | Select-String -Pattern '\d+\.\d+\.\d+').Matches.Value
+        echo "UMF_VERSION=$version" >> $env:GITHUB_ENV
+      shell: pwsh
+
+    - name: Test UMF installation and uninstallation
+      # The '--shared-library' parameter is added to the installation test when the UMF is built as a shared library
+      # The '--umfd-lib' parameter is added when the UMF is built with the umfd library
+      run: >
+        python3 ${{github.workspace}}/test/test_installation.py
+        --build-dir ${{env.BUILD_DIR}}
+        --install-dir ${{env.INSTALL_DIR}}
+        --build-type ${{matrix.build_type}}
+        --umf-version ${{env.UMF_VERSION}}
+        ${{ matrix.shared_library == 'ON' && '--proxy --shared-library' || '' }}
+        ${{ matrix.umfd_lib == 'ON' && '--umfd-lib' || ''}}
+        ${{ matrix.static_hwloc == 'ON' && '--hwloc' || '' }}
+
+    - name: Configure the fetch_content example
+      if: matrix.static_hwloc == 'OFF'
+      working-directory: ${{github.workspace}}/examples/fetch_content
+      # Fetch_Content the UMF code from the current repository (-DUMF_REPO="${{github.workspace}}")
+      run: >
+        cmake
+        -B build
+        -DCMAKE_BUILD_TYPE=${{matrix.build_type}}
+        -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
+        -DUMF_REPO="${{github.workspace}}"
+        -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
+        -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
+        -G "${{matrix.generator}}"
+
+    - name: Build the fetch_content example
+      if: matrix.static_hwloc == 'OFF'
+      working-directory: ${{github.workspace}}/examples/fetch_content
+      run: cmake --build build --config ${{matrix.build_type}} -j $env:NUMBER_OF_PROCESSORS
+
+    - name: Run the fetch_content example
+      if: matrix.static_hwloc == 'OFF'
+      working-directory: ${{github.workspace}}/examples/fetch_content/build
+      run: ctest -V
+
+    - name: Prepare vcpkg cache
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: |
+        Compress-Archive -Path ${{env.BUILD_DIR}}/vcpkg/packages -DestinationPath ${{github.workspace}}/vcpkg_pkgs_cache.zip -Force -CompressionLevel Fastest
+
+    - name: Save vcpkg cache
+      if: steps.cache.outputs.cache-hit != 'true'
+      uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+      with:
+        path: ${{github.workspace}}/vcpkg_pkgs_cache.zip
+        key: ${{ steps.cache.outputs.cache-primary-key }}
+
+  # Build and test UMF with Intel C++ Compiler (ICX) on Windows
+  Windows-icx:
+   env:
+     VCPKG_PATH: "${{github.workspace}}/build/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows"
+   strategy:
+     matrix:
+       os: ['windows-2022', 'windows-2025']
+       build_type: [Debug]
+       compiler: [{c: icx, cxx: icx}]
+       shared_library: ['ON', 'OFF']
+       include:
+         - os: windows-2022
+           build_type: Release
+           compiler: {c: icx, cxx: icx}
+           shared_library: 'ON'
+   name: ICX (${{matrix.os}}, build_type=${{matrix.build_type}}, compilers=${{matrix.compiler.c}}/${{matrix.compiler.cxx}}, shared_library=${{matrix.shared_library}})
+   runs-on: ${{matrix.os}}
+
+   steps:
+    - name: Checkout
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        fetch-depth: 0
+
+    - name: Restore vcpkg cache
+      uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+      id: cache
+      with:
+        path: vcpkg_pkgs_cache.zip
+        key: vcpkg-icx-${{matrix.os}}-${{ hashFiles('vcpkg.json') }}
+
+    - name: Unpack vcpkg cache
+      if: steps.cache.outputs.cache-hit == 'true'
+      run: |
+        Expand-Archive -Path ${{github.workspace}}/vcpkg_pkgs_cache.zip -DestinationPath ${{env.BUILD_DIR}}/vcpkg -Force
+
+    - name: Initialize vcpkg
+      if: steps.cache.outputs.cache-hit != 'true'
+      uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
+      with:
+        vcpkgGitCommitId: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
+        vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
+        vcpkgJsonGlob: '**/vcpkg.json'
+
+    - name: Install dependencies
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: vcpkg install --triplet x64-windows
+
+    - name: Install Ninja
+      uses: seanmiddleditch/gha-setup-ninja@3b1f8f94a2f8254bd26914c4ab9474d4f0015f67 # v6
+
+    - name: Download icx compiler
+      env:
+        # Link source: https://www.intel.com/content/www/us/en/developer/tools/oneapi/dpc-compiler-download.html
+        CMPLR_LINK: "https://registrationcenter-download.intel.com/akdlm/IRC_NAS/15a35578-2f9a-4f39-804b-3906e0a5f8fc/w_dpcpp-cpp-compiler_p_2024.2.1.83_offline.exe"
+      run: |
+        Invoke-WebRequest -Uri "${{ env.CMPLR_LINK }}" -OutFile compiler_install.exe
+
+    - name: Install icx compiler
+      shell: cmd
+      run: |
+        start /b /wait .\compiler_install.exe -s -x -f extracted --log extract.log
+        extracted\bootstrapper.exe -s --action install --eula=accept -p=NEED_VS2017_INTEGRATION=0 ^
+          -p=NEED_VS2019_INTEGRATION=0 -p=NEED_VS2022_INTEGRATION=0 --log-dir=.
+
+    - name: Configure build
+      shell: cmd
+      run: |
+        call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+        call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
+        cmake ^
+          -B ${{env.BUILD_DIR}} ^
+          -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}" ^
+          -DCMAKE_C_COMPILER=${{matrix.compiler.c}} ^
+          -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}} ^
+          -G Ninja ^
+          -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}} ^
+          -DUMF_FORMAT_CODE_STYLE=OFF ^
+          -DUMF_DEVELOPER_MODE=ON ^
+          -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON ^
+          -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON ^
+          -DUMF_BUILD_CUDA_PROVIDER=ON ^
+          -DUMF_TESTS_FAIL_ON_SKIP=ON
+
+    - name: Build UMF
+      shell: cmd
+      run: |
+        call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+        call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
+        cmake --build ${{env.BUILD_DIR}} --config ${{matrix.build_type}} -j %NUMBER_OF_PROCESSORS%
+
+    - name: Run tests
+      shell: cmd
+      working-directory: ${{env.BUILD_DIR}}
+      run: |
+        call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+        call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
+        ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
+
+    - name: Prepare vcpkg cache
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: |
+        Compress-Archive -Path ${{env.BUILD_DIR}}/vcpkg/packages -DestinationPath ${{github.workspace}}/vcpkg_pkgs_cache.zip -Force -CompressionLevel Fastest
+
+    - name: Save vcpkg cache
+      if: steps.cache.outputs.cache-hit != 'true'
+      uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+      with:
+        path: ${{github.workspace}}/vcpkg_pkgs_cache.zip
+        key: ${{ steps.cache.outputs.cache-primary-key }}
+
+  # Scenarios where UMF_LINK_HWLOC_STATICALLY is set to OFF and hwloc is not installed in the system
+  # The hwloc library is fetched implicitly
+  Hwloc-fallback:
+    strategy:
+      matrix:
+        include:
+          - os: 'ubuntu-latest'
+            build_type: Release
+            number_of_processors: '$(nproc)'
+          - os: 'windows-latest'
+            build_type: Release
+            number_of_processors: '$Env:NUMBER_OF_PROCESSORS'
+    name: "Fallback to static hwloc build (${{matrix.os}}), build_type=${{matrix.build_type}})"
+    runs-on: ${{matrix.os}}
+
+    steps:
+    - name: Install dependencies
+      if: matrix.os == 'ubuntu-latest'
+      run: sudo apt-get install -y libnuma-dev
+
+    - name: Checkout
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        fetch-depth: 0
+
+    - name: Configure build
+      run: >
+        cmake
+        -B ${{env.BUILD_DIR}}
+        -DCMAKE_BUILD_TYPE=${{matrix.build_type}}
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DUMF_BUILD_EXAMPLES=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_LINK_HWLOC_STATICALLY=OFF
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+
+    - name: Build UMF
+      run: >
+        cmake
+        --build ${{env.BUILD_DIR}}
+        --config ${{matrix.build_type}}
+        -j ${{matrix.number_of_processors}}
+
+    - name: Run tests
+      working-directory: ${{env.BUILD_DIR}}
+      run: ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
+
+  Windows-dynamic_mingw_hwloc:
+    env:
+      HWLOC_PACKAGE_NAME: hwloc-win64-build-2.10.0
+      TBB_PACKAGE_NAME: oneapi-tbb-2021.12.0
+      TBB_LIB_DIR: lib\intel64\vc14
+      TBB_BIN_DIR: redist\intel64\vc14
+
+    name: "Windows dynamic UMF + mingw libhwloc"
+    strategy:
+      matrix:
+        build_type: [Release]
+
+    runs-on: 'windows-latest'
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        fetch-depth: 0
+
+    - name: Get hwloc from official repo (mingw version)
+      run: |
+        Invoke-WebRequest -Uri https://download.open-mpi.org/release/hwloc/v2.10/${{env.HWLOC_PACKAGE_NAME}}.zip -OutFile ${{github.workspace}}\${{env.HWLOC_PACKAGE_NAME}}.zip -TimeoutSec 360
+        Expand-Archive ${{github.workspace}}\${{env.HWLOC_PACKAGE_NAME}}.zip -DestinationPath ${{github.workspace}}
+
+    - name: Get TBB from github
+      run: |
+        Invoke-WebRequest -Uri https://github.com/oneapi-src/oneTBB/releases/download/v2021.12.0/${{env.TBB_PACKAGE_NAME}}-win.zip -OutFile "${{github.workspace}}\${{env.TBB_PACKAGE_NAME}}-win.zip" -TimeoutSec 360
+        Expand-Archive "${{github.workspace}}\${{env.TBB_PACKAGE_NAME}}-win.zip" -DestinationPath ${{github.workspace}}
+
+    - name: Configure build
+      run: >
+        cmake
+        -B ${{env.BUILD_DIR}}
+        -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
+        -DCMAKE_PREFIX_PATH="${{github.workspace}}\${{env.HWLOC_PACKAGE_NAME}};${{github.workspace}}\${{env.TBB_PACKAGE_NAME}};${{github.workspace}}\${{env.TBB_PACKAGE_NAME}}\${{env.TBB_LIB_DIR}};${{github.workspace}}\${{env.TBB_PACKAGE_NAME}}\${{env.TBB_BIN_DIR}}"
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DUMF_BUILD_EXAMPLES=ON
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+        -DUMF_HWLOC_NAME=libhwloc
+
+    - name: Build UMF
+      run: cmake --build ${{env.BUILD_DIR}} --config ${{matrix.build_type}} -j $Env:NUMBER_OF_PROCESSORS
+
+    - name: Run tests
+      working-directory: ${{env.BUILD_DIR}}
+      run: ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
 
   L0:
     uses: ./.github/workflows/reusable_gpu.yml
     with:
-      name: "LEVEL_ZERO"
+      provider: "LEVEL_ZERO"
+      runner: "L0"
+  L0-BMG:
+    uses: ./.github/workflows/reusable_gpu.yml
+    with:
+      provider: "LEVEL_ZERO"
+      runner: "L0-BMG"
   CUDA:
     uses: ./.github/workflows/reusable_gpu.yml
     with:
-      name: "CUDA"
+      provider: "CUDA"
+      runner: "CUDA"
 
   # Full execution of QEMU tests
   QEMU:
@@ -193,4 +479,67 @@ jobs:
       short_run: false
       # Beside the 2 LTS Ubuntu, we also test this on the latest Ubuntu -  to be updated
       # every 6 months, so we verify the latest version of packages (compilers, etc.).
-      os: "['ubuntu-22.04', 'ubuntu-24.04', 'ubuntu-24.10']"
+      os: "['ubuntu-22.04', 'ubuntu-24.04', 'ubuntu-25.04']"
+
+  Benchmarks:
+    uses: ./.github/workflows/reusable_benchmarks.yml
+    permissions:
+      contents: write
+      pull-requests: write
+    with:
+      pr_no: '0'
+      bench_script_params: >
+        --save Baseline_PVC
+        --filter umf-benchmark
+
+  # Run benchmarks with the latest SYCL (with the latest UMF copied into the SYCL)
+  # to verify the compatibility.
+  #
+  # TODO: re-enable this job, when nightly sycl builds are again available;
+  #   the last one available (as of 24.07.2025) is not working properly with
+  #   compute benchmarks. Now, we could only build sycl from sources, or find a
+  #   matching version of compute benchmarks with last nightly package.
+  Benchmarks-sycl:
+    if: false
+    uses: ./.github/workflows/reusable_benchmarks.yml
+    permissions:
+      contents: write
+      pull-requests: write
+    with:
+      pr_no: '0'
+      bench_script_params: >-
+        --adapter level_zero_v2
+        --compute-runtime
+        --build-igc
+        --preset Minimal
+        --exit-on-failure
+      runner: 'L0_PERF_ARC'
+      compatibility: '1'
+
+  SYCL:
+    uses: ./.github/workflows/reusable_sycl.yml
+
+  alpine:
+    name: Alpine
+    env:
+      HOST_WORKDIR: ${{github.workspace}}
+      WORKDIR: /unified-memory-framework
+    strategy:
+      matrix:
+          build_type: [Debug, Release]
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        fetch-depth: 0
+
+    - name: Build Alpine image
+      run: |
+        docker build . -f .github/docker/alpine-3.21.Dockerfile -t umf-alpine-3.21
+
+    - name: Run UMF build on Alpine image
+      run: |
+        docker run --rm -i -v $HOST_WORKDIR:$WORKDIR \
+        umf-alpine-3.21 $WORKDIR/.github/scripts/alpine_build.sh ${{matrix.build_type}} $WORKDIR
diff --git a/.github/workflows/performance.yml b/.github/workflows/performance.yml
deleted file mode 100644
index 6057df5f0a..0000000000
--- a/.github/workflows/performance.yml
+++ /dev/null
@@ -1,115 +0,0 @@
-name: Performance
-
-on:
-  # Can be triggered via manual "dispatch" (from workflow view in GitHub Actions tab)
-  workflow_dispatch:
-    inputs:
-      pr_no:
-        description: PR number (if 0, it'll run on the main)
-        type: number
-        required: true
-
-permissions:
-  contents: read
-  pull-requests: write
-
-env:
-  BUILD_DIR : "${{github.workspace}}/build"
-
-jobs:
-  perf-l0:
-    name: Build UMF and run performance tests
-    runs-on: "L0_PERF"
-
-    steps:
-    # Workspace on self-hosted runners is not cleaned automatically.
-    # We have to delete the files created outside of using actions.
-    - name: Cleanup self-hosted workspace
-      if: always()
-      run: |
-        ls -la ./
-        rm -rf ./* || true
-
-    - name: Add comment to PR
-      uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
-      if: ${{ always() && inputs.pr_no != 0 }}
-      with:
-        script: |
-          const pr_no = '${{ inputs.pr_no }}';
-          const provider = 'LEVEL_ZERO';
-          const url = '${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}';
-          const body = `Performance workflow for ${provider}_PROVIDER run:\n${url}`;
-
-          github.rest.issues.createComment({
-            issue_number: pr_no,
-            owner: context.repo.owner,
-            repo: context.repo.repo,
-            body: body
-          })
-
-    - name: Checkout UMF
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-
-    - name: Get information about platform
-      run: .github/scripts/get_system_info.sh
-
-    # We need to fetch special ref for proper PR's merge commit. Note, this ref may be absent if the PR is already merged.
-    - name: Fetch PR's merge commit
-      if: ${{ inputs.pr_no != 0 }}
-      working-directory: ${{github.workspace}}
-      env:
-        PR_NO: ${{ inputs.pr_no }}
-      run: |
-        git fetch -- https://github.com/${{github.repository}} +refs/pull/${PR_NO}/*:refs/remotes/origin/pr/${PR_NO}/*
-        git checkout origin/pr/${PR_NO}/merge
-        git rev-parse origin/pr/${PR_NO}/merge
-
-    - name: Configure build
-      run: >
-        cmake
-        -B ${{env.BUILD_DIR}}
-        -DCMAKE_BUILD_TYPE=Release
-        -DUMF_BUILD_SHARED_LIBRARY=ON
-        -DUMF_BUILD_BENCHMARKS=ON
-        -DUMF_BUILD_BENCHMARKS_MT=ON
-        -DUMF_BUILD_TESTS=OFF
-        -DUMF_FORMAT_CODE_STYLE=OFF
-        -DUMF_DEVELOPER_MODE=OFF
-        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
-        -DUMF_BUILD_CUDA_PROVIDER=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
-        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
-
-    - name: Build
-      run: cmake --build ${{env.BUILD_DIR}} -j $(nproc)
-
-    - name: Run benchmarks
-      working-directory: ${{env.BUILD_DIR}}
-      id: benchmarks
-      run: numactl -N 1 ctest -V --test-dir benchmark -C Release
-
-    - name: Add comment to PR
-      uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
-      if: ${{ always() && inputs.pr_no != 0 }}
-      with:
-        script: |
-          let markdown = ""
-          try {
-            const fs = require('fs');
-            markdown = fs.readFileSync('umf_perf_results.md', 'utf8');
-          } catch(err) {
-          }
-
-          const pr_no = '${{ inputs.pr_no }}';
-          const provider = 'LEVEL_ZERO';
-          const url = '${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}';
-          const test_status = '${{ steps.benchmarks.outcome }}';
-          const job_status = '${{ job.status }}';
-          const body = `Performance workflow for ${provider}_PROVIDER run:\n${url}\nJob status: ${job_status}. Test status: ${test_status}.\n ${markdown}`;
-
-          github.rest.issues.createComment({
-            issue_number: pr_no,
-            owner: context.repo.owner,
-            repo: context.repo.repo,
-            body: body
-          })
diff --git a/.github/workflows/pr_push.yml b/.github/workflows/pr_push.yml
index 9623b69f1b..fffdc7373e 100644
--- a/.github/workflows/pr_push.yml
+++ b/.github/workflows/pr_push.yml
@@ -14,15 +14,14 @@ concurrency:
 
 permissions:
   contents: read
+  packages: read
 
 jobs:
   CodeChecks:
     uses: ./.github/workflows/reusable_checks.yml
-  DocsBuild:
-    uses: ./.github/workflows/reusable_docs_build.yml
   FastBuild:
     name: Fast builds
-    needs: [CodeChecks, DocsBuild]
+    needs: [CodeChecks]
     uses: ./.github/workflows/reusable_fast.yml
   Build:
     name: Basic builds
@@ -38,13 +37,22 @@ jobs:
     needs: [Build]
     uses: ./.github/workflows/reusable_gpu.yml
     with:
-      name: "LEVEL_ZERO"
+      provider: "LEVEL_ZERO"
+      runner: "L0"
+      shared_lib: "['ON']"
+  L0-BMG:
+    needs: [Build]
+    uses: ./.github/workflows/reusable_gpu.yml
+    with:
+      provider: "LEVEL_ZERO"
+      runner: "L0-BMG"
       shared_lib: "['ON']"
   CUDA:
     needs: [Build]
     uses: ./.github/workflows/reusable_gpu.yml
     with:
-      name: "CUDA"
+      provider: "CUDA"
+      runner: "CUDA"
       shared_lib: "['ON']"
   Sanitizers:
     needs: [FastBuild]
@@ -54,9 +62,6 @@ jobs:
     uses: ./.github/workflows/reusable_qemu.yml
     with:
       short_run: true
-  Benchmarks:
-    needs: [Build]
-    uses: ./.github/workflows/reusable_benchmarks.yml
   ProxyLib:
     needs: [Build]
     uses: ./.github/workflows/reusable_proxy_lib.yml
@@ -88,3 +93,11 @@ jobs:
       contents: read
       security-events: write
     uses: ./.github/workflows/reusable_trivy.yml
+  Compatibility:
+    needs: [Build]
+    uses: ./.github/workflows/reusable_compatibility.yml
+    strategy:
+      matrix:
+        tag: ["v1.0.1"]
+    with:
+      tag: ${{matrix.tag}}
diff --git a/.github/workflows/reusable_basic.yml b/.github/workflows/reusable_basic.yml
index ced48e0c72..7299cedabd 100644
--- a/.github/workflows/reusable_basic.yml
+++ b/.github/workflows/reusable_basic.yml
@@ -5,150 +5,144 @@ on: workflow_call
 
 permissions:
   contents: read
+  packages: read
 
 env:
-  # for installation testing - it should match with version set in CMake
-  UMF_VERSION: 0.10.1
   BUILD_DIR : "${{github.workspace}}/build"
-  INSTL_DIR : "${{github.workspace}}/../install-dir"
+  INSTL_DIR : "${{github.workspace}}/install-dir"
   COVERAGE_DIR : "${{github.workspace}}/coverage"
   COVERAGE_NAME : "exports-coverage-basic"
 
 jobs:
   ubuntu-build:
-    name: Ubuntu
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/bb-ur/umf-${{ matrix.os }}:latest
+      options: --user test_user --cap-add=SYS_NICE --cap-add=SYS_PTRACE
+      volumes:
+        - ${{ github.workspace }}:${{ github.workspace }}
     strategy:
       matrix:
-        os: ['ubuntu-20.04', 'ubuntu-22.04']
+        os: ['ubuntu-22.04', 'ubuntu-24.04']
         build_type: [Debug, Release]
         compiler: [{c: gcc, cxx: g++}]
         shared_library: ['OFF']
         level_zero_provider: ['ON']
         cuda_provider: ['ON']
         install_tbb: ['ON']
-        disable_hwloc: ['OFF']
         link_hwloc_statically: ['OFF']
+        cmake_ver: ['default']
         include:
-          - os: 'ubuntu-20.04'
-            build_type: Release
-            compiler: {c: gcc-7, cxx: g++-7}
-            shared_library: 'OFF'
-            level_zero_provider: 'ON'
-            cuda_provider: 'ON'
-            install_tbb: 'ON'
-            disable_hwloc: 'OFF'
-            link_hwloc_statically: 'OFF'
-          - os: 'ubuntu-22.04'
+          - os: ubuntu-22.04
             build_type: Release
             compiler: {c: clang, cxx: clang++}
             shared_library: 'OFF'
             level_zero_provider: 'ON'
             cuda_provider: 'ON'
             install_tbb: 'ON'
-            disable_hwloc: 'OFF'
             link_hwloc_statically: 'OFF'
-          - os: 'ubuntu-22.04'
+            # check minimum supported cmake version
+            cmake_ver: '3.14.0'
+          - os: ubuntu-22.04
             build_type: Release
             compiler: {c: gcc, cxx: g++}
             shared_library: 'ON'
             level_zero_provider: 'ON'
             cuda_provider: 'ON'
             install_tbb: 'ON'
-            disable_hwloc: 'OFF'
             link_hwloc_statically: 'OFF'
-          - os: 'ubuntu-24.04'
+            cmake_ver: '3.28.0'
+          - os: ubuntu-24.04
             build_type: Debug
             compiler: {c: gcc, cxx: g++}
             shared_library: 'ON'
             level_zero_provider: 'ON'
             cuda_provider: 'ON'
             install_tbb: 'ON'
-            disable_hwloc: 'OFF'
             link_hwloc_statically: 'OFF'
+            cmake_ver: 'default'
           # test level_zero_provider='OFF' and cuda_provider='OFF'
-          - os: 'ubuntu-22.04'
+          - os: ubuntu-22.04
             build_type: Release
             compiler: {c: gcc, cxx: g++}
             shared_library: 'OFF'
             level_zero_provider: 'OFF'
             cuda_provider: 'OFF'
             install_tbb: 'ON'
-            disable_hwloc: 'OFF'
             link_hwloc_statically: 'OFF'
+            cmake_ver: 'default'
           # test icx compiler
-          # - os: 'ubuntu-22.04'
-            # build_type: Release
-            # compiler: {c: icx, cxx: icpx}
-            # shared_library: 'ON'
-            # level_zero_provider: 'ON'
-            # cuda_provider: 'ON'
-            # install_tbb: 'ON'
-            # disable_hwloc: 'OFF'
-            # link_hwloc_statically: 'OFF'
-          # test without installing TBB
-          - os: 'ubuntu-22.04'
+          - os: ubuntu-22.04
             build_type: Release
-            compiler: {c: gcc, cxx: g++}
+            compiler: {c: icx, cxx: icpx}
             shared_library: 'ON'
             level_zero_provider: 'ON'
             cuda_provider: 'ON'
-            install_tbb: 'OFF'
-            disable_hwloc: 'OFF'
+            install_tbb: 'ON'
             link_hwloc_statically: 'OFF'
-          - os: 'ubuntu-22.04'
-            build_type: Debug
-            compiler: {c: gcc, cxx: g++}
+            cmake_ver: 'default'
+          # test lld linker
+          - os: ubuntu-24.04
+            build_type: Release
+            compiler: {c: icx, cxx: icpx}
             shared_library: 'ON'
             level_zero_provider: 'ON'
             cuda_provider: 'ON'
             install_tbb: 'ON'
-            disable_hwloc: 'ON'
             link_hwloc_statically: 'OFF'
-          - os: 'ubuntu-22.04'
+            llvm_linker: '-DCMAKE_EXE_LINKER_FLAGS="-fuse-ld=lld" -DCMAKE_MODULE_LINKER_FLAGS="-fuse-ld=lld" -DCMAKE_SHARED_LINKER_FLAGS="-fuse-ld=lld"'
+            cmake_ver: 'default'
+          # test without installing TBB
+          - os: ubuntu-22.04
+            build_type: Release
+            compiler: {c: gcc, cxx: g++}
+            shared_library: 'ON'
+            level_zero_provider: 'ON'
+            cuda_provider: 'ON'
+            install_tbb: 'OFF'
+            link_hwloc_statically: 'OFF'
+            cmake_ver: 'default'
+          - os: ubuntu-22.04
             build_type: Release
             compiler: {c: gcc, cxx: g++}
             shared_library: 'ON'
             level_zero_provider: 'ON'
             cuda_provider: 'ON'
             install_tbb: 'ON'
-            disable_hwloc: 'OFF'
             link_hwloc_statically: 'ON'
-    runs-on: ${{matrix.os}}
+            cmake_ver: 'default'
+    name: Basic (${{matrix.os}}, build_type=${{matrix.build_type}}, compilers=${{matrix.compiler.c}}/${{matrix.compiler.cxx}}, shared_library=${{matrix.shared_library}}, level_zero_provider=${{matrix.level_zero_provider}}, cuda_provider=${{matrix.cuda_provider}}, install_tbb=${{matrix.install_tbb}}, link_hwloc_statically=${{matrix.link_hwloc_statically}}, cmake_ver=${{matrix.cmake_ver}})
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
 
-    - name: Install apt packages
+    - name: Install cmake (non-default version)
+      if: matrix.cmake_ver != 'default'
       run: |
-        sudo apt-get update
-        sudo apt-get install -y clang cmake libnuma-dev libjemalloc-dev lcov
+        echo ${USERPASS} | sudo -Sk apt-get remove --purge -y cmake
+        wget https://github.com/Kitware/CMake/releases/download/v${{matrix.cmake_ver}}/cmake-${{matrix.cmake_ver}}-Linux-x86_64.sh
+        chmod +x cmake-${{matrix.cmake_ver}}-Linux-x86_64.sh
+        echo ${USERPASS} | sudo -Sk ./cmake-${{matrix.cmake_ver}}-Linux-x86_64.sh --skip-license --prefix=/usr/local
 
-    - name: Install TBB apt package
-      if: matrix.install_tbb == 'ON'
+    - name: Uninstall TBB apt package
+      if: matrix.install_tbb == 'OFF'
       run: |
-        sudo apt-get install -y libtbb-dev
+        echo ${USERPASS} | sudo -Sk apt-get remove --purge -y '*tbb*'
+        echo ${USERPASS} | sudo -Sk apt-get autoremove -y
 
     - name: Install oneAPI basekit
       if: matrix.compiler.cxx == 'icpx'
       run: |
-        sudo apt-get install -y gpg-agent wget
-        wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB | gpg --dearmor | sudo tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null
-        echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" | sudo tee /etc/apt/sources.list.d/oneAPI.list
-        sudo apt-get update
-        sudo apt-get install -y intel-oneapi-ippcp-devel intel-oneapi-ipp-devel intel-oneapi-common-oneapi-vars intel-oneapi-compiler-dpcpp-cpp
-  
-    - name: Install g++-7
-      if: matrix.compiler.cxx == 'g++-7'
-      run: sudo apt-get install -y ${{matrix.compiler.cxx}}
-
-    - name: Install libhwloc
-      run: .github/scripts/install_hwloc.sh
-
-    - name: Set ptrace value for IPC test
-      run: sudo bash -c "echo 0 > /proc/sys/kernel/yama/ptrace_scope"
+        echo "${USERPASS}" | sudo -Sk ./.github/scripts/install_oneAPI.sh
+
+    - name: Get UMF version
+      run: |
+        git config --global --add safe.directory $GITHUB_WORKSPACE
+        VERSION=$(git describe --tags --abbrev=0 | grep -oP '\d+\.\d+\.\d+')
+        echo "UMF_VERSION=$VERSION" >> $GITHUB_ENV
 
     - name: Configure build
       run: >
@@ -165,11 +159,10 @@ jobs:
         -DUMF_FORMAT_CODE_STYLE=OFF
         -DUMF_DEVELOPER_MODE=ON
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
         -DUMF_TESTS_FAIL_ON_SKIP=ON
-        -DUMF_DISABLE_HWLOC=${{matrix.disable_hwloc}}
         -DUMF_LINK_HWLOC_STATICALLY=${{matrix.link_hwloc_statically}}
         ${{ matrix.build_type == 'Debug' && matrix.compiler.c == 'gcc' && '-DUMF_USE_COVERAGE=ON' || '' }}
+        ${{ matrix.llvm_linker || '' }}
 
     - name: Build UMF
       run: |
@@ -180,152 +173,285 @@ jobs:
       working-directory: ${{env.BUILD_DIR}}
       run: |
         ${{ matrix.compiler.cxx == 'icpx' && '. /opt/intel/oneapi/setvars.sh' || true }}
-        ctest --output-on-failure # run all tests for better coverage
+        LD_LIBRARY_PATH="${{env.BUILD_DIR}}/lib/:${LD_LIBRARY_PATH}" ctest --output-on-failure
 
     - name: Check coverage
       if:  ${{ matrix.build_type == 'Debug' && matrix.compiler.c == 'gcc' }}
       working-directory: ${{env.BUILD_DIR}}
       run: |
-        export COVERAGE_FILE_NAME=${{env.COVERAGE_NAME}}-${{matrix.os}}-shared-${{matrix.shared_library}}-no_hwloc-${{matrix.disable_hwloc}}
+        export COVERAGE_FILE_NAME=${{env.COVERAGE_NAME}}-${{matrix.os}}-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
+    - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
       if:  ${{ matrix.build_type == 'Debug' && matrix.compiler.c == 'gcc' }}
       with:
-        name: ${{env.COVERAGE_NAME}}-${{matrix.os}}-shared-${{matrix.shared_library}}-no_hwloc-${{matrix.disable_hwloc}}
+        name: ${{env.COVERAGE_NAME}}-${{matrix.os}}-shared-${{matrix.shared_library}}
         path: ${{env.COVERAGE_DIR}}
 
     - name: Remove the installation directory
       run: rm -rf ${{env.INSTL_DIR}}
 
     - name: Test UMF installation and uninstallation
-      # The '--shared-library' parameter is added to the installation test when the UMF is built as a shared library
       run: >
         python3 ${{github.workspace}}/test/test_installation.py
         --build-dir ${{env.BUILD_DIR}}
         --install-dir ${{env.INSTL_DIR}}
         --build-type ${{matrix.build_type}}
-        --disjoint-pool
-        --jemalloc-pool
-        ${{ matrix.install_tbb == 'ON' && matrix.disable_hwloc != 'ON' && matrix.shared_library == 'ON' && '--proxy' || '' }}
+        ${{ matrix.install_tbb == 'ON' && matrix.shared_library == 'ON' && '--proxy' || '' }}
         --umf-version ${{env.UMF_VERSION}}
         ${{ matrix.shared_library == 'ON' && '--shared-library' || '' }}
 
   windows-build:
-    name: Windows
     env:
-      VCPKG_PATH: "${{github.workspace}}/build/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows"
+      BUILD_DEBUG_DIR : "${{github.workspace}}/debug/build"
+      INSTL_DEBUG_DIR : "${{github.workspace}}/debug/install-dir"
+      BUILD_RELEASE_DIR : "${{github.workspace}}/release/build"
+      INSTL_RELEASE_DIR : "${{github.workspace}}/release/install-dir"
+      VCPKG_PATH: "${{github.workspace}}/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/vcpkg/packages/jemalloc_x64-windows"
+      VCPKG_PATH_BIN: "${{github.workspace}}/vcpkg/packages/hwloc_x64-windows/bin;${{github.workspace}}/vcpkg/packages/tbb_x64-windows/bin;${{github.workspace}}/vcpkg/packages/jemalloc_x64-windows/bin"
     strategy:
       matrix:
-        os: ['windows-2019', 'windows-2022']
-        build_type: [Debug, Release]
+        os: ['windows-2022', 'windows-2025']
         compiler: [{c: cl, cxx: cl}]
         shared_library: ['ON', 'OFF']
         level_zero_provider: ['ON']
         cuda_provider: ['ON']
         include:
-          # temporarily disable failing CI job
-          #- os: 'windows-2022'
-          #  build_type: Release
-          #  compiler: {c: clang-cl, cxx: clang-cl}
-          #  shared_library: 'ON'
-          #  level_zero_provider: 'ON'
-          #  cuda_provider: 'ON'
-          #  toolset: "-T ClangCL"
-          - os: 'windows-2022'
-            build_type: Release
-            compiler: {c: cl, cxx: cl}
+          # extra job: Custom (old) CMake, clang-cl compiler
+          # Note: This CMake uses NMake generator as VS paths are probably messed up (by CMake?)
+          - os: 'windows-2025'
+            extra_release_build_type: '-DCMAKE_BUILD_TYPE=Release' # NMake generator requires this
+            compiler: {c: clang-cl, cxx: clang-cl}
             shared_library: 'ON'
             level_zero_provider: 'ON'
             cuda_provider: 'ON'
-          - os: 'windows-2022'
-            build_type: Release
+            cmake_ver: '3.14.0-win64-x64'
+          # extra job: Custom CMake, L0/CUDA providers disabled
+          - os: 'windows-2025'
             compiler: {c: cl, cxx: cl}
             shared_library: 'ON'
             level_zero_provider: 'OFF'
             cuda_provider: 'OFF'
-
+            cmake_ver: '3.28.0-windows-x86_64'
+          # umfd enabled (this job will replace one from matrix)
+          - os: 'windows-2022'
+            compiler: {c: cl, cxx: cl}
+            shared_library: 'ON'
+            level_zero_provider: 'ON'
+            cuda_provider: 'ON'
+            umfd_lib: 'ON'
+    name: Basic (${{matrix.os}}, 
+          compilers=${{matrix.compiler.c}}/${{matrix.compiler.cxx}}, 
+          shared_library=${{matrix.shared_library}}, 
+          level_zero_provider=${{matrix.level_zero_provider}}, 
+          cuda_provider=${{matrix.cuda_provider}}, 
+          cmake_ver=${{matrix.cmake_ver || 'default'}}, 
+          umfd=${{matrix.umfd_lib || 'OFF'}})
+          extra=${{matrix.extra_release_build_type || ''}}
     runs-on: ${{matrix.os}}
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
 
+    - name: Install cmake (non-default version)
+      if: ${{ matrix.cmake_ver != 'default' && matrix.cmake_ver != '' }}
+      run: |
+        $ErrorActionPreference = "Stop"
+        $cmakePath = "C:\Program Files\CMake"
+        if (Test-Path -Path $cmakePath) {
+          Write-Host "Removing existing CMake installation..."
+          Remove-Item -Recurse -Force -Path $cmakePath
+        }
+        $cmakeInstaller = "cmake-${{matrix.cmake_ver}}.msi"
+        $cmakeInstallerParts = $cmakeInstaller -split '-|\.'
+        $cmakeMajorMinorPatch = "$($cmakeInstallerParts[1]).$($cmakeInstallerParts[2]).$($cmakeInstallerParts[3])"
+        $cmakeUrl = "https://github.com/Kitware/CMake/releases/download/v$cmakeMajorMinorPatch/$cmakeInstaller"
+        Write-Host "Downloading CMake version ${{matrix.cmake_ver}}..."
+        Invoke-WebRequest -Uri $cmakeUrl -OutFile $cmakeInstaller -TimeoutSec 360
+        Write-Host "Installing CMake version ${{matrix.cmake_ver}}..."
+        Start-Process msiexec.exe -ArgumentList "/i $cmakeInstaller /quiet /norestart" -Wait
+        cmake --version
+
+    # Ensure that the required environment is set
+    # Note: While this step is required for the clang-cl compiler, it can be executed for all jobs
+    - name: Setup MSVC dev command prompt
+      uses: TheMrMilchmann/setup-msvc-dev@79dac248aac9d0059f86eae9d8b5bfab4e95e97c # v4.0.0
+      with:
+        arch: x64
+
+    - name: Restore vcpkg cache
+      uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+      id: cache
+      with:
+        path: vcpkg_pkgs_cache.zip
+        key: vcpkg-basic-${{matrix.os}}-${{ hashFiles('vcpkg.json') }}
+
+    - name: Unpack vcpkg cache
+      if: steps.cache.outputs.cache-hit == 'true'
+      run: |
+        Expand-Archive -Path ${{github.workspace}}/vcpkg_pkgs_cache.zip -DestinationPath ${{github.workspace}}/vcpkg -Force
+
     - name: Initialize vcpkg
+      if: steps.cache.outputs.cache-hit != 'true'
       uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
       with:
-        vcpkgGitCommitId: 3dd44b931481d7a8e9ba412621fa810232b66289
-        vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
+        vcpkgGitCommitId: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
+        vcpkgDirectory: ${{github.workspace}}/vcpkg
         vcpkgJsonGlob: '**/vcpkg.json'
 
     - name: Install dependencies
-      run: vcpkg install
-      shell: pwsh # Specifies PowerShell as the shell for running the script.
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: vcpkg install --triplet x64-windows
 
-    - name: Configure build
+    # Older versions of CMake require this step to correctly locate dependencies
+    - name: Add vcpkg bin dirs to PATH
+      run: |
+        $env:Path = "${{env.VCPKG_PATH_BIN}};$env:Path"
+        echo "PATH=$env:Path" >> $env:GITHUB_ENV
+
+    - name: Get UMF version
+      run: |
+        $version = (git describe --tags --abbrev=0 | Select-String -Pattern '\d+\.\d+\.\d+').Matches.Value
+        echo "UMF_VERSION=$version" >> $env:GITHUB_ENV
+
+    - name: Configure build (Debug)
       run: >
         cmake
-        -B ${{env.BUILD_DIR}}
-        ${{matrix.toolset}}
-        -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
+        -B ${{env.BUILD_DEBUG_DIR}}
+        -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DEBUG_DIR}}"
         -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
         -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
         -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
         -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}}
         -DUMF_FORMAT_CODE_STYLE=OFF
         -DUMF_DEVELOPER_MODE=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=${{matrix.level_zero_provider}}
         -DUMF_BUILD_CUDA_PROVIDER=${{matrix.cuda_provider}}
         -DUMF_TESTS_FAIL_ON_SKIP=ON
+        -DUMF_USE_DEBUG_POSTFIX=${{matrix.umfd_lib || 'OFF'}}
 
-    - name: Build UMF
-      run: cmake --build ${{env.BUILD_DIR}} --config ${{matrix.build_type}} -j $Env:NUMBER_OF_PROCESSORS
+    - name: Build UMF (Debug)
+      run: cmake --build ${{env.BUILD_DEBUG_DIR}} --config Debug -j $Env:NUMBER_OF_PROCESSORS
 
-    - name: Run tests
-      working-directory: ${{env.BUILD_DIR}}
-      run: ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
+    - name: Run tests (Debug)
+      working-directory: ${{env.BUILD_DEBUG_DIR}}
+      # For CMake versions < 3.22 we have to add the build directory to the PATH manually
+      # Extra paths without 'build_type' are set for NMake generator
+      run: |
+        $m = [regex]::Matches((cmake --version), "cmake version (\d+)\.(\d+)\.(\d+)")
+        if ($m) {
+          $major = [int]$m.groups[1].Value
+          $minor = [int]$m.groups[2].Value
+          if ($major -lt 3 -or ($major -eq 3 -and $minor -lt 22)) {
+            $env:Path = "${{env.BUILD_DEBUG_DIR}}/bin/Debug;${{env.BUILD_DEBUG_DIR}}/src/proxy_lib/Debug;$env:Path"
+            $env:Path = "${{env.BUILD_DEBUG_DIR}}/bin/;${{env.BUILD_DEBUG_DIR}}/src/proxy_lib/;$env:Path"
+            echo "PATH=$env:Path" >> $env:GITHUB_ENV
+          }
+        }
+        ctest -C Debug --output-on-failure --test-dir test
+      shell: pwsh
 
-    - name: Test UMF installation and uninstallation
-      # The '--shared-library' parameter is added to the installation test when the UMF is built as a shared library
+    - name: Test UMF installation and uninstallation (Debug)
       run: >
         python3 ${{github.workspace}}/test/test_installation.py
-        --build-dir ${{env.BUILD_DIR}}
-        --install-dir ${{env.INSTL_DIR}}
-        --build-type ${{matrix.build_type}}
-        --disjoint-pool
-        --jemalloc-pool
+        --build-dir ${{env.BUILD_DEBUG_DIR}}
+        --install-dir ${{env.INSTL_DEBUG_DIR}}
+        --build-type Debug
         ${{matrix.shared_library == 'ON' && '--proxy' || '' }}
         --umf-version ${{env.UMF_VERSION}}
         ${{ matrix.shared_library == 'ON' && '--shared-library' || ''}}
-        
-    - name: check /DEPENDENTLOADFLAG in umf.dll
+        ${{ matrix.umfd_lib == 'ON' && '--umfd-lib' || ''}}
+
+    - name: Configure build (Release)
+      run: >
+        cmake
+        -B ${{env.BUILD_RELEASE_DIR}}
+        ${{matrix.extra_release_build_type || ''}}
+        -DCMAKE_INSTALL_PREFIX="${{env.INSTL_RELEASE_DIR}}"
+        -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
+        -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
+        -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
+        -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}}
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=${{matrix.level_zero_provider}}
+        -DUMF_BUILD_CUDA_PROVIDER=${{matrix.cuda_provider}}
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+        -DUMF_USE_DEBUG_POSTFIX=${{matrix.umfd_lib || 'OFF'}}
+
+    - name: Build UMF (Release)
+      run: cmake --build ${{env.BUILD_RELEASE_DIR}} --config Release -j $Env:NUMBER_OF_PROCESSORS
+
+    - name: Run tests (Release)
+      working-directory: ${{env.BUILD_RELEASE_DIR}}
+      # For CMake versions < 3.22 we have to add the build directory to the PATH manually
+      # Extra paths without 'build_type' are set for NMake generator
+      run: |
+        $m = [regex]::Matches((cmake --version), "cmake version (\d+)\.(\d+)\.(\d+)")
+        if ($m) {
+          $major = [int]$m.groups[1].Value
+          $minor = [int]$m.groups[2].Value
+          if ($major -lt 3 -or ($major -eq 3 -and $minor -lt 22)) {
+            $env:Path = "${{env.BUILD_RELEASE_DIR}}/bin/Release;${{env.BUILD_RELEASE_DIR}}/src/proxy_lib/Release;$env:Path"
+            $env:Path = "${{env.BUILD_RELEASE_DIR}}/bin/;${{env.BUILD_RELEASE_DIR}}/src/proxy_lib/;$env:Path"
+            echo "PATH=$env:Path" >> $env:GITHUB_ENV
+          }
+        }
+        ctest -C Release --output-on-failure --test-dir test
+      shell: pwsh
+
+    - name: Test UMF installation and uninstallation (Release)
+      run: >
+        python3 ${{github.workspace}}/test/test_installation.py
+        --build-dir ${{env.BUILD_RELEASE_DIR}}
+        --install-dir ${{env.INSTL_RELEASE_DIR}}
+        --build-type Release
+        ${{matrix.shared_library == 'ON' && '--proxy' || '' }}
+        --umf-version ${{env.UMF_VERSION}}
+        ${{ matrix.shared_library == 'ON' && '--shared-library' || ''}}
+        ${{ matrix.umfd_lib == 'ON' && '--umfd-lib' || ''}}
+
+    - name: check /DEPENDENTLOADFLAG in umf.dll (Release)
       if: ${{matrix.shared_library == 'ON' && matrix.compiler.cxx == 'cl'}}
-      run: ${{github.workspace}}/.github/scripts/check_dll_flags.ps1 ${{env.BUILD_DIR}}/bin/${{matrix.build_type}}/umf.dll
+      run: ${{github.workspace}}/.github/scripts/check_dll_flags.ps1 ${{env.BUILD_RELEASE_DIR}}/bin/Release/umf.dll
       shell: pwsh
 
-    - name: check /DEPENDENTLOADFLAG in umf_proxy.dll
+    - name: check /DEPENDENTLOADFLAG in umf_proxy.dll (Release)
       if: ${{matrix.shared_library == 'ON' && matrix.compiler.cxx == 'cl'}}
-      run: ${{github.workspace}}/.github/scripts/check_dll_flags.ps1 ${{env.BUILD_DIR}}/src/proxy_lib/${{matrix.build_type}}/umf_proxy.dll
+      run: ${{github.workspace}}/.github/scripts/check_dll_flags.ps1 ${{env.BUILD_RELEASE_DIR}}/src/proxy_lib/Release/umf_proxy.dll
       shell: pwsh
 
+    - name: Prepare vcpkg cache
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: |
+        Compress-Archive -Path ${{github.workspace}}/vcpkg/packages -DestinationPath ${{github.workspace}}/vcpkg_pkgs_cache.zip -Force -CompressionLevel Fastest
+
+    - name: Save vcpkg cache
+      if: steps.cache.outputs.cache-hit != 'true'
+      uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+      with:
+        path: ${{github.workspace}}/vcpkg_pkgs_cache.zip
+        key: ${{ steps.cache.outputs.cache-primary-key }}
+
   windows-dynamic_build_hwloc:
     name: "Windows dynamic UMF + static hwloc"
     strategy:
       matrix:
         build_type: [Release]
 
-    runs-on: 'windows-2022'
+    runs-on: 'windows-latest'
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
 
@@ -335,10 +461,9 @@ jobs:
         -B ${{env.BUILD_DIR}}
         -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
         -DUMF_BUILD_SHARED_LIBRARY=ON
-        -DUMF_BUILD_EXAMPLES=OFF
+        -DUMF_BUILD_EXAMPLES=ON
         -DUMF_FORMAT_CODE_STYLE=OFF
         -DUMF_DEVELOPER_MODE=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=OFF
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
         -DUMF_BUILD_CUDA_PROVIDER=ON
@@ -364,11 +489,11 @@ jobs:
       matrix:
         build_type: [Release]
 
-    runs-on: 'windows-2022'
+    runs-on: 'windows-latest'
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
 
@@ -378,10 +503,9 @@ jobs:
         -B ${{env.BUILD_DIR}}
         -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
         -DUMF_BUILD_SHARED_LIBRARY=OFF
-        -DUMF_BUILD_EXAMPLES=OFF
+        -DUMF_BUILD_EXAMPLES=ON
         -DUMF_FORMAT_CODE_STYLE=OFF
         -DUMF_DEVELOPER_MODE=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=OFF
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
         -DUMF_BUILD_CUDA_PROVIDER=ON
@@ -395,68 +519,22 @@ jobs:
       working-directory: ${{env.BUILD_DIR}}
       run: ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
 
-  windows-dynamic_mingw_hwloc:
-    env:
-      HWLOC_PACKAGE_NAME: hwloc-win64-build-2.10.0
-      TBB_PACKAGE_NAME: oneapi-tbb-2021.12.0
-      TBB_LIB_DIR: lib\intel64\vc14
-      TBB_BIN_DIR: redist\intel64\vc14
-
-    name: "Windows dynamic UMF + mingw libhwloc"
-    strategy:
-      matrix:
-        build_type: [Release]
-
-    runs-on: 'windows-2022'
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      with:
-        fetch-depth: 0
-
-    - name: Get hwloc from official repo (mingw version)
-      run: |
-        Invoke-WebRequest -Uri https://download.open-mpi.org/release/hwloc/v2.10/${{env.HWLOC_PACKAGE_NAME}}.zip -OutFile ${{github.workspace}}\${{env.HWLOC_PACKAGE_NAME}}.zip -TimeoutSec 360
-        Expand-Archive ${{github.workspace}}\${{env.HWLOC_PACKAGE_NAME}}.zip -DestinationPath ${{github.workspace}}
-
-    - name: Get TBB from github
-      run: |
-        Invoke-WebRequest -Uri https://github.com/oneapi-src/oneTBB/releases/download/v2021.12.0/${{env.TBB_PACKAGE_NAME}}-win.zip -OutFile "${{github.workspace}}\${{env.TBB_PACKAGE_NAME}}-win.zip" -TimeoutSec 360
-        Expand-Archive "${{github.workspace}}\${{env.TBB_PACKAGE_NAME}}-win.zip" -DestinationPath ${{github.workspace}}
-
-    - name: Configure build
-      run: >
-        cmake
-        -B ${{env.BUILD_DIR}}
-        -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
-        -DCMAKE_PREFIX_PATH="${{github.workspace}}\${{env.HWLOC_PACKAGE_NAME}};${{github.workspace}}\${{env.TBB_PACKAGE_NAME}};${{github.workspace}}\${{env.TBB_PACKAGE_NAME}}\${{env.TBB_LIB_DIR}};${{github.workspace}}\${{env.TBB_PACKAGE_NAME}}\${{env.TBB_BIN_DIR}}"
-        -DUMF_BUILD_SHARED_LIBRARY=ON
-        -DUMF_BUILD_EXAMPLES=ON
-        -DUMF_FORMAT_CODE_STYLE=OFF
-        -DUMF_DEVELOPER_MODE=ON
-        -DUMF_TESTS_FAIL_ON_SKIP=ON
-        -DUMF_HWLOC_NAME=libhwloc
-
-    - name: Build UMF
-      run: cmake --build ${{env.BUILD_DIR}} --config ${{matrix.build_type}} -j $Env:NUMBER_OF_PROCESSORS
-
-    - name: Run tests
-      working-directory: ${{env.BUILD_DIR}}
-      run: ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
-
   macos-build:
-    name: MacOS
     strategy:
       matrix:
-        os: ['macos-13', 'macos-14']
+        include:
+          - os: macos-14
+            static_hwloc: 'OFF'
+          - os: macos-15
+            static_hwloc: 'ON'
     env:
       BUILD_TYPE : "Release"
+    name: Basic (${{matrix.os}}, static_hwloc=${{matrix.static_hwloc}})
     runs-on: ${{matrix.os}}
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
 
@@ -468,8 +546,17 @@ jobs:
         echo "$PATH" >> $GITHUB_PATH
         python3 -m pip install -r third_party/requirements.txt
 
+    - name: Install dependencies
+      run: brew install --quiet jemalloc tbb automake libtool
+
     - name: Install hwloc
-      run: brew install hwloc jemalloc tbb
+      if: ${{ matrix.static_hwloc == 'OFF' }}
+      run: brew install --quiet hwloc
+
+    - name: Get UMF version
+      run: |
+        VERSION=$(git describe --tags --abbrev=0 | grep -Eo '\d+\.\d+\.\d+')
+        echo "UMF_VERSION=$VERSION" >> $GITHUB_ENV
 
     - name: Configure build
       run: >
@@ -480,10 +567,10 @@ jobs:
         -DUMF_FORMAT_CODE_STYLE=OFF
         -DUMF_DEVELOPER_MODE=ON
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
         -DUMF_BUILD_SHARED_LIBRARY=ON
         -DUMF_TESTS_FAIL_ON_SKIP=ON
+        -DUMF_LINK_HWLOC_STATICALLY=${{matrix.static_hwloc}}
 
     - name: Build UMF
       run: cmake --build ${{env.BUILD_DIR}} -j $(sysctl -n hw.logicalcpu)
@@ -494,8 +581,6 @@ jobs:
         --build-dir ${{env.BUILD_DIR}}
         --install-dir ${{env.INSTL_DIR}}
         --build-type ${{env.BUILD_TYPE}}
-        --disjoint-pool
-        --jemalloc-pool
         --proxy
         --umf-version ${{env.UMF_VERSION}}
         --shared-library
diff --git a/.github/workflows/reusable_benchmarks.yml b/.github/workflows/reusable_benchmarks.yml
index 41710029c8..a6dc2f1e2f 100644
--- a/.github/workflows/reusable_benchmarks.yml
+++ b/.github/workflows/reusable_benchmarks.yml
@@ -1,80 +1,281 @@
-# Executes benchmarks implemented in this repository
+# Executes benchmarks implemented in this repository using scripts
+# for results visualization from intel/llvm.
 name: Benchmarks
 
-on: workflow_call
+on:
+  workflow_call:
+    inputs:
+      pr_no:
+        # even though this is a number, this is a workaround for issues with
+        # reusable workflow calls that result in "Unexpected value '0'" error.
+        type: string
+        default: '0'
+      bench_script_params:
+        required: false
+        type: string
+        default: ''
+      bench_script_compare:
+        required: false
+        type: string
+        default: ''
+      runner:
+        required: false
+        type: string
+        default: 'L0_PERF_PVC'
+      compatibility:
+        required: false
+        type: string
+        default: '0'
+        description: |
+          Set it to 1 to run compatibility sycl benchmarks
 
 permissions:
   contents: read
+  pull-requests: read
 
 env:
-  BUILD_DIR : "${{github.workspace}}/build"
-  INSTL_DIR : "${{github.workspace}}/../install-dir"
+  UMF_DIR: "${{github.workspace}}/umf-repo"
+  BUILD_DIR : "${{github.workspace}}/umf-repo/build"
 
 jobs:
   benchmarks:
     name: Benchmarks
-    env:
-      VCPKG_PATH: "${{github.workspace}}/build/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows"
-    strategy:
-      matrix:
-        os: ['ubuntu-latest', 'windows-latest']
-        include: 
-          # Windows doesn't recognize 'CMAKE_BUILD_TYPE', it uses '--config' param in build command to determine the build type
-          - os: ubuntu-latest
-            extra_build_option: '-DCMAKE_BUILD_TYPE=Release'
-    runs-on: ${{matrix.os}}
+    # run only on upstream; forks will not have the HW
+    if: github.repository == 'oneapi-src/unified-memory-framework'
+    runs-on: ${{ inputs.runner }}
+    permissions:
+      contents: write
+      pull-requests: write
 
     steps:
-      - name: Checkout
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-        with:
-          fetch-depth: 0
-
-      - name: Install apt packages
-        if: matrix.os == 'ubuntu-latest'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y cmake libhwloc-dev libnuma-dev libjemalloc-dev libtbb-dev
-
-      - name: Initialize vcpkg
-        if: matrix.os == 'windows-latest'
-        uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
-        with:
-          vcpkgGitCommitId: 3dd44b931481d7a8e9ba412621fa810232b66289
-          vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
-          vcpkgJsonGlob: '**/vcpkg.json'
-
-      - name: Install vcpkg packages
-        if: matrix.os == 'windows-latest'
-        run: vcpkg install
-        shell: pwsh # Specifies PowerShell as the shell for running the script.
-
-      - name: Configure build
-        run: >
-          cmake
-          -B ${{env.BUILD_DIR}}
-          ${{matrix.extra_build_option}}
-          -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
-          -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
-          -DUMF_BUILD_SHARED_LIBRARY=ON
-          -DUMF_BUILD_BENCHMARKS=ON
-          -DUMF_BUILD_BENCHMARKS_MT=ON
-          -DUMF_BUILD_TESTS=OFF
-          -DUMF_FORMAT_CODE_STYLE=OFF
-          -DUMF_DEVELOPER_MODE=OFF
-          -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
-          -DUMF_BUILD_CUDA_PROVIDER=ON
-          -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
-          -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
-
-      - name: Build UMF on Linux
-        if: matrix.os == 'ubuntu-latest'
-        run: cmake --build ${{env.BUILD_DIR}} -j $(nproc)
-
-      - name: Build UMF on Windows
-        if: matrix.os == 'windows-latest'
-        run: cmake --build ${{env.BUILD_DIR}} --config Release -j $Env:NUMBER_OF_PROCESSORS
-
-      - name: Run benchmarks
-        working-directory: ${{env.BUILD_DIR}}
-        run: ctest -V --test-dir benchmark -C Release
+    - name: Establish bench params
+      run: |
+        params="${{ inputs.bench_script_params }}"
+        if [ -n "${{ inputs.bench_script_compare }}" ]; then
+          params="$params --compare '${{ inputs.bench_script_compare }}'"
+        fi
+
+        echo "params=$params"
+        echo "bench_params=$params" >> $GITHUB_ENV
+
+    - name: Add comment to PR
+      uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
+      if: ${{ always() && inputs.pr_no != 0 }}
+      with:
+        script: |
+          const pr_no = '${{ inputs.pr_no }}';
+          const url = '${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}';
+          const params = `${{ env.bench_params }}`;
+          const body = `Compute Benchmarks run (with params: ${params}):\n${url}`;
+
+          github.rest.issues.createComment({
+            issue_number: pr_no,
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            body: body
+          })
+
+    - name: Checkout UMF
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        path: ${{env.UMF_DIR}}
+        fetch-depth: 0
+
+    # We need to fetch special ref for proper PR's merge commit. Note, this ref may be absent if the PR is already merged.
+    - name: Fetch PR's merge commit
+      if: ${{ inputs.pr_no != 0 }}
+      working-directory: ${{env.UMF_DIR}}
+      env:
+        PR_NO: ${{ inputs.pr_no }}
+      run: |
+        git fetch -- https://github.com/${{github.repository}} +refs/pull/${PR_NO}/*:refs/remotes/origin/pr/${PR_NO}/*
+        git checkout origin/pr/${PR_NO}/merge
+        git rev-parse origin/pr/${PR_NO}/merge
+
+    - name: Configure UMF
+      run: >
+        cmake
+        -S ${{env.UMF_DIR}}
+        -B ${{env.BUILD_DIR}}
+        -DCMAKE_BUILD_TYPE=Release
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DUMF_BUILD_BENCHMARKS=ON
+        -DUMF_BUILD_BENCHMARKS_MT=ON
+        -DUMF_BUILD_TESTS=OFF
+        -DUMF_BUILD_EXAMPLES=OFF
+        -DUMF_DEVELOPER_MODE=OFF
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+
+    - name: Build UMF
+      run: cmake --build ${{env.BUILD_DIR}} -j $(nproc)
+
+    - name: Checkout UMF results branch
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        ref: benchmark-results
+        path: results-repo
+
+    # Get scripts for benchmark data visualization (from SYCL repo).
+    # Use specific ref, as the scripts or files' location may change.
+    - name: Checkout benchmark scripts
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        repository: intel/llvm
+        # Note: The same ref is used in docs build (for dashboard generation)!
+        #
+        # 30.07.2025
+        # branch: sycl
+        ref: 8f54710553800eec05a6fd9717b14f995a22b137
+        path: sc
+        sparse-checkout: |
+          devops/scripts/benchmarks
+
+    - name: Install benchmarking scripts deps
+      run: |
+        python3 -m venv .venv
+        source .venv/bin/activate
+        echo "$PATH" >> $GITHUB_PATH
+        pip install -r ${{github.workspace}}/sc/devops/scripts/benchmarks/requirements.txt
+
+    - name: Set core range and GPU mask
+      run: |
+        # On the L0_PERF_PVC runner, compute the core range for the second NUMA node;
+        # first node is for SYCL/UR jobs.
+        # Skip the first 4 cores - the kernel is likely to schedule more work on these.
+        CORES=$(lscpu | awk '
+          /NUMA node1 CPU|On-line CPU/ {line=$0}
+          END {
+            split(line, a, " ")
+            split(a[4], b, ",")
+            sub(/^0/, "4", b[1])
+            print b[1]
+          }')
+        echo "Selected core: $CORES"
+        echo "CORES=$CORES" >> $GITHUB_ENV
+
+        ZE_AFFINITY_MASK=${{ inputs.runner == 'L0_PERF_ARC' && '0' || '1' }}
+        echo "ZE_AFFINITY_MASK=$ZE_AFFINITY_MASK" >> $GITHUB_ENV
+
+    - name: Download latest sycl
+      if: inputs.compatibility == 1
+      run: |
+        llvm_tag=$(curl -s https://api.github.com/repos/intel/llvm/releases | awk -F'"' '/"tag_name": "nightly/ {print $4; exit}')
+        download_url="https://github.com/intel/llvm/releases/download/${llvm_tag}/sycl_linux.tar.gz"
+        echo "llvm tag: $llvm_tag"
+        wget --no-verbose $download_url -O sycl_linux.tar.gz
+
+    - name: Unpack sycl
+      if: inputs.compatibility == 1
+      run: |
+        mkdir -p sycl
+        tar -xzf sycl_linux.tar.gz -C sycl --strip-components=1
+        rm sycl_linux.tar.gz
+        echo "SYCL_DIR=${{ github.workspace }}/sycl" >> $GITHUB_ENV
+        echo "${{ github.workspace }}/sycl/bin" >> $GITHUB_PATH
+        echo "LD_LIBRARY_PATH=${{ github.workspace }}/sycl/lib:$LD_LIBRARY_PATH" >> $GITHUB_ENV
+
+    - name: Remove UMF libraries from sycl
+      if: inputs.compatibility == 1
+      run: rm -f ${{ env.SYCL_DIR }}/lib/libumf*
+
+    - name: Copy UMF libraries to sycl
+      if: inputs.compatibility == 1
+      run: |
+        cp ${{ env.BUILD_DIR }}/lib/libumf* ${{ env.SYCL_DIR }}/lib/
+
+    - name: Run sycl-ls
+      if: inputs.compatibility == 1
+      env:
+        LD_LIBRARY_PATH: ${{ env.SYCL_DIR }}/lib
+        SYCL_UR_TRACE: 1
+        SYCL_UR_USE_LEVEL_ZERO_V2: 1
+      run: ${{ env.SYCL_DIR }}/bin/sycl-ls
+
+    - name: Run benchmarks
+      id: benchmarks
+      env:
+        LD_LIBRARY_PATH: ${{ env.SYCL_DIR }}/lib
+        CPATH: ${{ env.SYCL_DIR }}/include
+      run: >
+        taskset -c ${{ env.CORES }} ./sc/devops/scripts/benchmarks/main.py
+        ~/bench_workdir_umf
+        --results-dir ${{ github.workspace }}/results-repo
+        --output-markdown
+        ${{ (inputs.compatibility == 0) && format('--umf {0}/ --timeout 3000 --output-html remote', env.BUILD_DIR) || '' }}
+        ${{ (inputs.compatibility == 1) && format('--sycl {0} --timeout 7200', env.SYCL_DIR) || '' }}
+        ${{ env.bench_params }}
+
+    # In case it failed to add a comment, we can still print the results.
+    - name: Print benchmark results
+      if: ${{ always() }}
+      run: cat ${{ github.workspace }}/benchmark_results.md || true
+
+    - name: Add comment to PR
+      uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
+      if: ${{ always() && inputs.pr_no != 0 }}
+      with:
+        script: |
+          let markdown = ""
+          try {
+            const fs = require('fs');
+            markdown = fs.readFileSync('${{ github.workspace }}/benchmark_results.md', 'utf8');
+          } catch(err) {
+          }
+
+          const pr_no = '${{ inputs.pr_no }}';
+          const url = '${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}';
+          const test_status = '${{ steps.benchmarks.outcome }}';
+          const job_status = '${{ job.status }}';
+          const params = `${{ env.bench_params }}`;
+          const body = `Compute Benchmarks run (${params}):\n${url}\nJob status: ${job_status}. Test status: ${test_status}.\n ${markdown}`;
+
+          github.rest.issues.createComment({
+            issue_number: pr_no,
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            body: body
+          })
+
+    - name: Commit data.json, data_archive.json, and results directory
+      working-directory: results-repo
+      if: inputs.compatibility == 0
+      run: |
+        git config --global user.name "GitHub Actions Bot"
+        git config --global user.email "actions@github.com"
+
+        for attempt in {1..5}; do
+          echo "Attempt #$attempt to push changes"
+
+          rm -f data.json data_archive.json
+          cp ${{ github.workspace }}/sc/devops/scripts/benchmarks/html/data.json .
+          cp ${{ github.workspace }}/sc/devops/scripts/benchmarks/html/data_archive.json .
+
+          git add data.json data_archive.json results/
+          git commit -m "Add benchmark results, data.json, and data_archive.json"
+
+          results_file=$(git diff HEAD~1 --name-only -- results/ | head -n 1)
+
+          if git push origin benchmark-results; then
+            echo "Push succeeded"
+            break
+          fi
+
+          echo "Push failed, retrying..."
+
+          if [ -n "$results_file" ]; then
+            mv $results_file ${{ github.workspace }}/temp_$(basename $results_file)
+
+            git reset --hard origin/benchmark-results
+            git pull origin benchmark-results
+
+            new_file="results/$(basename "$results_file")"
+            mv ${{ github.workspace }}/temp_$(basename $results_file) $new_file
+          fi
+
+          echo "Regenerating data.json and data_archive.json"
+          (cd ${{ github.workspace }} && ${{ github.workspace }}/sc/devops/scripts/benchmarks/main.py ~/bench_workdir_umf --dry-run --results-dir ${{ github.workspace }}/results-repo --output-html remote)
+
+        done
diff --git a/.github/workflows/reusable_checks.yml b/.github/workflows/reusable_checks.yml
index e3e264b0db..460dee11f7 100644
--- a/.github/workflows/reusable_checks.yml
+++ b/.github/workflows/reusable_checks.yml
@@ -14,14 +14,14 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
 
     - name: Install dependencies
       run: |
         sudo apt-get update
-        sudo apt-get install -y black cmake clang-format-15 cmake-format libhwloc-dev
+        sudo apt-get install -y cmake libhwloc-dev doxygen
 
     # Latest distros do not allow global pip installation
     - name: Install Python requirements in venv
@@ -29,7 +29,7 @@ jobs:
         python3 -m venv .venv
         . .venv/bin/activate
         echo "$PATH" >> $GITHUB_PATH
-        python3 -m pip install bandit
+        python3 -m pip install -r third_party/requirements.txt
 
     - name: Configure CMake
       run: >
@@ -52,11 +52,24 @@ jobs:
     - name: Check Python formatting
       run: cmake --build build --target black-format-check
 
+    - name: Run check-license
+      run: |
+        ./scripts/check_license/check_headers.sh . "Apache-2.0 WITH LLVM-exception" -v
+
     - name: Run a spell check
-      uses: crate-ci/typos@b63f421581dce830bda2f597a678cb7776b41877 # v1.18.2
+      uses: crate-ci/typos@2d0ce569feab1f8752f1dde43cc2f2aa53236e06 # v1.40.0
       with:
         config: ./.github/workflows/.spellcheck-conf.toml
 
+    - name: Run codespell
+      run: python3 ./.github/scripts/run-codespell.py
+
+    - name: Check spelling in docs
+      run: |
+        cmake -B build
+        cmake --build build --target docs
+        sphinx-build -b spelling ./build/docs_build/config ./build/docs_build/spelling_log -W
+
     # Run Bandit recursively, but omit _deps directory (with 3rd party code) and python's venv
     - name: Run Bandit
       run: python3 -m bandit -r . -x '/_deps/,/.venv/'
diff --git a/.github/workflows/reusable_codeql.yml b/.github/workflows/reusable_codeql.yml
index e764563103..f2148d1cdf 100644
--- a/.github/workflows/reusable_codeql.yml
+++ b/.github/workflows/reusable_codeql.yml
@@ -5,10 +5,11 @@ on: workflow_call
 
 permissions:
   contents: read
+  security-events: read
 
 env:
   BUILD_DIR : "${{github.workspace}}/build"
-  INSTL_DIR : "${{github.workspace}}/../install-dir"
+  INSTL_DIR : "${{github.workspace}}/install-dir"
 
 jobs:
   analyze:
@@ -30,39 +31,55 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
 
     - name: Setup newer Python
-      uses: actions/setup-python@0a5c61591373683505ea898e09a3ea4f39ef2b9c # v5.0.0
+      uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
       with:
         python-version: "3.10"
 
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@b7bf0a3ed3ecfa44160715d7c442788f65f0f923 # v3.23.2
+      uses: github/codeql-action/init@fe4161a26a8629af62121b670040955b330f9af2 # v4.31.6
       with:
         languages: cpp
+        trap-caching: false
 
-    - name: "[Win] Initialize vcpkg"
+    - name: "[Win] Restore vcpkg cache"
       if: matrix.os == 'windows-latest'
+      uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+      id: cache
+      with:
+        path: vcpkg_pkgs_cache.zip
+        key: vcpkg-codeql-${{matrix.os}}-${{ hashFiles('vcpkg.json') }}
+
+    - name: "[Win] Unpack vcpkg cache"
+      if: matrix.os == 'windows-latest' && steps.cache.outputs.cache-hit == 'true'
+      run: |
+        Expand-Archive -Path ${{github.workspace}}/vcpkg_pkgs_cache.zip -DestinationPath ${{env.BUILD_DIR}}/vcpkg -Force
+
+    - name: "[Win] Initialize vcpkg"
+      if: matrix.os == 'windows-latest' && steps.cache.outputs.cache-hit != 'true'
       uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
       with:
-        vcpkgGitCommitId: 3dd44b931481d7a8e9ba412621fa810232b66289
+        vcpkgGitCommitId: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
         vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
         vcpkgJsonGlob: '**/vcpkg.json'
 
-    - name: "[Win] Install dependencies"
+    - name: "[Win] Install vcpkg dependencies"
+      if: matrix.os == 'windows-latest' && steps.cache.outputs.cache-hit != 'true'
+      run: vcpkg install --triplet x64-windows
+
+    - name: "[Win] Install Python requirements"
       if: matrix.os == 'windows-latest'
-      run: |
-        vcpkg install
-        python3 -m pip install -r third_party/requirements.txt
+      run: python3 -m pip install -r third_party/requirements.txt
 
     - name: "[Lin] Install apt packages"
       if: matrix.os == 'ubuntu-latest'
       run: |
         sudo apt-get update
-        sudo apt-get install -y cmake clang libhwloc-dev libnuma-dev libjemalloc-dev libtbb-dev
+        sudo apt-get install -y cmake clang libhwloc-dev libnuma-dev libtbb-dev
 
     # Latest distros do not allow global pip installation
     - name: "[Lin] Install Python requirements in venv"
@@ -91,4 +108,16 @@ jobs:
       run: cmake --build ${{env.BUILD_DIR}} --config Release -j
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@b7bf0a3ed3ecfa44160715d7c442788f65f0f923 # v3.23.2
+      uses: github/codeql-action/analyze@fe4161a26a8629af62121b670040955b330f9af2 # v4.31.6
+
+    - name: "[Win] Prepare vcpkg cache"
+      if: matrix.os == 'windows-latest' && steps.cache.outputs.cache-hit != 'true'
+      run: |
+        Compress-Archive -Path ${{env.BUILD_DIR}}/vcpkg/packages -DestinationPath ${{github.workspace}}/vcpkg_pkgs_cache.zip -Force -CompressionLevel Fastest
+
+    - name: "[Win] Save vcpkg cache"
+      if: matrix.os == 'windows-latest' && steps.cache.outputs.cache-hit != 'true'
+      uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+      with:
+        path: ${{github.workspace}}/vcpkg_pkgs_cache.zip
+        key: ${{ steps.cache.outputs.cache-primary-key }}
diff --git a/.github/workflows/reusable_compatibility.yml b/.github/workflows/reusable_compatibility.yml
new file mode 100644
index 0000000000..621103479c
--- /dev/null
+++ b/.github/workflows/reusable_compatibility.yml
@@ -0,0 +1,418 @@
+# Workflow for checking the backward compatibility of UMF.
+# Test the latest UMF shared library with binaries compiled using the older UMF 
+# shared library.
+name: Compatibility 
+
+on:
+  workflow_call:
+    inputs:
+      tag:
+        description: Check backward compatibility with this tag
+        type: string
+        # While we're still compatible with v1.0.0, we implemented a fix in v1.0.1
+        # to verify if the split operation is supported (in jemalloc pool).
+        # Without bumping the tag we'd have to omit some tests.
+        default: "v1.0.1"
+
+permissions:
+  contents: read
+
+jobs:
+  ubuntu:
+    name: Ubuntu
+    runs-on: 'ubuntu-22.04'
+
+    steps:
+    - name: Install apt packages
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y clang cmake hwloc libhwloc-dev libnuma-dev libtbb-dev
+
+    - name: Checkout "tag" UMF version
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        fetch-depth: 0
+        ref: refs/tags/${{inputs.tag}}
+        path: ${{github.workspace}}/tag_version
+
+    - name: Checkout latest UMF version
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        fetch-depth: 0
+        path: ${{github.workspace}}/latest_version
+
+    - name: Configure latest UMF build
+      working-directory: ${{github.workspace}}/latest_version
+      run: >
+        cmake
+        -B ${{github.workspace}}/latest_version/build
+        -DCMAKE_INSTALL_PREFIX=_install
+        -DCMAKE_BUILD_TYPE=Debug
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DCMAKE_C_COMPILER=gcc
+        -DCMAKE_CXX_COMPILER=g++
+        -DUMF_BUILD_TESTS=OFF
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+
+    - name: Build latest UMF
+      working-directory: ${{github.workspace}}/latest_version
+      run: |
+        cmake --build ${{github.workspace}}/latest_version/build -j $(nproc)
+
+    - name: Install latest UMF
+      working-directory: ${{github.workspace}}/latest_version
+      run: sudo cmake --install ${{github.workspace}}/latest_version/build --config Debug
+
+    - name: Configure "tag" UMF build
+      working-directory: ${{github.workspace}}/tag_version
+      run: >
+        cmake
+        -B ${{github.workspace}}/tag_version/build
+        -DCMAKE_BUILD_TYPE=Debug
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DCMAKE_C_COMPILER=gcc
+        -DCMAKE_CXX_COMPILER=g++
+        -DUMF_BUILD_TESTS=ON
+        -DUMF_BUILD_EXAMPLES=ON
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+
+    - name: Build "tag" UMF
+      working-directory: ${{github.workspace}}/tag_version
+      run: |
+        cmake --build ${{github.workspace}}/tag_version/build -j $(nproc)
+
+    - name: Run "tag" UMF tests
+      working-directory: ${{github.workspace}}/tag_version/build
+      run: |
+        LD_LIBRARY_PATH=${{github.workspace}}/tag_version/build/lib/ ctest --output-on-failure
+
+    - name: Run "tag" UMF tests with latest UMF libs (warnings enabled)
+      working-directory: ${{github.workspace}}/tag_version/build
+      env:
+        UMF_LOG: level:warning;flush:debug;output:stderr;pid:no
+        LD_LIBRARY_PATH: ${{github.workspace}}/latest_version/build/lib/
+      run: |
+        ctest --verbose -E "test_memoryProvider|test_disjoint_pool"
+
+    - name: Run disabled tests individually with latest UMF libs (warnings enabled)
+      working-directory: ${{github.workspace}}/tag_version/build
+      env:
+        UMF_LOG: level:warning;flush:debug;output:stderr;pid:no
+        LD_LIBRARY_PATH: ${{github.workspace}}/latest_version/build/lib/
+      run: |
+        test/test_memoryProvider --gtest_filter="-*Trace"
+        test/test_disjoint_pool --gtest_filter="-test.internals"
+
+    # Browse all folders in the examples directory, build them using the 
+    # latest UMF version, and run them, excluding those in the exclude list.
+    - name: Build and run "tag" examples using the latest UMF libraries
+      working-directory: ${{github.workspace}}/tag_version
+      run: |  
+        EXAMPLES_EXCLUDE_LIST="cmake|common|hmat|level_zero|cuda"
+        rm -rf build
+        rm -rf include
+        mkdir _examples
+        cd _examples
+        EXAMPLES_LIST=$(find ${{github.workspace}}/tag_version/examples -maxdepth 1 -mindepth 1 -type d | grep -Ev $EXAMPLES_EXCLUDE_LIST | xargs -n 1 basename)
+        for EXAMPLE_NAME in $EXAMPLES_LIST; do
+          cd ${{github.workspace}}/tag_version
+          mkdir -p _examples/$EXAMPLE_NAME;
+          cd _examples/$EXAMPLE_NAME;
+          echo "Building example: $EXAMPLE_NAME"
+          CMAKE_PREFIX_PATH=${{github.workspace}}/latest_version/_install cmake ${{github.workspace}}/tag_version/examples/$EXAMPLE_NAME;
+          make;
+          find . -maxdepth 1 -type f -executable -exec echo "Running example: {}" \; -exec {} \;
+        done
+
+  windows:
+    name: Windows
+    env:
+      VCPKG_PATH: "${{github.workspace}}/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/vcpkg/packages/jemalloc_x64-windows"
+      VCPKG_BIN_PATH: "${{github.workspace}}/vcpkg/packages/hwloc_x64-windows/bin;${{github.workspace}}/vcpkg/packages/tbb_x64-windows/bin;${{github.workspace}}/vcpkg/packages/jemalloc_x64-windows/bin"
+    runs-on: "windows-latest"
+
+    steps:
+    - name: Checkout "tag" UMF version
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        fetch-depth: 0
+        ref: refs/tags/${{inputs.tag}}
+        path: ${{github.workspace}}/tag_version
+
+    - name: Restore vcpkg cache
+      uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+      id: cache
+      with:
+        path: vcpkg_pkgs_cache.zip
+        key: vcpkg-compat-windows-latest-${{ hashFiles('tag_version/vcpkg.json') }}
+
+    - name: Unpack vcpkg cache
+      if: steps.cache.outputs.cache-hit == 'true'
+      run: |
+        Expand-Archive -Path ${{github.workspace}}/vcpkg_pkgs_cache.zip -DestinationPath ${{github.workspace}}/vcpkg -Force
+
+    - name: Initialize vcpkg
+      if: steps.cache.outputs.cache-hit != 'true'
+      uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
+      with:
+        vcpkgGitCommitId: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
+        vcpkgDirectory: ${{github.workspace}}/vcpkg
+        vcpkgJsonGlob: '**/vcpkg.json'
+
+    # NOTE we use vcpkg setup from "tag" version
+    - name: Install dependencies
+      if: steps.cache.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}/tag_version
+      run: vcpkg install --triplet x64-windows
+
+    - name: Checkout latest UMF version
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        fetch-depth: 0
+        path: ${{github.workspace}}/latest_version
+        
+    - name: Configure latest UMF build
+      working-directory: ${{github.workspace}}/latest_version
+      run: >
+        cmake
+        -B "${{github.workspace}}/latest_version/build"
+        -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
+        -DCMAKE_INSTALL_PREFIX=_install
+        -DCMAKE_C_COMPILER=cl
+        -DCMAKE_CXX_COMPILER=cl
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DUMF_BUILD_TESTS=OFF
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+
+    - name: Build latest UMF
+      run: cmake --build "${{github.workspace}}/latest_version/build" --config Debug -j $Env:NUMBER_OF_PROCESSORS
+
+    - name: Install latest UMF
+      working-directory: ${{github.workspace}}/latest_version
+      run: cmake --install ${{github.workspace}}/latest_version/build --config Debug
+      
+    - name: Configure "tag" UMF build
+      working-directory: ${{github.workspace}}/tag_version
+      run: >
+        cmake
+        -B "${{github.workspace}}/tag_version/build"
+        -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
+        -DCMAKE_C_COMPILER=cl
+        -DCMAKE_CXX_COMPILER=cl
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DUMF_BUILD_TESTS=ON
+        -DUMF_BUILD_EXAMPLES=ON
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+
+    - name: Build "tag" UMF
+      run: cmake --build "${{github.workspace}}/tag_version/build" --config Debug -j $Env:NUMBER_OF_PROCESSORS
+
+    - name: Run "tag" UMF tests
+      working-directory: "${{github.workspace}}/tag_version/build"
+      run: ctest -C Debug --output-on-failure --test-dir test
+
+    - name: Run "tag" UMF tests with latest UMF libs (warnings enabled)
+      working-directory: ${{github.workspace}}/tag_version/build
+      env:
+        UMF_LOG: level:warning;flush:debug;output:stderr;pid:no
+      run: |
+        $env:UMF_LOG="level:warning;flush:debug;output:stderr;pid:no"
+        cp ${{github.workspace}}/latest_version/build/bin/Debug/umf.dll ${{github.workspace}}/tag_version/build/bin/Debug/umf.dll
+        ctest -C Debug --verbose -E "test_memoryProvider|test_disjoint_pool"
+        $env:Path = "${{github.workspace}}/tag_version/build/bin/Debug;${{env.VCPKG_BIN_PATH}};$env:Path"
+        test/Debug/test_memoryProvider.exe --gtest_filter="-*Trace"
+        test/Debug/test_disjoint_pool.exe --gtest_filter="-test.internals"
+
+    # Browse all folders in the examples directory, build them using the 
+    # latest UMF version, and run them, excluding those in the exclude list.
+    - name: Build and run "tag" examples using the latest UMF libraries
+      working-directory: ${{github.workspace}}/tag_version
+      run: |
+        $ErrorActionPreference = "Stop"
+        $EXAMPLES_EXCLUDE_LIST = "cmake|common|hmat|level_zero|cuda|custom|ipc|numa"
+        Set-Location "${{github.workspace}}/tag_version"
+        Remove-Item -Recurse -ErrorAction Ignore -Force build, include
+        New-Item -ItemType Directory -Path _examples
+        Set-Location -Path _examples
+        $EXAMPLES_LIST = Get-ChildItem -Path "${{github.workspace}}/tag_version/examples" -Directory | Where-Object { $_.Name -notmatch $EXAMPLES_EXCLUDE_LIST } | ForEach-Object { $_.Name }
+        # NOTE: we add our paths at the beginning of the PATH variable because 
+        # there is a limit on the size of the PATH variable in Windows
+        $env:Path = "${{github.workspace}}/latest_version/_install/bin;${{env.VCPKG_BIN_PATH}};$env:Path"
+        foreach ($EXAMPLE_NAME in $EXAMPLES_LIST) {
+          Set-Location -Path "${{github.workspace}}/tag_version"
+          New-Item -ItemType Directory -Path "_examples/$EXAMPLE_NAME"
+          Set-Location -Path "_examples/$EXAMPLE_NAME"
+          Write-Output "`nBuilding example: $EXAMPLE_NAME"
+          cmake -DCMAKE_PREFIX_PATH="${{github.workspace}}/latest_version/_install;${{env.VCPKG_PATH}}" "${{github.workspace}}/tag_version/examples/$EXAMPLE_NAME"
+          cmake --build .
+          Set-Location -Path Debug
+          Write-Output "`nRunning example: $EXAMPLE_NAME"
+          $exeFiles = Get-ChildItem -Filter *.exe
+          if ($exeFiles.Count -eq 0) {
+              Write-Error "No executable files found in the current directory."
+              exit 1
+          }
+          foreach ($exeFile in $exeFiles) {
+            Write-Output "Running: $($exeFile.FullName)"
+            & $exeFile.FullName 
+            if ($LASTEXITCODE -ne 0) {
+              $unsignedExitCode = [Convert]::ToInt32($LASTEXITCODE)
+              # Format the error code as a hexadecimal string
+              $hexErrorCode = [Convert]::ToString($unsignedExitCode, 16).ToUpper()
+              Write-Output "error 0x$hexErrorCode"
+              exit $LASTEXITCODE
+            }
+          }
+        }
+
+    - name: Prepare vcpkg cache
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: |
+        Compress-Archive -Path ${{github.workspace}}/vcpkg/packages -DestinationPath ${{github.workspace}}/vcpkg_pkgs_cache.zip -Force -CompressionLevel Fastest
+
+    - name: Save vcpkg cache
+      if: steps.cache.outputs.cache-hit != 'true'
+      uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+      with:
+        path: ${{github.workspace}}/vcpkg_pkgs_cache.zip
+        key: ${{ steps.cache.outputs.cache-primary-key }}
+
+  gpu:
+    name: GPU Ubuntu
+    # run only on upstream; forks will not have the HW
+    if: github.repository == 'oneapi-src/unified-memory-framework'
+    strategy:
+      matrix:
+        provider: ['LEVEL_ZERO', 'CUDA']
+    runs-on: ["DSS-${{matrix.provider}}", "DSS-UBUNTU"]
+
+    steps:
+    - name: Checkout latest UMF version
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        fetch-depth: 0
+        path: ${{github.workspace}}/latest_version
+
+    - name: Configure latest UMF build
+      working-directory: ${{github.workspace}}/latest_version
+      run: >
+        cmake
+        -B ${{github.workspace}}/latest_version/build
+        -DCMAKE_INSTALL_PREFIX=_install
+        -DCMAKE_BUILD_TYPE=Debug
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DCMAKE_C_COMPILER=gcc
+        -DCMAKE_CXX_COMPILER=g++
+        -DUMF_BUILD_TESTS=OFF
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=${{matrix.provider == 'LEVEL_ZERO' && 'ON' || 'OFF' }}
+        -DUMF_BUILD_CUDA_PROVIDER=${{matrix.provider == 'CUDA' && 'ON' || 'OFF' }}
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+
+    - name: Build latest UMF
+      working-directory: ${{github.workspace}}/latest_version
+      run: |
+        cmake --build ${{github.workspace}}/latest_version/build -j $(nproc)
+
+    - name: Install latest UMF
+      working-directory: ${{github.workspace}}/latest_version
+      run: cmake --install ${{github.workspace}}/latest_version/build --config Debug
+      
+    - name: Checkout "tag" UMF version
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        fetch-depth: 0
+        ref: refs/tags/${{inputs.tag}}
+        path: ${{github.workspace}}/tag_version
+
+    - name: Configure "tag" UMF build
+      working-directory: ${{github.workspace}}/tag_version
+      run: >
+        cmake
+        -B ${{github.workspace}}/tag_version/build
+        -DCMAKE_BUILD_TYPE=Debug
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DCMAKE_C_COMPILER=gcc
+        -DCMAKE_CXX_COMPILER=g++
+        -DUMF_BUILD_TESTS=ON
+        -DUMF_BUILD_GPU_TESTS=ON
+        -DUMF_BUILD_EXAMPLES=ON
+        -DUMF_BUILD_GPU_EXAMPLES=ON
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=${{matrix.provider == 'LEVEL_ZERO' && 'ON' || 'OFF' }}
+        -DUMF_BUILD_CUDA_PROVIDER=${{matrix.provider == 'CUDA' && 'ON' || 'OFF' }}
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+
+    - name: Build "tag" UMF
+      working-directory: ${{github.workspace}}/tag_version
+      run: |
+        cmake --build ${{github.workspace}}/tag_version/build -j $(nproc)
+
+    - name: Run "tag" UMF tests
+      working-directory: ${{github.workspace}}/tag_version/build
+      run: >
+        LD_LIBRARY_PATH=${{github.workspace}}/tag_version/build/lib/
+        ctest --output-on-failure
+
+    - name: Run "tag" UMF tests with latest UMF libs (warnings enabled)
+      working-directory: ${{github.workspace}}/tag_version/build
+      env:
+        UMF_LOG: level:warning;flush:debug;output:stderr;pid:no
+        LD_LIBRARY_PATH: ${{github.workspace}}/latest_version/build/lib/
+      run: |
+        ctest --verbose -E "test_memoryProvider|test_disjoint_pool"
+
+    - name: Run disabled tests individually with latest UMF libs (warnings enabled)
+      working-directory: ${{github.workspace}}/tag_version/build
+      env:
+        UMF_LOG: level:warning;flush:debug;output:stderr;pid:no
+        LD_LIBRARY_PATH: ${{github.workspace}}/latest_version/build/lib/
+      run: |
+        test/test_memoryProvider --gtest_filter="-*Trace"
+        test/test_disjoint_pool --gtest_filter="-test.internals"
+
+    # Browse all folders in the examples directory, build them using the 
+    # latest UMF version, and run them, excluding those in the exclude list.
+    # NOTE: exclude either CUDA or Level Zero examples depending on the GPU
+    - name: Build and run "tag" examples using the latest UMF libraries
+      working-directory: ${{github.workspace}}/tag_version
+      run: |  
+        EXAMPLES_EXCLUDE_LIST="cmake|common|hmat|${{matrix.provider == 'LEVEL_ZERO' && 'cuda' || 'level_zero' }}"
+        rm -rf build
+        rm -rf include
+        mkdir _examples
+        cd _examples
+        EXAMPLES_LIST=$(find ${{github.workspace}}/tag_version/examples -maxdepth 1 -mindepth 1 -type d | grep -Ev $EXAMPLES_EXCLUDE_LIST | xargs -n 1 basename)
+        for EXAMPLE_NAME in $EXAMPLES_LIST; do
+          cd ${{github.workspace}}/tag_version
+          mkdir -p _examples/$EXAMPLE_NAME;
+          cd _examples/$EXAMPLE_NAME;          
+          echo "Building example: $EXAMPLE_NAME"
+          CMAKE_PREFIX_PATH=${{github.workspace}}/latest_version/_install cmake ${{github.workspace}}/tag_version/examples/$EXAMPLE_NAME;
+          find . -maxdepth 1 -type f -executable -exec echo "Running example: {}" \; -exec {} \;
+        done
+
+# TODO add GPU windows
diff --git a/.github/workflows/reusable_coverage.yml b/.github/workflows/reusable_coverage.yml
index c8dde20ec4..a035eeab1a 100644
--- a/.github/workflows/reusable_coverage.yml
+++ b/.github/workflows/reusable_coverage.yml
@@ -22,7 +22,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
         with:
           fetch-depth: 0
 
@@ -32,7 +32,7 @@ jobs:
           sudo apt-get install -y lcov
 
       - name: Download all coverage artifacts
-        uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16 # v4.1.8
+        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
         with:
           pattern: exports-coverage-*
           path: coverage
@@ -51,7 +51,7 @@ jobs:
           echo "COV_OUT=$(tail -n1 output.txt | grep -oP "lines[.]+: [\d.]+%" | cut -d ' ' -f2 | tr -d '%')" >> $GITHUB_OUTPUT
 
       - name: Upload coverage report
-        uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808 # v4.3.3
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         with:
           name: coverage_html_report
           path: coverage/coverage_report
diff --git a/.github/workflows/reusable_dax.yml b/.github/workflows/reusable_dax.yml
index f7c5d0d21a..7dacba4e9d 100644
--- a/.github/workflows/reusable_dax.yml
+++ b/.github/workflows/reusable_dax.yml
@@ -28,21 +28,22 @@ env:
   UMF_TESTS_FSDAX_PATH: "/mnt/pmem1/file"
   UMF_TESTS_FSDAX_PATH_2: "/mnt/pmem1/file_2"
   BUILD_DIR : "${{github.workspace}}/build"
-  INSTL_DIR : "${{github.workspace}}/../install-dir"
+  INSTL_DIR : "${{github.workspace}}/install-dir"
   COVERAGE_DIR : "${{github.workspace}}/coverage"
   COVERAGE_NAME : "exports-coverage-dax"
+  DAX_TESTS: "./test/test_provider_file_memory ./test/test_provider_devdax_memory"
 
 jobs:
   dax:
-    name: Build
     # run only on upstream; forks may not have a DAX device
     if: github.repository == 'oneapi-src/unified-memory-framework'
     strategy:
       matrix:
         build_type: [Debug, Release]
         shared_library: ['ON', 'OFF']
-
+    name: DAX (ubuntu, build_type=${{matrix.build_type}}, shared_library=${{matrix.shared_library}})
     runs-on: ["DSS-DEVDAX", "DSS-Ubuntu"]
+
     steps:
       - name: Check configuration of the DEVDAX
         run: |
@@ -64,7 +65,7 @@ jobs:
           rm -f ${{env.UMF_TESTS_FSDAX_PATH}} ${{env.UMF_TESTS_FSDAX_PATH_2}}
 
       - name: Checkout
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
         with:
           fetch-depth: 0
 
@@ -83,7 +84,6 @@ jobs:
           -DUMF_BUILD_GPU_EXAMPLES=OFF
           -DUMF_FORMAT_CODE_STYLE=OFF
           -DUMF_DEVELOPER_MODE=ON
-          -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
           -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
           -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
           -DUMF_TESTS_FAIL_ON_SKIP=ON
@@ -106,8 +106,6 @@ jobs:
           UMF_TESTS_FSDAX_PATH_2=${{env.UMF_TESTS_FSDAX_PATH_2}}
           ctest -C ${{matrix.build_type}} -V -R "file|fsdax"
 
-      # TODO: enable the provider_devdax_memory_ipc test when the IPC tests with the proxy library are fixed
-      # see the issue: https://github.com/oneapi-src/unified-memory-framework/issues/864
       - name: Run the DEVDAX tests with the proxy library
         # proxy library is built only if libumf is a shared library
         if: ${{ matrix.shared_library == 'ON' }}
@@ -116,10 +114,8 @@ jobs:
           LD_PRELOAD=./lib/libumf_proxy.so
           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)"
-          ctest -C ${{matrix.build_type}} -V -R devdax -E provider_devdax_memory_ipc
+          ctest -C ${{matrix.build_type}} -V -R devdax
 
-      # TODO: enable the provider_file_memory_ipc test when the IPC tests with the proxy library are fixed
-      # see the issue: https://github.com/oneapi-src/unified-memory-framework/issues/864
       - name: Run the FSDAX tests with the proxy library
         # proxy library is built only if libumf is a shared library
         if: ${{ matrix.shared_library == 'ON' }}
@@ -128,7 +124,13 @@ jobs:
           LD_PRELOAD=./lib/libumf_proxy.so
           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}} -V -R "file|fsdax" -E provider_file_memory_ipc
+          ctest -C ${{matrix.build_type}} -V -R "file|fsdax"
+
+      - name: Run DAX tests under valgrind
+        run: |
+          ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{env.BUILD_DIR}} memcheck "${{env.DAX_TESTS}}"
+          ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{env.BUILD_DIR}} drd "${{env.DAX_TESTS}}"
+          ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{env.BUILD_DIR}} helgrind "${{env.DAX_TESTS}}"
 
       - name: Check coverage
         if:  ${{ matrix.build_type == 'Debug' }}
@@ -140,7 +142,7 @@ jobs:
           mkdir -p ${{env.COVERAGE_DIR}}
           mv ./$COVERAGE_FILE_NAME ${{env.COVERAGE_DIR}}
 
-      - uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808 # v4.3.3
+      - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         if:  ${{ matrix.build_type == 'Debug' }}
         with:
           name: ${{env.COVERAGE_NAME}}-shared-${{matrix.shared_library}}
diff --git a/.github/workflows/reusable_dockers_build.yml b/.github/workflows/reusable_dockers_build.yml
new file mode 100644
index 0000000000..c9c62a3303
--- /dev/null
+++ b/.github/workflows/reusable_dockers_build.yml
@@ -0,0 +1,46 @@
+# Build and push Docker images to GHCR
+name: BuildDockers
+
+on: 
+  workflow_call:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  packages: read
+
+jobs: 
+  build-dockers:
+    runs-on: ubuntu-latest
+    strategy: 
+      matrix:
+        os: [ubuntu-20.04, ubuntu-22.04, ubuntu-24.04]
+    env:
+      IMG: ghcr.io/bb-ur/umf-${{ matrix.os }}:latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        with:
+          fetch-depth: 0
+
+      - name: Build ${{ matrix.os }} Docker image
+        run: |
+          docker build -f .github/docker/${{ matrix.os }}.Dockerfile -t ${{ env.IMG }} .
+
+      # Login and push require login/pass to GHCR - omit these steps on forks
+      - name: Login to GitHub Container Registry
+        if: ${{ github.event_name != 'pull_request' && github.repository == 'oneapi-src/unified-memory-framework' }}
+        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        with:
+          registry: ghcr.io
+          username: bb-ur
+          password: ${{ secrets.BB_GHCR_TOKEN }}
+
+      - name: Push ${{ matrix.os }} Docker image
+        if: ${{ github.event_name != 'pull_request' && github.repository == 'oneapi-src/unified-memory-framework' }}
+        run: |
+          docker push ${{ env.IMG }}
diff --git a/.github/workflows/reusable_docs_build.yml b/.github/workflows/reusable_docs_build.yml
index 269560c674..b852e09182 100644
--- a/.github/workflows/reusable_docs_build.yml
+++ b/.github/workflows/reusable_docs_build.yml
@@ -1,6 +1,12 @@
 name: Docs build
 
-on: workflow_call
+on:
+  workflow_call:
+    inputs:
+      upload:
+        description: Should HTML documentation be uploaded as artifact?
+        type: boolean
+        default: false
 
 permissions:
   contents: read
@@ -12,7 +18,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
 
@@ -30,5 +36,48 @@ jobs:
         python3 -m pip install -r third_party/requirements.txt
 
     - name: Build the documentation
-      working-directory: scripts
-      run: python3 generate_docs.py
+      run: |
+        cmake -B build \
+          -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF \
+          -DUMF_BUILD_CUDA_PROVIDER=OFF \
+          -DUMF_BUILD_TESTS=OFF \
+          -DUMF_BUILD_EXAMPLES=OFF
+        cmake --build build --target docs
+
+    #
+    # Documentation is built. Now we want to add benchmark dashboard.
+    # We only do it if inputs.upload is set, as this job is also used for testing docs build.
+    #
+    - name: Checkout benchmark scripts
+      if: ${{ inputs.upload == true }}
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        repository: intel/llvm
+        # 30.07.2025
+        # branch: sycl
+        ref: 8f54710553800eec05a6fd9717b14f995a22b137
+        path: sc
+        sparse-checkout: |
+          devops/scripts/benchmarks
+
+    - name: Move benchmark HTML files
+      if: ${{ inputs.upload == true }}
+      working-directory: ${{ github.workspace }}/build/docs_build/generated/html
+      run: |
+        mkdir performance
+        mv ${{ github.workspace }}/sc/devops/scripts/benchmarks/html/* performance/
+
+    - name: Replace config.js
+      if: ${{ inputs.upload == true }}
+      working-directory: ${{ github.workspace }}/build/docs_build/generated/html
+      run: |
+        cat << 'EOF' > ./performance/config.js
+        remoteDataUrl = 'https://raw.githubusercontent.com/oneapi-src/unified-memory-framework/refs/heads/benchmark-results/';
+        defaultCompareNames = ["Baseline_PVC"];
+        EOF
+
+    - name: Upload artifact
+      if: ${{ inputs.upload == true }}
+      uses: actions/upload-pages-artifact@7b1f4a764d45c48632c6b24a0339c27f5614fb0b # v4.0.0
+      with:
+        path: build/docs_build/generated/html
diff --git a/.github/workflows/reusable_fast.yml b/.github/workflows/reusable_fast.yml
index e25de68a1b..3bba141312 100644
--- a/.github/workflows/reusable_fast.yml
+++ b/.github/workflows/reusable_fast.yml
@@ -1,96 +1,136 @@
-# Fast builds
+# Fast build linux part is working in dockers, Windows is not
 name: FastBuild
 
 on: workflow_call
 
 permissions:
   contents: read
+  packages: read
 
 env:
   BUILD_DIR : "${{github.workspace}}/build"
-  INSTL_DIR : "${{github.workspace}}/../install-dir"
+  INSTL_DIR : "${{github.workspace}}/install-dir"
 
 jobs:
-  FastBuild:
-    name: Fast builds
-    env:
-      VCPKG_PATH: "${{github.workspace}}/build/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows"
+  ubuntu-build:
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/bb-ur/umf-${{ matrix.os }}:latest
+      options: --user test_user --cap-add=SYS_NICE --cap-add=SYS_PTRACE
+      volumes:
+        - ${{ github.workspace }}:${{ github.workspace }}
     strategy:
       matrix:
         include:
-          - os: windows-latest
-            disjoint: 'OFF'
-            build_tests: 'ON'
-            simple_cmake: 'OFF'
-          # pure C build (Windows)
-          - os: windows-latest
-            disjoint: 'OFF'
-            # Tests' building is off for a pure C build
-            build_tests: 'OFF'
-            simple_cmake: 'OFF'
-          - os: ubuntu-latest
-            disjoint: 'ON'
+          - os: ubuntu-24.04
             build_tests: 'ON'
-            # Windows doesn't recognize 'CMAKE_BUILD_TYPE', it uses '--config' param in build command
-            extra_build_options: '-DCMAKE_BUILD_TYPE=Release -DUMF_BUILD_BENCHMARKS=ON -DUMF_BUILD_BENCHMARKS_MT=ON'
+            extra_build_options: ' -DUMF_BUILD_BENCHMARKS=ON -DUMF_BUILD_BENCHMARKS_MT=ON'
             simple_cmake: 'OFF'
-          # pure C build (Linux)
-          - os: ubuntu-latest
-            disjoint: 'OFF'
-            # Windows doesn't recognize 'CMAKE_BUILD_TYPE', it uses '--config' param in build command
+          # pure C build
+          - os: ubuntu-24.04
             # Tests' building is off for a pure C build
             build_tests: 'OFF'
-            extra_build_options: '-DCMAKE_BUILD_TYPE=Release -DUMF_BUILD_BENCHMARKS=ON'
+            extra_build_options: '-DUMF_BUILD_BENCHMARKS=ON'
             simple_cmake: 'OFF'
-          # simplest CMake on ubuntu-latest
-          - os: ubuntu-latest
-            disjoint: 'OFF'
+          # simplest CMake on Ubuntu 22.04, 24.04
+          - os: ubuntu-24.04
             build_tests: 'ON'
-            extra_build_options: '-DCMAKE_BUILD_TYPE=Release'
             simple_cmake: 'ON'
-          # simplest CMake ubuntu-20.04
-          - os: ubuntu-20.04
-            disjoint: 'OFF'
+          - os: ubuntu-22.04
             build_tests: 'ON'
-            extra_build_options: '-DCMAKE_BUILD_TYPE=Release'
             simple_cmake: 'ON'
-    runs-on: ${{ (matrix.os == 'ubuntu-latest' && github.repository_owner == 'oneapi-src') && 'intel-ubuntu-22.04' || matrix.os }}
+    name: Fast (${{matrix.os}}, build_tests=${{matrix.build_tests}}, simple_cmake=${{matrix.simple_cmake}}, extra_build_options=${{matrix.extra_build_options}})
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
 
-    - name: Initialize vcpkg
-      if: matrix.os == 'windows-latest'
-      uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
+    - name: Configure CMake
+      if: matrix.simple_cmake == 'OFF'
+      run: >
+        cmake
+        -B ${{env.BUILD_DIR}}
+        -DCMAKE_BUILD_TYPE=Release
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+        -DUMF_BUILD_TESTS=${{matrix.build_tests}}
+        -DUMF_BUILD_EXAMPLES=ON
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        ${{matrix.extra_build_options}}
+
+    - name: Configure CMake (simple)
+      if: matrix.simple_cmake == 'ON'
+      run: >
+        cmake
+        -B ${{env.BUILD_DIR}}
+        -DCMAKE_BUILD_TYPE=Release
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+        ${{matrix.extra_build_options}}
+
+    - name: Build
+      run: cmake --build ${{env.BUILD_DIR}} --config Release -j $(nproc)
+
+    - name: Run examples
+      working-directory: ${{env.BUILD_DIR}}
+      run: ctest --output-on-failure --test-dir examples -C Release
+
+    - name: Run tests
+      if: matrix.build_tests == 'ON'
+      working-directory: ${{env.BUILD_DIR}}
+      run: ctest --output-on-failure --test-dir test -C Release
+
+  # TODO: use dockers
+  windows-build:
+    runs-on: windows-latest 
+    env:
+      VCPKG_PATH: "${{github.workspace}}/build/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows"
+    strategy:
+      matrix:
+        include:
+          - build_tests: 'ON'
+            simple_cmake: 'OFF'
+          - build_tests: 'OFF'
+            simple_cmake: 'OFF'
+          - build_tests: 'OFF'
+            simple_cmake: 'ON'
+    name: Fast (windows-latest, build_tests=${{matrix.build_tests}}, simple_cmake=${{matrix.simple_cmake}})
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
-        vcpkgGitCommitId: 3dd44b931481d7a8e9ba412621fa810232b66289
-        vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
-        vcpkgJsonGlob: '**/vcpkg.json'
+        fetch-depth: 0
 
-    - name: Install dependencies (windows-latest)
-      if: matrix.os == 'windows-latest'
-      run: vcpkg install
-      shell: pwsh # Specifies PowerShell as the shell for running the script.
+    - name: Restore vcpkg cache
+      uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+      id: cache
+      with:
+        path: vcpkg_pkgs_cache.zip
+        key: vcpkg-fast-windows-latest-${{ hashFiles('vcpkg.json') }}
 
-    - name: Install dependencies (ubuntu-latest)
-      if: matrix.os == 'ubuntu-latest'
+    - name: Unpack vcpkg cache
+      if: steps.cache.outputs.cache-hit == 'true'
       run: |
-        sudo apt-get update
-        sudo apt-get install -y cmake libjemalloc-dev libhwloc-dev libnuma-dev libtbb-dev
+        Expand-Archive -Path ${{github.workspace}}/vcpkg_pkgs_cache.zip -DestinationPath ${{env.BUILD_DIR}}/vcpkg -Force
 
-    - name: Install dependencies (ubuntu-20.04)
-      if: matrix.os == 'ubuntu-20.04'
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y cmake libjemalloc-dev libnuma-dev libtbb-dev
-        .github/scripts/install_hwloc.sh # install hwloc-2.3.0 instead of hwloc-2.1.0 present in the OS package
+    - name: Initialize vcpkg
+      if: steps.cache.outputs.cache-hit != 'true'
+      uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
+      with:
+        vcpkgGitCommitId: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
+        vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
+        vcpkgJsonGlob: '**/vcpkg.json'
 
-    - name: Set ptrace value for IPC test (on Linux only)
-      if: ${{ matrix.os == 'ubuntu-latest' || matrix.os == 'ubuntu-20.04' }}
-      run: sudo bash -c "echo 0 > /proc/sys/kernel/yama/ptrace_scope"
+    - name: Install dependencies
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: vcpkg install --triplet x64-windows
 
     - name: Configure CMake
       if: matrix.simple_cmake == 'OFF'
@@ -101,7 +141,6 @@ jobs:
         -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
         -DUMF_FORMAT_CODE_STYLE=OFF
         -DUMF_DEVELOPER_MODE=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=${{matrix.disjoint}}
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
         -DUMF_BUILD_TESTS=${{matrix.build_tests}}
         -DUMF_BUILD_EXAMPLES=ON
@@ -109,7 +148,6 @@ jobs:
         -DUMF_BUILD_CUDA_PROVIDER=ON
         -DUMF_TESTS_FAIL_ON_SKIP=ON
         -DUMF_BUILD_SHARED_LIBRARY=ON
-        ${{matrix.extra_build_options}}
 
     - name: Configure CMake (simple)
       if: matrix.simple_cmake == 'ON'
@@ -117,9 +155,9 @@ jobs:
         cmake
         -B ${{env.BUILD_DIR}}
         -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
+        -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
         -DUMF_BUILD_SHARED_LIBRARY=ON
         -DUMF_TESTS_FAIL_ON_SKIP=ON
-        ${{matrix.extra_build_options}}
 
     - name: Build
       run: cmake --build ${{env.BUILD_DIR}} --config Release -j
@@ -136,7 +174,18 @@ jobs:
     # TODO: We could add some script to verify metadata of dll's (selected fields, perhaps)
     # ref. https://superuser.com/questions/381276/what-are-some-nice-command-line-ways-to-inspect-dll-exe-details
     - name: Print metadata of our dll's
-      if: matrix.os == 'windows-latest'
       run: |
         get-command ${{github.workspace}}/build/bin/Release/umf.dll | format-list
         get-command ${{github.workspace}}/build/src/proxy_lib/Release/umf_proxy.dll | format-list
+
+    - name: Prepare vcpkg cache
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: |
+        Compress-Archive -Path ${{env.BUILD_DIR}}/vcpkg/packages -DestinationPath ${{github.workspace}}/vcpkg_pkgs_cache.zip -Force -CompressionLevel Fastest
+
+    - name: Save vcpkg cache
+      if: steps.cache.outputs.cache-hit != 'true'
+      uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+      with:
+        path: ${{github.workspace}}/vcpkg_pkgs_cache.zip
+        key: ${{ steps.cache.outputs.cache-primary-key }}
diff --git a/.github/workflows/reusable_gpu.yml b/.github/workflows/reusable_gpu.yml
index 913a0f0f18..38f2cf53ec 100644
--- a/.github/workflows/reusable_gpu.yml
+++ b/.github/workflows/reusable_gpu.yml
@@ -5,18 +5,18 @@ name: GPU
 on:
   workflow_call:
     inputs:
-      name:
+      provider:
         description: Provider name
         type: string
         required: true
+      runner:
+        description: Runner name (without 'DSS-' prefix)
+        type: string
+        required: true
       os:
         description: A list of OSes
         type: string
         default: "['Ubuntu', 'Windows']"
-      build_type:
-        description: A list of build types
-        type: string
-        default: "['Debug', 'Release']"
       shared_lib:
         description: A list of options for building shared library
         type: string
@@ -26,17 +26,17 @@ permissions:
   contents: read
 
 env:
-  BUILD_DIR : "${{github.workspace}}/build"
-  INSTL_DIR : "${{github.workspace}}/../install-dir"
+  BUILD_DEBUG_DIR : "${{github.workspace}}/debug/build"
+  BUILD_RELEASE_DIR : "${{github.workspace}}/release/build"
+  INSTL_DEBUG_DIR : "${{github.workspace}}/debug/install-dir"
+  INSTL_RELEASE_DIR : "${{github.workspace}}/release/install-dir"
   COVERAGE_DIR : "${{github.workspace}}/coverage"
 
 jobs:
   gpu:
-    name: "${{matrix.os}}, ${{matrix.build_type}}, shared=${{matrix.shared_library}}"
     env:
-      VCPKG_PATH: "${{github.workspace}}/build/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows;"
-      CUDA_PATH: "C:/cuda"
-      COVERAGE_NAME : "exports-coverage-${{inputs.name}}"
+      VCPKG_PATH: "${{github.workspace}}/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/vcpkg/packages/jemalloc_x64-windows;"
+      COVERAGE_NAME : "exports-coverage-${{inputs.provider}}-${{inputs.runner}}"
     # run only on upstream; forks will not have the HW
     if: github.repository == 'oneapi-src/unified-memory-framework'
     strategy:
@@ -44,90 +44,160 @@ jobs:
       matrix:
         shared_library: ${{ fromJSON(inputs.shared_lib)}}
         os: ${{ fromJSON(inputs.os)}}
-        build_type: ${{ fromJSON(inputs.build_type)}}
-        include:
-          - os: 'Ubuntu'
-            compiler: {c: gcc, cxx: g++}
-            number_of_processors: '$(nproc)'
-          - os: 'Windows'
-            compiler: {c: cl, cxx: cl}
-            number_of_processors: '$Env:NUMBER_OF_PROCESSORS'
-
-    runs-on: ["DSS-${{inputs.name}}", "DSS-${{matrix.os}}"]
+    name: GPU (${{matrix.os}}, shared=${{matrix.shared_library}})
+    runs-on: ["DSS-${{inputs.runner}}", "DSS-${{matrix.os}}"]
+
     steps:
+      # Set various build params based on OS
+      - name: "[Win] Establish build params"
+        if : ${{ matrix.os == 'Windows' }}
+        run: |
+          echo "C_COMPILER=cl" >> $env:GITHUB_ENV
+          echo "CXX_COMPILER=cl" >> $env:GITHUB_ENV
+          echo "PROCS=$Env:NUMBER_OF_PROCESSORS" >> $env:GITHUB_ENV
+          echo "EXTRA_CMAKE_PATH=$Env:CUDA_PATH" >> $env:GITHUB_ENV
+
+      - name: "[Lin] Establish build params"
+        if : ${{ matrix.os == 'Ubuntu' }}
+        run: |
+          echo "C_COMPILER=gcc" >> $GITHUB_ENV
+          echo "CXX_COMPILER=g++" >> $GITHUB_ENV
+          echo "PROCS=$(nproc)" >> $GITHUB_ENV
+
       - name: Checkout
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
         with:
           fetch-depth: 0
 
-      - name: Get information about platform
+      - name: "[Lin] Get information about platform"
         if: matrix.os == 'Ubuntu'
         run: .github/scripts/get_system_info.sh
 
-      - name: "[Win] Initialize vcpkg"
+      - name: "[Win] Restore vcpkg cache"
         if: matrix.os == 'Windows'
+        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        id: cache
+        with:
+          path: vcpkg_pkgs_cache.zip
+          key: vcpkg-gpu-${{inputs.runner}}-windows-${{ hashFiles('vcpkg.json') }}
+
+      - name: "[Win] Unpack vcpkg cache"
+        if: matrix.os == 'Windows' && steps.cache.outputs.cache-hit == 'true'
+        run: |
+          Expand-Archive -Path ${{github.workspace}}/vcpkg_pkgs_cache.zip -DestinationPath ${{github.workspace}}/vcpkg -Force
+
+      - name: "[Win] Initialize vcpkg"
+        if: matrix.os == 'Windows' && steps.cache.outputs.cache-hit != 'true'
         uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
         with:
-          vcpkgGitCommitId: 3dd44b931481d7a8e9ba412621fa810232b66289
-          vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
+          vcpkgGitCommitId: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
+          vcpkgDirectory: ${{github.workspace}}/vcpkg
           vcpkgJsonGlob: '**/vcpkg.json'
 
       - name: "[Win] Install dependencies"
-        if: matrix.os == 'Windows'
-        run: vcpkg install
+        if: matrix.os == 'Windows' && steps.cache.outputs.cache-hit != 'true'
+        run: vcpkg install --triplet x64-windows
 
       # note: disable all providers except the one being tested
-      - name: Configure build
+      # '-DCMAKE_SUPPRESS_REGENERATION=ON' is the WA for the error: "CUSTOMBUILD : CMake error : Cannot restore timestamp"
+      - name: Configure build (Debug)
         run: >
           cmake
-          -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}${{env.CUDA_PATH}}"
-          -B ${{env.BUILD_DIR}}
-          -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
-          -DCMAKE_BUILD_TYPE=${{matrix.build_type}}
-          -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
-          -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
+          -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}};${{env.EXTRA_CMAKE_PATH}}"
+          -B ${{env.BUILD_DEBUG_DIR}}
+          -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DEBUG_DIR}}"
+          -DCMAKE_BUILD_TYPE=Debug
+          -DCMAKE_C_COMPILER=${{env.C_COMPILER}}
+          -DCMAKE_CXX_COMPILER=${{env.CXX_COMPILER}}
           -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}}
           -DUMF_BUILD_BENCHMARKS=ON
+          -DUMF_BUILD_BENCHMARKS_MT=ON
           -DUMF_BUILD_TESTS=ON
           -DUMF_BUILD_GPU_TESTS=ON
           -DUMF_BUILD_GPU_EXAMPLES=ON
           -DUMF_DEVELOPER_MODE=ON
-          -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
           -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
           -DUMF_BUILD_CUDA_PROVIDER=OFF
           -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
-          -DUMF_BUILD_${{inputs.name}}_PROVIDER=ON
+          -DUMF_BUILD_${{inputs.provider}}_PROVIDER=ON
           -DUMF_TESTS_FAIL_ON_SKIP=ON
-          ${{ matrix.os == 'Ubuntu' && matrix.build_type == 'Debug' && '-DUMF_USE_COVERAGE=ON' || '' }}
+          ${{ matrix.os == 'Ubuntu' && '-DUMF_USE_COVERAGE=ON' || '' }}
+          ${{ matrix.os == 'Windows' && '-DCMAKE_SUPPRESS_REGENERATION=ON' || '' }}
 
-      - name: Build UMF
-        run: cmake --build ${{env.BUILD_DIR}} --config ${{matrix.build_type}} -j ${{matrix.number_of_processors}}
+      - name: Build UMF (Debug)
+        run: cmake --build ${{env.BUILD_DEBUG_DIR}} --config Debug -j ${{env.PROCS}}
 
-      - name: Run tests
-        working-directory: ${{env.BUILD_DIR}}
-        run: ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
+      - name: Run tests (Debug)
+        working-directory: ${{env.BUILD_DEBUG_DIR}}
+        run: ctest -C Debug --output-on-failure --test-dir test
 
-      - name: Run examples
-        working-directory: ${{env.BUILD_DIR}}
-        run: ctest --output-on-failure --test-dir examples -C ${{matrix.build_type}}
+      - name: Run examples (Debug)
+        working-directory: ${{env.BUILD_DEBUG_DIR}}
+        run: ctest --output-on-failure --test-dir examples -C Debug
 
-      - name: Run benchmarks
-        if: matrix.build_type == 'Release'
-        working-directory: ${{env.BUILD_DIR}}
-        run: ctest --output-on-failure --test-dir benchmark -C ${{matrix.build_type}} --exclude-regex umf-bench-multithreaded
+      - name: Configure build (Release)
+        run: >
+          cmake
+          -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}};${{env.EXTRA_CMAKE_PATH}}"
+          -B ${{env.BUILD_RELEASE_DIR}}
+          -DCMAKE_INSTALL_PREFIX="${{env.INSTL_RELEASE_DIR}}"
+          -DCMAKE_BUILD_TYPE=Release
+          -DCMAKE_C_COMPILER=${{env.C_COMPILER}}
+          -DCMAKE_CXX_COMPILER=${{env.CXX_COMPILER}}
+          -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}}
+          -DUMF_BUILD_BENCHMARKS=ON
+          -DUMF_BUILD_BENCHMARKS_MT=ON
+          -DUMF_BUILD_TESTS=ON
+          -DUMF_BUILD_GPU_TESTS=ON
+          -DUMF_BUILD_GPU_EXAMPLES=ON
+          -DUMF_DEVELOPER_MODE=ON
+          -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+          -DUMF_BUILD_CUDA_PROVIDER=OFF
+          -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
+          -DUMF_BUILD_${{inputs.provider}}_PROVIDER=ON
+          -DUMF_TESTS_FAIL_ON_SKIP=ON
+          ${{ matrix.os == 'Windows' && '-DCMAKE_SUPPRESS_REGENERATION=ON' || '' }}
 
-      - name: Check coverage
-        if: ${{ matrix.build_type == 'Debug' && matrix.os == 'Ubuntu' }}
-        working-directory: ${{env.BUILD_DIR}}
+      - name: Build UMF (Release)
+        run: cmake --build ${{env.BUILD_RELEASE_DIR}} --config Release -j ${{env.PROCS}}
+
+      - name: Run tests (Release)
+        working-directory: ${{env.BUILD_RELEASE_DIR}}
+        run: ctest -C Release --output-on-failure --test-dir test
+
+      - name: Run examples (Release)
+        working-directory: ${{env.BUILD_RELEASE_DIR}}
+        run: ctest --output-on-failure --test-dir examples -C Release
+
+      - name: Run benchmarks (Release)
+        working-directory: ${{env.BUILD_RELEASE_DIR}}
+        run: ctest --output-on-failure --test-dir benchmark -C Release --exclude-regex umf-multithreaded
+
+      - name: "[Lin] Check coverage (Debug)"
+        if: ${{ matrix.os == 'Ubuntu' }}
+        working-directory: ${{env.BUILD_DEBUG_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
+          ${{github.workspace}}/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' && matrix.os == 'Ubuntu' }}
+      - name: "[Lin] Upload coverage"
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        if: ${{ matrix.os == 'Ubuntu' }}
         with:
           name: ${{env.COVERAGE_NAME}}-shared-${{matrix.shared_library}}
           path: ${{env.COVERAGE_DIR}}
+
+      - name: "[Win] Prepare vcpkg cache"
+        if: matrix.os == 'Windows' && steps.cache.outputs.cache-hit != 'true'
+        run: |
+          Compress-Archive -Path ${{github.workspace}}/vcpkg/packages -DestinationPath ${{github.workspace}}/vcpkg_pkgs_cache.zip -Force -CompressionLevel Fastest
+
+      - name: "[Win] Save vcpkg cache"
+        if: matrix.os == 'Windows' && steps.cache.outputs.cache-hit != 'true'
+        uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        with:
+          path: ${{github.workspace}}/vcpkg_pkgs_cache.zip
+          key: ${{ steps.cache.outputs.cache-primary-key }}
diff --git a/.github/workflows/reusable_multi_numa.yml b/.github/workflows/reusable_multi_numa.yml
index 8b30ed53ed..86ed771751 100644
--- a/.github/workflows/reusable_multi_numa.yml
+++ b/.github/workflows/reusable_multi_numa.yml
@@ -1,4 +1,4 @@
-# Runs tests on multi-numa machine
+# Runs tests on multi-numa machines
 name: MultiNuma
 
 on: [workflow_call]
@@ -10,29 +10,26 @@ env:
   BUILD_DIR : "${{github.workspace}}/build"
   COVERAGE_DIR : "${{github.workspace}}/coverage"
   COVERAGE_NAME : "exports-coverage-multinuma"
+  NUMA_TESTS: "./test/test_memspace_numa ./test/test_provider_os_memory_multiple_numa_nodes"
 
 jobs:
   multi_numa:
-    name: "${{matrix.os}}, ${{matrix.build_type}}, shared=${{matrix.shared_library}}"
     # run only on upstream; forks will not have the HW
     if: github.repository == 'oneapi-src/unified-memory-framework'
-
     strategy:
       matrix:
-        os: [ubuntu-22.04, rhel-9.1]
+        os: [ubuntu-22.04, rhel-9.1, sles-15]
         build_type: [Debug, Release]
         shared_library: ['ON', 'OFF']
+    name: Multi NUMA (${{matrix.os}}, build_type=${{matrix.build_type}}, shared=${{matrix.shared_library}})
     runs-on:  ["DSS-MULTI-NUMA", "DSS-${{matrix.os}}"]
 
     steps:
       - name: Checkout
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
         with:
           fetch-depth: 0
 
-      - name: Get information about platform
-        run: .github/scripts/get_system_info.sh
-
       - name: Configure build
         run: >
           cmake
@@ -44,8 +41,7 @@ jobs:
           -DUMF_BUILD_BENCHMARKS=OFF
           -DUMF_BUILD_TESTS=ON
           -DUMF_DEVELOPER_MODE=ON
-          -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
-          -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+          -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=${{ matrix.os == 'rhel-9.1' && 'OFF' || 'ON' }}
           -DUMF_TESTS_FAIL_ON_SKIP=ON
           ${{ matrix.build_type == 'Debug' && matrix.os == 'ubuntu-22.04' && '-DUMF_USE_COVERAGE=ON' || '' }}
 
@@ -53,21 +49,28 @@ jobs:
         run: cmake --build ${{github.workspace}}/build -j $(nproc)
 
       - name: Run tests
-        if: matrix.os != 'rhel-9.1'
+        if: (matrix.os != 'rhel-9.1') && (matrix.os != 'sles-15')
         working-directory: ${{github.workspace}}/build
         run: ctest --output-on-failure --test-dir test
 
-        # On RHEL, hwloc version is just a little too low.
+        # On RHEL/SLES, hwloc version is just a little too low.
         # Skip some tests until we upgrade hwloc and update CMake to properly handle local hwloc installation.
         # TODO: fix issue #560
-      - name: Run tests (on RHEL)
-        if: matrix.os == 'rhel-9.1'
+      - name: Run tests (on RHEL/SLES)
+        if: (matrix.os == 'rhel-9.1') || (matrix.os == 'sles-15')
         working-directory: ${{github.workspace}}/build
         run: |
-          ctest --output-on-failure --test-dir test -E "umf-provider_os_memory_multiple_numa_nodes"
-          ./test/umf_test-provider_os_memory_multiple_numa_nodes \
+          ctest --output-on-failure --test-dir test -E "test_provider_os_memory_multiple_numa_nodes"
+          ./test/test_provider_os_memory_multiple_numa_nodes \
             --gtest_filter="-*checkModeLocal/*:*checkModePreferredEmptyNodeset/*:testNuma.checkModeInterleave"
 
+      - name: Run NUMA tests under valgrind
+        if: (matrix.os != 'rhel-9.1') && (matrix.os != 'sles-15')
+        run: |
+          ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{env.BUILD_DIR}} memcheck "${{env.NUMA_TESTS}}"
+          ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{env.BUILD_DIR}} drd "${{env.NUMA_TESTS}}"
+          ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{env.BUILD_DIR}} helgrind "${{env.NUMA_TESTS}}"
+
       - name: Check coverage
         if: ${{ matrix.build_type == 'Debug' && matrix.os == 'ubuntu-22.04' }}
         working-directory: ${{env.BUILD_DIR}}
@@ -78,8 +81,12 @@ jobs:
           mkdir -p ${{env.COVERAGE_DIR}}
           mv ./$COVERAGE_FILE_NAME ${{env.COVERAGE_DIR}}
 
-      - uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808 # v4.3.3
+      - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         if: ${{ matrix.build_type == 'Debug' && matrix.os == 'ubuntu-22.04' }}
         with:
           name: ${{env.COVERAGE_NAME}}-${{matrix.os}}-shared-${{matrix.shared_library}}
           path: ${{env.COVERAGE_DIR}}
+
+      - name: Get information about platform
+        if: always()
+        run: .github/scripts/get_system_info.sh
diff --git a/.github/workflows/reusable_proxy_lib.yml b/.github/workflows/reusable_proxy_lib.yml
index 2a27161b3e..c09f18ef02 100644
--- a/.github/workflows/reusable_proxy_lib.yml
+++ b/.github/workflows/reusable_proxy_lib.yml
@@ -8,34 +8,30 @@ permissions:
 
 env:
   BUILD_DIR : "${{github.workspace}}/build"
-  INSTL_DIR : "${{github.workspace}}/../install-dir"
+  INSTL_DIR : "${{github.workspace}}/install-dir"
   COVERAGE_DIR : "${{github.workspace}}/coverage"
   COVERAGE_NAME : "exports-coverage-proxy"
 
 jobs:
   proxy-ubuntu:
-    name: Ubuntu
-
     strategy:
       matrix:
         build_type: [Release, Debug]
         compiler: [{c: gcc, cxx: g++}]
         proxy_lib_pool: ['SCALABLE', 'JEMALLOC']
+    name: Proxy Library (ubuntu-22.04, build_type=${{matrix.build_type}}, compilers=${{matrix.compiler.c}}/${{matrix.compiler.cxx}}, proxy_lib_pool=${{matrix.proxy_lib_pool}})
     runs-on: ${{ github.repository_owner == 'oneapi-src' && 'intel-ubuntu-22.04' || 'ubuntu-22.04' }}
 
     steps:
       - name: Checkout
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
         with:
           fetch-depth: 0
 
       - name: Install apt packages
         run: |
           sudo apt-get update
-          sudo apt-get install -y cmake libhwloc-dev libjemalloc-dev libtbb-dev lcov
-
-      - name: Set ptrace value for IPC test
-        run: sudo bash -c "echo 0 > /proc/sys/kernel/yama/ptrace_scope"
+          sudo apt-get install -y cmake libhwloc-dev libnuma-dev libtbb-dev lcov
 
       - name: Configure build
         run: >
@@ -49,9 +45,8 @@ jobs:
           -DUMF_BUILD_BENCHMARKS=OFF
           -DUMF_BUILD_TESTS=ON
           -DUMF_FORMAT_CODE_STYLE=OFF
-          -DUMF_DEVELOPER_MODE=OFF
+          -DUMF_DEVELOPER_MODE=ON
           -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
-          -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
           -DUMF_TESTS_FAIL_ON_SKIP=ON
           -DUMF_PROXY_LIB_BASED_ON_POOL=${{matrix.proxy_lib_pool}}
           ${{ matrix.build_type == 'Debug' && '-DUMF_USE_COVERAGE=ON' || '' }}
@@ -59,15 +54,13 @@ jobs:
       - name: Build UMF
         run: cmake --build ${{env.BUILD_DIR}} -j $(nproc)
 
-      # TODO enable the provider_file_memory_ipc test when the IPC tests with the proxy library are fixed
-      # see the issue: https://github.com/oneapi-src/unified-memory-framework/issues/864
       - name: Run "ctest --output-on-failure" with proxy library
         working-directory: ${{env.BUILD_DIR}}
-        run: LD_PRELOAD=./lib/libumf_proxy.so ctest --output-on-failure -E provider_file_memory_ipc
+        run: LD_PRELOAD=./lib/libumf_proxy.so ctest --output-on-failure
 
-      - name: Run "./test/umf_test-memoryPool" with proxy library
+      - name: Run "./test/test_memoryPool" with proxy library
         working-directory: ${{env.BUILD_DIR}}
-        run: LD_PRELOAD=./lib/libumf_proxy.so ./test/umf_test-memoryPool
+        run: LD_PRELOAD=./lib/libumf_proxy.so ./test/test_memoryPool
 
       - name: Run "/usr/bin/ls" with proxy library
         working-directory: ${{env.BUILD_DIR}}
@@ -77,14 +70,12 @@ jobs:
         working-directory: ${{env.BUILD_DIR}}
         run: UMF_PROXY="page.disposition=shared-shm" LD_PRELOAD=./lib/libumf_proxy.so /usr/bin/date
 
-      # TODO enable the provider_file_memory_ipc test when the IPC tests with the proxy library are fixed
-      # see the issue: https://github.com/oneapi-src/unified-memory-framework/issues/864
       - name: Run "ctest --output-on-failure" with proxy library and size.threshold=128
         working-directory: ${{env.BUILD_DIR}}
         run: >
           UMF_PROXY="page.disposition=shared-shm;size.threshold=128"
           LD_PRELOAD=./lib/libumf_proxy.so
-          ctest --output-on-failure -E provider_file_memory_ipc
+          ctest --output-on-failure
 
       - name: Check coverage
         if:  ${{ matrix.build_type == 'Debug' }}
@@ -96,7 +87,7 @@ jobs:
           mkdir -p ${{env.COVERAGE_DIR}}
           mv ./$COVERAGE_FILE_NAME ${{env.COVERAGE_DIR}}
 
-      - uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808 # v4.3.3
+      - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         if:  ${{ matrix.build_type == 'Debug' }}
         with:
           name: ${{env.COVERAGE_NAME}}-proxy_lib_pool-${{matrix.proxy_lib_pool}}
diff --git a/.github/workflows/reusable_qemu.yml b/.github/workflows/reusable_qemu.yml
index 257e90f628..9ba9c3994f 100644
--- a/.github/workflows/reusable_qemu.yml
+++ b/.github/workflows/reusable_qemu.yml
@@ -18,17 +18,17 @@ permissions:
 
 jobs:
   qemu-build:
-    name: QEMU
     strategy:
       matrix:
         os: ${{ fromJson(inputs.os) }}
+    name: QEMU (${{ matrix.os }})
 
     # Host QEMU on any Linux platform
     runs-on: ubuntu-22.04
 
     steps:
     - name: Checkout UMF
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
         path: umf
@@ -98,7 +98,7 @@ jobs:
       if: ${{ inputs.short_run == true }}
       run: |
         echo "SHORT_RUN=true" >> $GITHUB_ENV
-        declare -a short_configs=("default.xml" "sock_2_var3.xml" "sock_4_var1_hmat.xml")
+        declare -a short_configs=("default.xml" "sock_2_var3.xml" "sock_8_var1_hmat.xml")
         echo "CONFIG_OPTIONS=${short_configs[@]}" >> $GITHUB_ENV
 
     - name: Set vars if long run
@@ -149,7 +149,7 @@ jobs:
         done
         ls -al ./coverage
 
-    - uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808 # v4.3.3
+    - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
       with:
         name: exports-coverage-qemu-${{matrix.os}}
         path: coverage
diff --git a/.github/workflows/reusable_sanitizers.yml b/.github/workflows/reusable_sanitizers.yml
index 3acda6833e..a08ce2ccac 100644
--- a/.github/workflows/reusable_sanitizers.yml
+++ b/.github/workflows/reusable_sanitizers.yml
@@ -5,31 +5,31 @@ on: workflow_call
 
 env:
   BUILD_DIR : "${{github.workspace}}/build"
-  INSTL_DIR : "${{github.workspace}}/../install-dir"
+  INSTL_DIR : "${{github.workspace}}/install-dir"
 
 permissions:
   contents: read
 
 jobs:
   ubuntu-build:
-    name: Ubuntu
     strategy:
       matrix:
         compiler: [{c: gcc, cxx: g++}, {c: clang, cxx: clang++}, {c: icx, cxx: icpx}]
         # TSAN is mutually exclusive with other sanitizers
         sanitizers: [{asan: ON, ubsan: ON, tsan: OFF}, {asan: OFF, ubsan: OFF, tsan: ON}]
+    name: Sanitizers (ubuntu-22.04, compilers=${{matrix.compiler.c}}/${{matrix.compiler.cxx}}, asan=${{matrix.sanitizers.asan}}, ubsan=${{matrix.sanitizers.ubsan}}, tsan=${{matrix.sanitizers.tsan}})
     runs-on: ubuntu-22.04
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
 
     - name: Install apt packages
       run: |
         sudo apt-get update
-        sudo apt-get install -y clang cmake libhwloc-dev libnuma-dev libjemalloc-dev libtbb-dev
+        sudo apt-get install -y clang cmake libhwloc-dev libnuma-dev libtbb-dev
 
     - name: Install oneAPI basekit
       if: matrix.compiler.cxx == 'icpx'
@@ -40,10 +40,6 @@ jobs:
         sudo apt-get update
         sudo apt-get install -y intel-oneapi-ippcp-devel intel-oneapi-ipp-devel intel-oneapi-common-oneapi-vars intel-oneapi-compiler-dpcpp-cpp
 
-
-    - name: Set ptrace value for IPC test
-      run: sudo bash -c "echo 0 > /proc/sys/kernel/yama/ptrace_scope"
-
     - name: Configure build
       run: >
         ${{ matrix.compiler.cxx == 'icpx' && '. /opt/intel/oneapi/setvars.sh &&' || ''}} 
@@ -57,9 +53,8 @@ jobs:
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
         -DUMF_BUILD_CUDA_PROVIDER=ON
         -DUMF_FORMAT_CODE_STYLE=OFF
-        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_DEVELOPER_MODE=OFF
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
         -DUMF_USE_ASAN=${{matrix.sanitizers.asan}}
         -DUMF_USE_UBSAN=${{matrix.sanitizers.ubsan}}
         -DUMF_USE_TSAN=${{matrix.sanitizers.tsan}}
@@ -77,74 +72,70 @@ jobs:
         ASAN_OPTIONS: allocator_may_return_null=1
         TSAN_OPTIONS: allocator_may_return_null=1
       run: |
-        ${{ matrix.compiler.cxx == 'icpx' && '. /opt/intel/oneapi/setvars.sh' || true }}
         ctest --output-on-failure
 
-  windows-build:
-    name: cl and clang-cl on Windows
-    env:
-      VCPKG_PATH: "${{github.workspace}}/build/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows"
-    strategy:
-      matrix:
-        compiler: [{c: cl, cxx: cl}, {c: clang-cl, cxx: clang-cl}]
-        # Only ASAN is supported
-        sanitizers: [{asan: ON}]
-    runs-on: windows-2022
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      with:
-        fetch-depth: 0
-
-    # Use the latest MSVC toolset available, when compiling UMF with ASan.
-    # Running binaries compiled with older toolsets results in a
-    # 'STATUS_DLL_INIT_FAILED' error despite being linked with ASan from
-    # the same toolset as the compiler being used.
-    # https://github.com/actions/runner-images/issues/8891
-    - name: Setup MSVC dev command prompt
-      if: matrix.sanitizers.asan == 'ON'
-      uses: TheMrMilchmann/setup-msvc-dev@48edcef51a12c80d7e62ace57aae1417795e511c # v3.0.0
-      with:
-        arch: x64
-        toolset: '14'
-
-    - name: Initialize vcpkg
-      uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
-      with:
-        vcpkgGitCommitId: 3dd44b931481d7a8e9ba412621fa810232b66289
-        vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
-        vcpkgJsonGlob: '**/vcpkg.json'
-
-    - name: Install dependencies
-      run: vcpkg install
-      shell: pwsh # Specifies PowerShell as the shell for running the script.
-
-    # TODO enable level zero provider
-    - name: Configure build
-      run: >
-        cmake
-        -B ${{env.BUILD_DIR}}
-        -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
-        -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
-        -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
-        -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
-        -DUMF_BUILD_SHARED_LIBRARY=OFF
-        -DUMF_FORMAT_CODE_STYLE=OFF
-        -DUMF_DEVELOPER_MODE=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
-        -DUMF_USE_ASAN=${{matrix.sanitizers.asan}}
-        -DUMF_BUILD_EXAMPLES=ON
-        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
-        -DUMF_BUILD_CUDA_PROVIDER=OFF
-        -DUMF_TESTS_FAIL_ON_SKIP=ON
-
-    - name: Build UMF
-      run: cmake --build ${{env.BUILD_DIR}} --config Debug -j $Env:NUMBER_OF_PROCESSORS
-
-    - name: Run tests
-      working-directory: ${{env.BUILD_DIR}}
-      env:
-        ASAN_OPTIONS: allocator_may_return_null=1
-        TSAN_OPTIONS: allocator_may_return_null=1
-      run: ctest -C Debug --output-on-failure
+  # TODO: restore ASAN tests on Windows
+  # TODO: ... and when restored - add cache support for vcpkg packages !!!
+  #windows-build:
+  #  env:
+  #    VCPKG_PATH: "${{github.workspace}}/build/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows"
+  #  strategy:
+  #    matrix:
+  #
+  #      # {c: clang-cl, cxx: clang-cl}
+  #      compiler: [{c: cl, cxx: cl}]
+  #      # Only ASAN is supported
+  #      sanitizers: [{asan: OFF}]
+  #  name: Sanitizers (windows-latest, compilers=${{matrix.compiler.c}}/${{matrix.compiler.cxx}}, asan=${{matrix.sanitizers.asan}})
+  #  runs-on: windows-latest
+  #
+  #  steps:
+  #  - name: Checkout
+  #    uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+  #    with:
+  #      fetch-depth: 0
+  #
+  #  # Ensure that the required environment is set
+  #  # Note: No need to specify version, the latest one will be used and should work fine
+  #  - name: Setup MSVC dev command prompt
+  #    uses: TheMrMilchmann/setup-msvc-dev@fb19abb8a41b3cf0340f5d1be17d420309232be6 # v3.0.1
+  #    with:
+  #      arch: x64
+  #
+  #  - name: Initialize vcpkg
+  #    uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
+  #    with:
+  #      vcpkgGitCommitId: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
+  #      vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
+  #      vcpkgJsonGlob: '**/vcpkg.json'
+  #
+  #  - name: Install dependencies
+  #    run: vcpkg install --triplet x64-windows
+  #    shell: pwsh
+  #
+  #  - name: Configure build
+  #    run: >
+  #      cmake
+  #      -B ${{env.BUILD_DIR}}
+  #      -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
+  #      -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
+  #      -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
+  #      -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
+  #      -DUMF_BUILD_SHARED_LIBRARY=OFF
+  #      -DUMF_FORMAT_CODE_STYLE=OFF
+  #      -DUMF_DEVELOPER_MODE=OFF
+  #      -DUMF_USE_ASAN=${{matrix.sanitizers.asan}}
+  #      -DUMF_BUILD_EXAMPLES=ON
+  #      -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+  #      -DUMF_BUILD_CUDA_PROVIDER=OFF
+  #      -DUMF_TESTS_FAIL_ON_SKIP=ON
+  #
+  #  - name: Build UMF
+  #    run: cmake --build ${{env.BUILD_DIR}} --config Debug -j $Env:NUMBER_OF_PROCESSORS
+  #
+  #  - name: Run tests
+  #    working-directory: ${{env.BUILD_DIR}}
+  #    env:
+  #      ASAN_OPTIONS: allocator_may_return_null=1
+  #      TSAN_OPTIONS: allocator_may_return_null=1
+  #    run: ctest -C Debug --output-on-failure
diff --git a/.github/workflows/reusable_sycl.yml b/.github/workflows/reusable_sycl.yml
new file mode 100644
index 0000000000..3f6d686ca9
--- /dev/null
+++ b/.github/workflows/reusable_sycl.yml
@@ -0,0 +1,131 @@
+# UMF compatibility with intel/llvm workflow.
+# The latest llvm daily release and the last working release are tested.
+# Triggered in the Nightly workflow.
+name: SYCL
+
+on: workflow_call
+
+permissions:
+  contents: read
+
+jobs:
+  sycl-compatibility:
+    # run only on upstream; forks will not have the HW
+    if: github.repository == 'oneapi-src/unified-memory-framework'
+    name: ${{matrix.llvm_tag}} llvm build
+    runs-on: ["DSS-LEVEL_ZERO", "DSS-UBUNTU"]
+
+    strategy:
+      matrix:
+        llvm_tag: ["latest", "nightly-2025-07-31"] # "latest" or llvm with UMF v1.0.0
+
+    steps:
+    # 1. Install sycl
+    - name: Clean up
+      if: always()
+      run: rm -rf llvm sycl_linux.tar.gz
+
+    - name: Download llvm daily release
+      run: |
+        if [ "${{ matrix.llvm_tag }}" == "latest" ]; then
+          llvm_tag=$(curl -s https://api.github.com/repos/intel/llvm/releases | awk -F'"' '/"tag_name": "nightly/ {print $4; exit}')
+        else
+          llvm_tag="${{ matrix.llvm_tag }}"
+        fi
+        echo "llvm tag: $llvm_tag"
+        download_url="https://github.com/intel/llvm/releases/download/${llvm_tag}/sycl_linux.tar.gz"
+        wget --no-verbose $download_url -O sycl_linux.tar.gz
+
+    - name: Extract llvm
+      run: |
+        mkdir llvm
+        tar -xzf sycl_linux.tar.gz -C llvm --strip-components=1
+
+    - name: Remove UMF installed with llvm
+      run: rm -f llvm/lib/libumf*
+
+    - name: Add sycl to PATH
+      run: |
+        echo "${{ github.workspace }}/llvm/bin" >> $GITHUB_PATH
+        echo "LD_LIBRARY_PATH=${{ github.workspace }}/llvm/lib:$LD_LIBRARY_PATH" >> $GITHUB_ENV
+
+    # 2. Install UMF
+    - name: Checkout UMF
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        path: umf_repo
+        fetch-depth: 0
+
+    - name: Configure UMF
+      working-directory: umf_repo
+      run: >
+        cmake
+        -B build
+        -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/llvm
+        -DCMAKE_BUILD_TYPE=Release
+        -DCMAKE_C_COMPILER=gcc
+        -DCMAKE_CXX_COMPILER=g++
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DUMF_BUILD_TESTS=OFF
+        -DUMF_BUILD_EXAMPLES=OFF
+
+    - name: Build and install UMF
+      working-directory: umf_repo
+      run: cmake --build build --target install -j$(nproc)
+
+    - name: Print installed lib files
+      run: ls -l llvm/lib
+
+    # 3. Test sycl-ls
+    - name: Run sycl-ls
+      env:
+        SYCL_UR_TRACE: 1
+      run: |
+        which clang++
+        which sycl-ls
+        ./llvm/bin/sycl-ls | tee sycl-ls-output.log
+        grep -q "level_zero:gpu" sycl-ls-output.log
+
+    # 4. Test several sycl e2e test
+    # Arbitrarily picked tests to check the compatibility. Note that some intel/llvm tests may be flaky
+    # Checkout the repo in the version that matches the downloaded version
+    - name: Checkout sycl
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        repository: intel/llvm
+        path: sycl_repo
+        fetch-depth: 1
+        ref: ${{ matrix.llvm_tag == 'latest' && 'sycl' || matrix.llvm_tag }}
+
+    - name: Create sycl tests build directory
+      run: |
+        TESTS_BUILD_DIR=${{ github.workspace }}/sycl_repo/sycl/test-e2e/build
+        mkdir $TESTS_BUILD_DIR
+        echo "TESTS_BUILD_DIR=$TESTS_BUILD_DIR" >> $GITHUB_ENV
+
+    # Paths of some tests have changed in the latest llvm release
+    # TODO: when new tagged SYCL version is used (and it's later than 23.04) - remove the extra test paths
+    - name: Build sycl e2e tests
+      working-directory: sycl_repo
+      run: |
+        ${{github.workspace}}/llvm/bin/clang++ -fsycl sycl/test-e2e/AbiNeutral/submit-kernel.cpp -o ${{env.TESTS_BUILD_DIR}}/submit-kernel -Iinclude
+        ${{github.workspace}}/llvm/bin/clang++ -fsycl sycl/test-e2e/Adapters/level_zero/interop-direct.cpp -o ${{env.TESTS_BUILD_DIR}}/l0-interop-direct -lze_loader -Iinclude || \
+          ${{github.workspace}}/llvm/bin/clang++ -fsycl sycl/test-e2e/Adapters/interop-l0-direct.cpp -o ${{env.TESTS_BUILD_DIR}}/interop-l0-direct -lze_loader -Iinclude
+        ${{github.workspace}}/llvm/bin/clang++ -fsycl sycl/test-e2e/Adapters/level_zero/interop_memcpy.cpp -o ${{env.TESTS_BUILD_DIR}}/l0-interop-memcpy -Iinclude || \
+          ${{github.workspace}}/llvm/bin/clang++ -fsycl sycl/test-e2e/Adapters/level_zero_interop_memcpy.cpp -o ${{env.TESTS_BUILD_DIR}}/level_zero_interop_memcpy -Iinclude
+        ${{github.workspace}}/llvm/bin/clang++ -fsycl sycl/test-e2e/Basic/build_log.cpp -o ${{env.TESTS_BUILD_DIR}}/build_log -Iinclude
+        ${{github.workspace}}/llvm/bin/clang++ -fsycl sycl/test-e2e/PerformanceTests/ParallelFor/parallel_for_range_roundup.cpp -fsycl-range-rounding=force -o ${{env.TESTS_BUILD_DIR}}/parallel_for_range_roundup -Iinclude
+        ${{github.workspace}}/llvm/bin/clang++ -fsycl sycl/test-e2e/USM/fill_any_size.cpp -o ${{env.TESTS_BUILD_DIR}}/fill_any_size -Iinclude
+
+    - name: Run sycl e2e tests
+      env:
+        ONEAPI_DEVICE_SELECTOR: level_zero:gpu
+        UMF_LOG: "level:debug;flush:debug;output:stdout;pid:yes"
+      working-directory: ${{env.TESTS_BUILD_DIR}}
+      run: |
+        for test in ./*; do
+          if [ -x "$test" ] && [ ! -d "$test" ]; then
+            echo "### Running test: $test"
+            "$test"
+          fi
+        done
diff --git a/.github/workflows/reusable_trivy.yml b/.github/workflows/reusable_trivy.yml
index c10229276c..9d39cdaa4f 100644
--- a/.github/workflows/reusable_trivy.yml
+++ b/.github/workflows/reusable_trivy.yml
@@ -5,6 +5,7 @@ on: workflow_call
 
 permissions:
   contents: read
+  security-events: read
 
 jobs:
   trivy:
@@ -15,12 +16,12 @@ jobs:
 
     steps:
       - name: Clone the git repo
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
         with:
           fetch-depth: 0
 
       - name: Run Trivy
-        uses: aquasecurity/trivy-action@84384bd6e777ef152729993b8145ea352e9dd3ef # v0.17.0
+        uses: aquasecurity/trivy-action@b6643a29fecd7f34b3597bc6acb0a98b03d33ff8 # v0.33.1
         with:
           scan-type: 'config'
           hide-progress: false
@@ -37,6 +38,6 @@ jobs:
           cat trivy-results.sarif
 
       - name: Upload results
-        uses: github/codeql-action/upload-sarif@e8893c57a1f3a2b659b6b55564fdfdbbd2982911 # v3.24.0
+        uses: github/codeql-action/upload-sarif@fe4161a26a8629af62121b670040955b330f9af2 # v4.31.6
         with:
           sarif_file: 'trivy-results.sarif'
diff --git a/.github/workflows/reusable_valgrind.yml b/.github/workflows/reusable_valgrind.yml
index 86ceb68c68..cc347e32bf 100644
--- a/.github/workflows/reusable_valgrind.yml
+++ b/.github/workflows/reusable_valgrind.yml
@@ -1,4 +1,4 @@
-# Run tests with valgrind intstrumentation tools: memcheck, drd, helgrind
+# Run tests with valgrind instrumentation tools: memcheck, drd, helgrind
 name: Valgrind
 
 on: workflow_call
@@ -13,14 +13,14 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
 
     - name: Install apt packages
       run: |
         sudo apt-get update
-        sudo apt-get install -y cmake hwloc libhwloc-dev libjemalloc-dev libnuma-dev libtbb-dev valgrind
+        sudo apt-get install -y cmake hwloc libhwloc-dev libnuma-dev libtbb-dev valgrind
 
     - name: Configure CMake
       run: >
@@ -28,8 +28,7 @@ jobs:
         -B ${{github.workspace}}/build
         -DCMAKE_BUILD_TYPE=Debug
         -DUMF_FORMAT_CODE_STYLE=OFF
-        -DUMF_DEVELOPER_MODE=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
+        -DUMF_DEVELOPER_MODE=OFF
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
         -DUMF_BUILD_CUDA_PROVIDER=OFF
@@ -42,8 +41,8 @@ jobs:
     - name: Run tests with 'memcheck'
       run: ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{github.workspace}}/build memcheck
 
-    - name: Run tests with 'drd'
-      run: ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{github.workspace}}/build drd
+    - name: Run tests with 'drd' ("drdshort" - very long lasting tests are disabled)
+      run: ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{github.workspace}}/build drdshort
 
     - name: Run tests with 'helgrind'
       run: ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{github.workspace}}/build helgrind
diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml
index b28bb150e7..168f748056 100644
--- a/.github/workflows/scorecard.yml
+++ b/.github/workflows/scorecard.yml
@@ -12,7 +12,9 @@ on:
   push:
     branches: [ "main" ]
 
-permissions: read-all
+permissions:
+  contents: read
+  security-events: read
 
 jobs:
   analyze:
@@ -26,12 +28,12 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
 
     - name: Run analysis
-      uses: ossf/scorecard-action@0864cf19026789058feabb7e87baa5f140aac736 # v2.3.1
+      uses: ossf/scorecard-action@4eaacf0543bb3f2c246792bd56e8cdeffafb205a # v2.4.3
       with:
         results_file: scorecard_results.sarif
         results_format: sarif
@@ -39,7 +41,7 @@ jobs:
 
     # Upload the results as artifacts to the repository Actions tab.
     - name: Upload artifact
-      uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 # 4.3.1
+      uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # 5.0.0
       with:
         name: Scorecard results
         path: scorecard_results.sarif
@@ -47,6 +49,6 @@ jobs:
 
     # Upload the results to GitHub's code scanning dashboard.
     - name: Upload to code-scanning
-      uses: github/codeql-action/upload-sarif@05963f47d870e2cb19a537396c1f668a348c7d8f # v3.24.8
+      uses: github/codeql-action/upload-sarif@fe4161a26a8629af62121b670040955b330f9af2 # v4.31.6
       with:
         sarif_file: scorecard_results.sarif
diff --git a/.github/workflows/weekly.yml b/.github/workflows/weekly.yml
new file mode 100644
index 0000000000..ea1fecaa50
--- /dev/null
+++ b/.github/workflows/weekly.yml
@@ -0,0 +1,76 @@
+# Various non-standard tests, requiring e.g. very long runs or just not required to be run very often.
+name: Weekly
+
+# This job is run every Saturday at 01:00 UTC or on demand.
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0 1 * * 6' # every Saturday at 01:00 UTC
+
+env:
+  BUILD_DIR : "${{github.workspace}}/build"
+  INSTL_DIR : "${{github.workspace}}/install-dir"
+  N_ITER_SAN : 400 # Number of iterations for sanitizers looped job
+
+permissions:
+  contents: read
+
+jobs:
+  # Check code with looped compilers' sanitizers. With 1000 iterations it should take around 4,5 hours.
+  sanitizers-looped:
+    name: Sanitizers looped
+    strategy:
+      fail-fast: false
+      matrix:
+        compiler: [{c: gcc, cxx: g++}, {c: clang, cxx: clang++}, {c: icx, cxx: icpx}]
+        # TSAN is mutually exclusive with other sanitizers
+        sanitizers: [{asan: ON, ubsan: ON, tsan: OFF}, {asan: OFF, ubsan: OFF, tsan: ON}]
+    runs-on: ubuntu-22.04
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        fetch-depth: 0
+
+    - name: Install apt packages
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y clang cmake libhwloc-dev libnuma-dev libtbb-dev
+
+    - name: Install oneAPI basekit
+      if: matrix.compiler.cxx == 'icpx'
+      run: sudo .github/scripts/install_oneAPI.sh
+
+    - name: Configure build
+      run: >
+        ${{ matrix.compiler.cxx == 'icpx' && '. /opt/intel/oneapi/setvars.sh &&' || ''}}
+        cmake
+        -B ${{env.BUILD_DIR}}
+        -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
+        -DCMAKE_BUILD_TYPE=Debug
+        -DUMF_BUILD_SHARED_LIBRARY=OFF
+        -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
+        -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=OFF
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+        -DUMF_USE_ASAN=${{matrix.sanitizers.asan}}
+        -DUMF_USE_UBSAN=${{matrix.sanitizers.ubsan}}
+        -DUMF_USE_TSAN=${{matrix.sanitizers.tsan}}
+        -DUMF_BUILD_EXAMPLES=ON
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+
+    - name: Build UMF
+      run: |
+        ${{ matrix.compiler.cxx == 'icpx' && '. /opt/intel/oneapi/setvars.sh' || true }}
+        cmake --build ${{env.BUILD_DIR}} -j $(nproc)
+
+    - name: Run tests
+      working-directory: ${{env.BUILD_DIR}}
+      env:
+        ASAN_OPTIONS: allocator_may_return_null=1
+        TSAN_OPTIONS: allocator_may_return_null=1
+      run: for i in {1..${{env.N_ITER_SAN}}}; do echo ">>> ITERATION no. ${i}" ; ctest --output-on-failure || exit 1; date; done
diff --git a/.gitignore b/.gitignore
index a1a488bc14..7d0aa10fda 100644
--- a/.gitignore
+++ b/.gitignore
@@ -58,7 +58,7 @@ __pycache__/
 *.py[cod]
 
 # Generated docs
-docs/
+docs_build/
 
 # Build files
 /build*/
@@ -83,3 +83,7 @@ out/
 # IDE Files
 /.vscode
 /.devcontainer
+
+# clangd files
+/.cache/clangd
+compile_commands.json
diff --git a/CMakeLists.txt b/CMakeLists.txt
index f71ce18201..2a60a22502 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,8 +1,10 @@
-# Copyright (C) 2022-2024 Intel Corporation
+# Copyright (C) 2022-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+message(STATUS "CMake version: ${CMAKE_VERSION}")
 cmake_minimum_required(VERSION 3.14.0 FATAL_ERROR)
+
 # needed when UMF is used as an external project
 set(UMF_CMAKE_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
@@ -10,8 +12,12 @@ list(APPEND CMAKE_MODULE_PATH "${UMF_CMAKE_SOURCE_DIR}/cmake")
 # Use full path of the helpers module (to omit potential conflicts with others)
 include(${UMF_CMAKE_SOURCE_DIR}/cmake/helpers.cmake)
 
+# --------------------------------------------------------------------------- #
+# Set UMF version variables, define project, and add basic modules
+# --------------------------------------------------------------------------- #
+
 # We use semver aligned version, set via git tags. We parse git output to
-# establih the version of UMF to be used in CMake, Win dll's, and within the
+# establish the version of UMF to be used in CMake, Win dll's, and within the
 # code (e.g. in logger). We have 3-component releases (e.g. 1.5.1) plus release
 # candidates and git info. Function below sets all variables related to version.
 set_version_variables()
@@ -22,6 +28,13 @@ project(
     umf
     VERSION ${UMF_CMAKE_VERSION}
     LANGUAGES C)
+if(UMF_CMAKE_VERSION VERSION_EQUAL "0.0.0")
+    message(
+        WARNING
+            "UMF version is set to 0.0.0, which most likely is not expected! "
+            "Please install git and checkout the git tags to get a proper version."
+    )
+endif()
 
 if(PROJECT_VERSION_PATCH GREATER 0)
     # set extra variable for Windows dll metadata
@@ -31,8 +44,13 @@ endif()
 include(CTest)
 include(CMakePackageConfigHelpers)
 include(GNUInstallDirs)
+include(FetchContent)
 find_package(PkgConfig)
 
+# --------------------------------------------------------------------------- #
+# Set UMF build options (and CACHE variables)
+# --------------------------------------------------------------------------- #
+
 # Define a list to store the names of all options
 set(UMF_OPTIONS_LIST "")
 list(APPEND UMF_OPTIONS_LIST CMAKE_BUILD_TYPE)
@@ -43,12 +61,11 @@ macro(umf_option)
     option(${ARGV})
 endmacro()
 
-# Build Options
+# All CMake options have to be explicitly set in the build_umfd target's
+# configuration command
 umf_option(UMF_BUILD_SHARED_LIBRARY "Build UMF as shared library" OFF)
 umf_option(UMF_BUILD_LEVEL_ZERO_PROVIDER "Build Level Zero memory provider" ON)
 umf_option(UMF_BUILD_CUDA_PROVIDER "Build CUDA memory provider" ON)
-umf_option(UMF_BUILD_LIBUMF_POOL_DISJOINT
-           "Build the libumf_pool_disjoint static library" OFF)
 umf_option(UMF_BUILD_LIBUMF_POOL_JEMALLOC
            "Build the libumf_pool_jemalloc static library" OFF)
 umf_option(UMF_BUILD_TESTS "Build UMF tests" ON)
@@ -56,20 +73,13 @@ umf_option(UMF_BUILD_GPU_TESTS "Build UMF GPU tests" OFF)
 umf_option(UMF_BUILD_BENCHMARKS "Build UMF benchmarks" OFF)
 umf_option(UMF_BUILD_BENCHMARKS_MT "Build UMF multithreaded benchmarks" OFF)
 umf_option(UMF_BUILD_EXAMPLES "Build UMF examples" ON)
-umf_option(UMF_BUILD_FUZZTESTS "Build UMF fuzz tests" OFF)
 umf_option(UMF_BUILD_GPU_EXAMPLES "Build UMF GPU examples" OFF)
-umf_option(UMF_DEVELOPER_MODE "Enable additional developer checks" OFF)
-umf_option(
-    UMF_DISABLE_HWLOC
-    "Disable hwloc and UMF features requiring it (OS provider, memtargets, topology discovery)"
-    OFF)
+umf_option(UMF_BUILD_FUZZTESTS
+           "Build UMF fuzz tests (supported only on Linux with Clang)" OFF)
 umf_option(
     UMF_LINK_HWLOC_STATICALLY
-    "Link UMF with HWLOC library statically (supported for Linux, MacOS and Release build on Windows)"
+    "Link UMF with HWLOC library statically (proxy library will be disabled on Windows+Debug build)"
     OFF)
-umf_option(
-    UMF_FORMAT_CODE_STYLE
-    "Add clang, cmake, and black -format-check and -format-apply targets" OFF)
 set(UMF_HWLOC_NAME
     "hwloc"
     CACHE STRING "Custom name for hwloc library w/o extension")
@@ -81,6 +91,12 @@ set(UMF_INSTALL_RPATH
         "Set the runtime search path to the directory with dependencies (e.g. hwloc)"
 )
 
+umf_option(UMF_USE_DEBUG_POSTFIX "Add a 'd' postfix to Windows debug libraries"
+           OFF)
+umf_option(UMF_DEVELOPER_MODE "Enable additional developer checks" OFF)
+umf_option(
+    UMF_FORMAT_CODE_STYLE
+    "Add clang, cmake, and black -format-check and -format-apply targets" OFF)
 # Only a part of skips is treated as a failure now. TODO: extend to all tests
 umf_option(UMF_TESTS_FAIL_ON_SKIP "Treat skips in tests as fail" OFF)
 umf_option(UMF_USE_ASAN "Enable AddressSanitizer checks" OFF)
@@ -100,6 +116,12 @@ set_property(CACHE UMF_PROXY_LIB_BASED_ON_POOL
              PROPERTY STRINGS ${KNOWN_PROXY_LIB_POOLS})
 list(APPEND UMF_OPTIONS_LIST UMF_PROXY_LIB_BASED_ON_POOL)
 
+# --------------------------------------------------------------------------- #
+# Setup required variables, definitions; fetch dependencies; include
+# sub_directories based on build options; set flags; etc.
+# --------------------------------------------------------------------------- #
+message(STATUS "CMAKE_GENERATOR: ${CMAKE_GENERATOR}")
+
 if(UMF_BUILD_TESTS
    AND DEFINED ENV{CI}
    AND NOT UMF_TESTS_FAIL_ON_SKIP)
@@ -123,56 +145,180 @@ else()
     message(FATAL_ERROR "Unknown OS type")
 endif()
 
-if(UMF_DISABLE_HWLOC)
-    message(STATUS "hwloc is disabled, hence OS provider, memtargets, "
-                   "topology discovery, examples won't be available!")
+if(UMF_DEVELOPER_MODE)
+    set(UMF_COMMON_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS}
+                                       UMF_DEVELOPER_MODE=1)
+endif()
+
+message(STATUS "CMAKE_PREFIX_PATH=${CMAKE_PREFIX_PATH}")
+
+if(NOT UMF_BUILD_LIBUMF_POOL_JEMALLOC)
+    set(UMF_POOL_JEMALLOC_ENABLED FALSE)
+    set(JEMALLOC_FOUND FALSE)
+    set(JEMALLOC_LIBRARIES FALSE)
+elseif(WINDOWS)
+    pkg_check_modules(JEMALLOC jemalloc)
+    if(NOT JEMALLOC_FOUND)
+        find_package(JEMALLOC REQUIRED jemalloc)
+    endif()
 else()
-    if(NOT DEFINED UMF_HWLOC_REPO)
-        set(UMF_HWLOC_REPO "https://github.com/open-mpi/hwloc.git")
+    if(NOT DEFINED UMF_JEMALLOC_REPO)
+        set(UMF_JEMALLOC_REPO "https://github.com/jemalloc/jemalloc.git")
     endif()
 
-    if(NOT DEFINED UMF_HWLOC_TAG)
-        set(UMF_HWLOC_TAG hwloc-2.10.0)
+    if(NOT DEFINED UMF_JEMALLOC_TAG)
+        set(UMF_JEMALLOC_TAG 5.3.0)
     endif()
 
-    if(NOT UMF_LINK_HWLOC_STATICALLY)
-        pkg_check_modules(LIBHWLOC hwloc>=2.3.0)
-        if(NOT LIBHWLOC_FOUND)
-            find_package(LIBHWLOC 2.3.0 REQUIRED hwloc)
+    message(
+        STATUS
+            "Will fetch jemalloc from ${UMF_JEMALLOC_REPO} (tag: ${UMF_JEMALLOC_TAG})"
+    )
+
+    FetchContent_Declare(
+        jemalloc_targ
+        GIT_REPOSITORY ${UMF_JEMALLOC_REPO}
+        GIT_TAG ${UMF_JEMALLOC_TAG})
+    FetchContent_MakeAvailable(jemalloc_targ)
+
+    add_custom_command(
+        COMMAND ./autogen.sh
+        WORKING_DIRECTORY ${jemalloc_targ_SOURCE_DIR}
+        OUTPUT ${jemalloc_targ_SOURCE_DIR}/configure)
+    add_custom_command(
+        # Custom jemalloc build. Non-default options used:
+        # --with-jemalloc-prefix=je_ - add je_ prefix to all public APIs
+        # --disable-cxx - Disable C++ integration. This will cause new and
+        # delete operators implementations to be omitted.
+        # --disable-initial-exec-tls - Disable the initial-exec TLS model for
+        # jemalloc's internal thread-local storage (on those platforms that
+        # support explicit settings). This can allow jemalloc to be dynamically
+        # loaded after program startup (e.g. using dlopen). --disable-doc -
+        # Disable building and installing the documentation.
+        COMMAND
+            ./configure --prefix=${jemalloc_targ_BINARY_DIR}
+            --with-jemalloc-prefix=je_ --disable-cxx --disable-initial-exec-tls
+            --disable-doc CFLAGS=-fPIC
+        WORKING_DIRECTORY ${jemalloc_targ_SOURCE_DIR}
+        OUTPUT ${jemalloc_targ_SOURCE_DIR}/Makefile
+        DEPENDS ${jemalloc_targ_SOURCE_DIR}/configure)
+
+    if(NOT UMF_QEMU_BUILD)
+        if(CMAKE_GENERATOR STREQUAL "Ninja")
+            # While CMake is supposed to escape this in the generated build
+            # files, for some reason, it doesn't do so here. Until it's fixed,
+            # we just manually escape it for ninja.
+            set(MAKE_ARGUMENTS "-j$$(nproc)")
+        else()
+            set(MAKE_ARGUMENTS "-j$(nproc)")
         endif()
+    endif()
+
+    add_custom_command(
+        COMMAND make ${MAKE_ARGUMENTS}
+        WORKING_DIRECTORY ${jemalloc_targ_SOURCE_DIR}
+        OUTPUT ${jemalloc_targ_SOURCE_DIR}/lib/libjemalloc.a
+        DEPENDS ${jemalloc_targ_SOURCE_DIR}/Makefile)
+    add_custom_command(
+        COMMAND make install
+        WORKING_DIRECTORY ${jemalloc_targ_SOURCE_DIR}
+        OUTPUT ${jemalloc_targ_BINARY_DIR}/lib/libjemalloc.a
+        DEPENDS ${jemalloc_targ_SOURCE_DIR}/lib/libjemalloc.a)
+
+    add_custom_target(jemalloc_prod
+                      DEPENDS ${jemalloc_targ_BINARY_DIR}/lib/libjemalloc.a)
+    add_library(jemalloc INTERFACE)
+    target_link_libraries(
+        jemalloc INTERFACE ${jemalloc_targ_BINARY_DIR}/lib/libjemalloc.a)
+    add_dependencies(jemalloc jemalloc_prod)
+
+    set(JEMALLOC_FOUND TRUE)
+    set(JEMALLOC_LIBRARY_DIRS ${jemalloc_targ_BINARY_DIR}/lib)
+    set(JEMALLOC_INCLUDE_DIRS ${jemalloc_targ_BINARY_DIR}/include)
+    set(JEMALLOC_LIBRARIES ${jemalloc_targ_BINARY_DIR}/lib/libjemalloc.a)
+endif()
 
+if(JEMALLOC_FOUND)
+    set(UMF_POOL_JEMALLOC_ENABLED TRUE)
+    # add PATH to DLL on Windows
+    set(DLL_PATH_LIST
+        "${DLL_PATH_LIST};PATH=path_list_append:${JEMALLOC_DLL_DIRS}")
+    message(STATUS "    JEMALLOC_LIBRARIES = ${JEMALLOC_LIBRARIES}")
+    message(STATUS "    JEMALLOC_INCLUDE_DIRS = ${JEMALLOC_INCLUDE_DIRS}")
+    message(STATUS "    JEMALLOC_LIBRARY_DIRS = ${JEMALLOC_LIBRARY_DIRS}")
+    if(WINDOWS)
+        message(STATUS "    JEMALLOC_DLL_DIRS = ${JEMALLOC_DLL_DIRS}")
+    endif()
+else()
+    set(UMF_POOL_JEMALLOC_ENABLED FALSE)
+    message(
+        STATUS
+            "Disabling the Jemalloc Pool and tests and benchmarks that use it because jemalloc was not built/found."
+    )
+endif()
+
+if(NOT UMF_LINK_HWLOC_STATICALLY)
+    pkg_check_modules(LIBHWLOC hwloc>=2.3.0)
+    if(NOT LIBHWLOC_FOUND)
+        find_package(LIBHWLOC 2.3.0 COMPONENTS hwloc)
+    endif()
+
+    if(LIBHWLOC_FOUND)
         # add PATH to DLL on Windows
         set(DLL_PATH_LIST
             "${DLL_PATH_LIST};PATH=path_list_append:${LIBHWLOC_DLL_DIRS}")
-    elseif(WINDOWS)
-        include(FetchContent)
+    else()
+        set(UMF_LINK_HWLOC_STATICALLY ON)
+    endif()
+endif()
+
+if(UMF_LINK_HWLOC_STATICALLY)
+    if(NOT DEFINED UMF_HWLOC_REPO)
+        set(UMF_HWLOC_REPO "https://github.com/open-mpi/hwloc.git")
+    endif()
+    if(NOT DEFINED UMF_HWLOC_TAG)
+        set(UMF_HWLOC_TAG hwloc-2.10.0)
+    endif()
+
+    message(
+        STATUS
+            "Will fetch hwloc from ${UMF_HWLOC_REPO} (tag: ${UMF_HWLOC_TAG}) and link it statically"
+    )
+
+    if(WINDOWS)
         set(HWLOC_ENABLE_TESTING OFF)
         set(HWLOC_SKIP_LSTOPO ON)
         set(HWLOC_SKIP_TOOLS ON)
-
-        message(
-            STATUS
-                "Will fetch hwloc from ${UMF_HWLOC_REPO} (tag: ${UMF_HWLOC_TAG})"
-        )
+        set(HWLOC_SKIP_INCLUDES ON)
 
         FetchContent_Declare(
             hwloc_targ
             GIT_REPOSITORY ${UMF_HWLOC_REPO}
             GIT_TAG ${UMF_HWLOC_TAG}
-            SOURCE_SUBDIR contrib/windows-cmake/ FIND_PACKAGE_ARGS)
+            SOURCE_SUBDIR contrib/windows-cmake/)
         FetchContent_MakeAvailable(hwloc_targ)
 
-        set(LIBHWLOC_INCLUDE_DIRS
-            ${hwloc_targ_SOURCE_DIR}/include;${hwloc_targ_BINARY_DIR}/include)
-        set(LIBHWLOC_LIBRARY_DIRS
-            ${hwloc_targ_BINARY_DIR}/Release;${hwloc_targ_BINARY_DIR}/Debug)
-    else()
-        include(FetchContent)
-        message(
-            STATUS
-                "Will fetch hwloc from ${UMF_HWLOC_REPO} (tag: ${UMF_HWLOC_TAG})"
-        )
+        set(HWLOC_LIB_PATH "")
+        if(CMAKE_GENERATOR STREQUAL "NMake Makefiles")
+            set(HWLOC_LIB_PATH "${hwloc_targ_BINARY_DIR}/hwloc.lib")
+        else()
+            set(HWLOC_LIB_PATH "${hwloc_targ_BINARY_DIR}/lib/hwloc.lib")
+        endif()
 
+        get_filename_component(LIBHWLOC_LIBRARY_DIRS ${HWLOC_LIB_PATH}
+                               DIRECTORY)
+        set(LIBHWLOC_LIBRARIES ${HWLOC_LIB_PATH})
+        set(LIBHWLOC_INCLUDE_DIRS ${hwloc_targ_BINARY_DIR}/include)
+        set(LIBHWLOC_FOUND TRUE)
+    else() # not Windows
+        find_program(AUTORECONF_EXECUTABLE autoreconf)
+        if(NOT AUTORECONF_EXECUTABLE)
+            message(
+                FATAL_ERROR
+                    "autoreconf is not installed, but it's needed in hwloc configure step. "
+                    "Either install it, or set UMF_LINK_HWLOC_STATICALLY=OFF and install hwloc >= 2.3.0 in your system."
+            )
+        endif()
         FetchContent_Declare(
             hwloc_targ
             GIT_REPOSITORY ${UMF_HWLOC_REPO}
@@ -214,15 +360,20 @@ else()
         set(LIBHWLOC_LIBRARY_DIRS ${hwloc_targ_BINARY_DIR}/lib)
         set(LIBHWLOC_INCLUDE_DIRS ${hwloc_targ_BINARY_DIR}/include)
         set(LIBHWLOC_LIBRARIES ${hwloc_targ_BINARY_DIR}/lib/libhwloc.a)
+        set(LIBHWLOC_FOUND TRUE)
     endif()
+endif() # UMF_LINK_HWLOC_STATICALLY
 
-    message(STATUS "    LIBHWLOC_LIBRARIES = ${LIBHWLOC_LIBRARIES}")
-    message(STATUS "    LIBHWLOC_INCLUDE_DIRS = ${LIBHWLOC_INCLUDE_DIRS}")
-    message(STATUS "    LIBHWLOC_LIBRARY_DIRS = ${LIBHWLOC_LIBRARY_DIRS}")
+message(STATUS "    LIBHWLOC_LIBRARIES = ${LIBHWLOC_LIBRARIES}")
+message(STATUS "    LIBHWLOC_INCLUDE_DIRS = ${LIBHWLOC_INCLUDE_DIRS}")
+message(STATUS "    LIBHWLOC_LIBRARY_DIRS = ${LIBHWLOC_LIBRARY_DIRS}")
+message(STATUS "    LIBHWLOC_API_VERSION = ${LIBHWLOC_API_VERSION}")
+if(WINDOWS)
+    message(STATUS "    LIBHWLOC_DLL_DIRS = ${LIBHWLOC_DLL_DIRS}")
 endif()
 
 if(hwloc_targ_SOURCE_DIR)
-    # apply security patch for HWLOC
+    # Apply security patch for HWLOC
     execute_process(
         COMMAND git apply ${PROJECT_SOURCE_DIR}/cmake/fix_coverity_issues.patch
         WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
@@ -237,62 +388,186 @@ if(hwloc_targ_SOURCE_DIR)
     endif()
 endif()
 
-# Fetch L0 loader only if needed i.e.: if building L0 provider is ON and L0
-# headers are not provided by the user (via setting UMF_LEVEL_ZERO_INCLUDE_DIR).
-if(UMF_BUILD_LEVEL_ZERO_PROVIDER AND (NOT UMF_LEVEL_ZERO_INCLUDE_DIR))
-    include(FetchContent)
-
-    set(LEVEL_ZERO_LOADER_REPO "https://github.com/oneapi-src/level-zero.git")
-    set(LEVEL_ZERO_LOADER_TAG v1.19.2)
+if(UMF_BUILD_LEVEL_ZERO_PROVIDER)
+    if(UMF_BUILD_GPU_TESTS OR UMF_BUILD_GPU_EXAMPLES)
+        # Level Zero loader library is required to build Level Zero GPU tests
+        # and examples
+        find_package(ZE_LOADER REQUIRED ze_loader)
+    else()
+        find_package(ZE_LOADER COMPONENTS ze_loader)
+    endif()
 
-    message(
-        STATUS
-            "Fetching L0 loader (${LEVEL_ZERO_LOADER_TAG}) from ${LEVEL_ZERO_LOADER_REPO} ..."
-    )
+    # If the Level Zero headers are not provided by the user and not found in
+    # the system, we will fetch them from the repo
+    if(UMF_LEVEL_ZERO_INCLUDE_DIR)
+        set(LEVEL_ZERO_INCLUDE_DIRS ${UMF_LEVEL_ZERO_INCLUDE_DIR})
+    elseif(ZE_LOADER_INCLUDE_DIR)
+        set(LEVEL_ZERO_INCLUDE_DIRS ${ZE_LOADER_INCLUDE_DIR})
+    else()
+        set(LEVEL_ZERO_LOADER_REPO
+            "https://github.com/oneapi-src/level-zero.git")
+        set(LEVEL_ZERO_LOADER_TAG v1.22.4)
+
+        message(STATUS "Fetching Level Zero loader (${LEVEL_ZERO_LOADER_TAG}) "
+                       "from ${LEVEL_ZERO_LOADER_REPO} ...")
+
+        # We don't want to build and include Level Zero binaries to our install
+        # target. For CMake >= 3.28 we use EXCLUDE_FROM_ALL flag to do that, but
+        # for older versions we need to use FetchContent_Populate.
+        if(CMAKE_VERSION VERSION_LESS 3.28)
+            FetchContent_Declare(
+                level-zero-loader
+                GIT_REPOSITORY ${LEVEL_ZERO_LOADER_REPO}
+                GIT_TAG ${LEVEL_ZERO_LOADER_TAG})
+            FetchContent_Populate(level-zero-loader)
+        else()
+            # 'non-existing-dir' is set to avoid configuring L0 loader. Ref.
+            # https://gitlab.kitware.com/cmake/cmake/-/issues/26220
+            FetchContent_Declare(
+                level-zero-loader
+                GIT_REPOSITORY ${LEVEL_ZERO_LOADER_REPO}
+                GIT_TAG ${LEVEL_ZERO_LOADER_TAG}
+                EXCLUDE_FROM_ALL SOURCE_SUBDIR "non-existing-dir")
+            FetchContent_MakeAvailable(level-zero-loader)
+        endif()
 
-    FetchContent_Declare(
-        level-zero-loader
-        GIT_REPOSITORY ${LEVEL_ZERO_LOADER_REPO}
-        GIT_TAG ${LEVEL_ZERO_LOADER_TAG}
-        EXCLUDE_FROM_ALL)
-    FetchContent_MakeAvailable(level-zero-loader)
+        set(LEVEL_ZERO_INCLUDE_DIRS
+            ${level-zero-loader_SOURCE_DIR}/include
+            CACHE PATH "Path to Level Zero headers")
+    endif()
+    message(STATUS "LEVEL_ZERO_INCLUDE_DIRS = ${LEVEL_ZERO_INCLUDE_DIRS}")
 
-    set(LEVEL_ZERO_INCLUDE_DIRS
-        ${level-zero-loader_SOURCE_DIR}/include
-        CACHE PATH "Path to Level Zero Headers")
-    message(STATUS "Level Zero include directory: ${LEVEL_ZERO_INCLUDE_DIRS}")
-elseif(UMF_BUILD_LEVEL_ZERO_PROVIDER)
-    # Only header is needed to build UMF
-    set(LEVEL_ZERO_INCLUDE_DIRS ${UMF_LEVEL_ZERO_INCLUDE_DIR})
-    message(STATUS "Level Zero include directory: ${LEVEL_ZERO_INCLUDE_DIRS}")
+    if(ZE_LOADER_FOUND)
+        set(UMF_LEVEL_ZERO_ENABLED TRUE)
+    else()
+        message(
+            STATUS
+                "Disabling tests and examples that use the Level Zero Provider "
+                "because the Level Zero libraries they require were not found.")
+    endif()
 endif()
 
-# Fetch CUDA only if needed i.e.: if building CUDA provider is ON and CUDA
-# headers are not provided by the user (via setting UMF_CUDA_INCLUDE_DIR).
-if(UMF_BUILD_CUDA_PROVIDER AND (NOT UMF_CUDA_INCLUDE_DIR))
-    include(FetchContent)
+if(UMF_BUILD_CUDA_PROVIDER)
+    if(UMF_BUILD_GPU_TESTS OR UMF_BUILD_GPU_EXAMPLES)
+        # CUDA library is required to build CUDA GPU tests and examples
+        find_package(CUDA REQUIRED cuda)
+    else()
+        find_package(CUDA COMPONENTS cuda)
+    endif()
 
-    set(CUDA_REPO
-        "https://gitlab.com/nvidia/headers/cuda-individual/cudart.git")
-    set(CUDA_TAG cuda-12.5.1)
+    # If the CUDA headers are not provided by the user and not found in the
+    # system, we will fetch them from the repo
+    if(UMF_CUDA_INCLUDE_DIR)
+        set(CUDA_INCLUDE_DIRS ${UMF_CUDA_INCLUDE_DIR})
+    elseif(CUDA_INCLUDE_DIR)
+        set(CUDA_INCLUDE_DIRS ${CUDA_INCLUDE_DIR})
+    else()
+        set(CUDA_REPO
+            "https://gitlab.com/nvidia/headers/cuda-individual/cudart.git")
+        set(CUDA_TAG cuda-12.5.1)
 
-    message(STATUS "Fetching CUDA ${CUDA_TAG} from ${CUDA_REPO} ...")
+        message(
+            STATUS "Fetching CUDA (${CUDA_TAG}) headers from ${CUDA_REPO} ...")
+
+        # We don't want to build and include CUDA binaries to our install
+        # target. For CMake >= 3.28 we could use EXCLUDE_FROM_ALL flag to do
+        # that, but for older versions we need to use FetchContent_Populate.
+        if(CMAKE_VERSION VERSION_LESS 3.28)
+            FetchContent_Declare(
+                cuda-headers
+                GIT_REPOSITORY ${CUDA_REPO}
+                GIT_TAG ${CUDA_TAG})
+            FetchContent_Populate(cuda-headers)
+        else()
+            FetchContent_Declare(
+                cuda-headers
+                GIT_REPOSITORY ${CUDA_REPO}
+                GIT_TAG ${CUDA_TAG}
+                EXCLUDE_FROM_ALL)
+            FetchContent_MakeAvailable(cuda-headers)
+        endif()
 
-    FetchContent_Declare(
-        cuda-headers
-        GIT_REPOSITORY ${CUDA_REPO}
-        GIT_TAG ${CUDA_TAG}
-        EXCLUDE_FROM_ALL)
-    FetchContent_MakeAvailable(cuda-headers)
-
-    set(CUDA_INCLUDE_DIRS
-        ${cuda-headers_SOURCE_DIR}
-        CACHE PATH "Path to CUDA headers")
-    message(STATUS "CUDA include directory: ${CUDA_INCLUDE_DIRS}")
-elseif(UMF_BUILD_CUDA_PROVIDER)
-    # Only header is needed to build UMF
-    set(CUDA_INCLUDE_DIRS ${UMF_CUDA_INCLUDE_DIR})
-    message(STATUS "CUDA include directory: ${CUDA_INCLUDE_DIRS}")
+        set(CUDA_INCLUDE_DIRS
+            ${cuda-headers_SOURCE_DIR}
+            CACHE PATH "Path to CUDA headers")
+    endif()
+    message(STATUS "CUDA_INCLUDE_DIRS = ${CUDA_INCLUDE_DIRS}")
+
+    if(CUDA_FOUND)
+        set(UMF_CUDA_ENABLED TRUE)
+    else()
+        message(
+            STATUS "Disabling tests and examples that use the CUDA Provider "
+                   "because the CUDA libraries they require were not found.")
+    endif()
+endif()
+
+# Build the umfd target in a separate directory with Debug configuration
+if(WINDOWS AND UMF_USE_DEBUG_POSTFIX)
+    # The build_umfd target's configuration command requires to have
+    # CMAKE_PREFIX_PATH with semicolons escaped
+    string(JOIN "\;" UMFD_CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH})
+    add_custom_target(
+        build_umfd ALL
+        COMMAND
+            ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" -S ${UMF_CMAKE_SOURCE_DIR}
+            -B ${CMAKE_BINARY_DIR}/umfd_build -DCMAKE_BUILD_TYPE=Debug
+            -DCMAKE_DEBUG_POSTFIX=d
+            -DCMAKE_PREFIX_PATH="${UMFD_CMAKE_PREFIX_PATH}"
+            -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+            -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+            -DUMF_USE_DEBUG_POSTFIX=OFF
+            -DUMF_BUILD_SHARED_LIBRARY=${UMF_BUILD_SHARED_LIBRARY}
+            -DUMF_BUILD_LEVEL_ZERO_PROVIDER=${UMF_BUILD_LEVEL_ZERO_PROVIDER}
+            -DUMF_BUILD_CUDA_PROVIDER=${UMF_BUILD_CUDA_PROVIDER}
+            -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=${UMF_BUILD_LIBUMF_POOL_JEMALLOC}
+            -DUMF_BUILD_TESTS=OFF -DUMF_BUILD_GPU_TESTS=OFF
+            -DUMF_BUILD_BENCHMARKS=OFF -DUMF_BUILD_BENCHMARKS_MT=OFF
+            -DUMF_BUILD_EXAMPLES=OFF -DUMF_BUILD_GPU_EXAMPLES=OFF
+            -DUMF_BUILD_FUZZTESTS=OFF
+            -DUMF_LINK_HWLOC_STATICALLY=${UMF_LINK_HWLOC_STATICALLY}
+            -DUMF_HWLOC_NAME=${UMF_HWLOC_NAME}
+            -DUMF_INSTALL_RPATH=${UMF_INSTALL_RPATH} -DUMF_DEVELOPER_MODE=OFF
+            -DUMF_FORMAT_CODE_STYLE=OFF -DUMF_TESTS_FAIL_ON_SKIP=OFF
+            -DUMF_USE_ASAN=OFF -DUMF_USE_UBSAN=OFF -DUMF_USE_TSAN=OFF
+            -DUMF_USE_MSAN=OFF -DUMF_USE_VALGRIND=OFF -DUMF_USE_COVERAGE=OFF
+            -DUMF_PROXY_LIB_BASED_ON_POOL=${UMF_PROXY_LIB_BASED_ON_POOL}
+        COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR}/umfd_build --target
+                umf --config Debug
+        COMMENT
+            "Configuring and building umfd.dll in a separate directory with Debug configuration"
+    )
+
+    # Copy built UMF libraries to the main binary directory and remove
+    # umfd_build
+    if(CMAKE_CONFIGURATION_TYPES)
+        # Multi-config generator (e.g., Visual Studio)
+        set(UMFD_DLL_SRC "${CMAKE_BINARY_DIR}/umfd_build/bin/Debug/umfd.dll")
+        set(UMFD_LIB_SRC "${CMAKE_BINARY_DIR}/umfd_build/lib/Debug/umfd.lib")
+        set(UMFD_DLL "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/umfd.dll")
+        set(UMFD_LIB "${CMAKE_BINARY_DIR}/lib/$<CONFIG>/umfd.lib")
+    else()
+        # Single-config generator (e.g., Ninja)
+        set(UMFD_DLL_SRC "${CMAKE_BINARY_DIR}/umfd_build/bin/umfd.dll")
+        set(UMFD_LIB_SRC "${CMAKE_BINARY_DIR}/umfd_build/lib/umfd.lib")
+        set(UMFD_DLL "${CMAKE_BINARY_DIR}/bin/umfd.dll")
+        set(UMFD_LIB "${CMAKE_BINARY_DIR}/lib/umfd.lib")
+    endif()
+
+    if(UMF_BUILD_SHARED_LIBRARY)
+        add_custom_command(
+            TARGET build_umfd
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different ${UMFD_DLL_SRC}
+                    ${UMFD_DLL}
+            COMMENT "Copying umfd.dll to the main binary directory")
+    endif()
+    add_custom_command(
+        TARGET build_umfd
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${UMFD_LIB_SRC}
+                ${UMFD_LIB}
+        COMMAND ${CMAKE_COMMAND} -E remove_directory
+                ${CMAKE_BINARY_DIR}/umfd_build DEPENDS ${UMFD_DLL}
+        COMMENT "Copying umfd.lib to the main library directory")
 endif()
 
 # This build type check is not possible on Windows when CMAKE_BUILD_TYPE is not
@@ -331,8 +606,8 @@ endif()
 # For using the options listed in the OPTIONS_REQUIRING_CXX variable a C++17
 # compiler is required. Moreover, if these options are not set, CMake will set
 # up a strict C build, without C++ support.
-set(OPTIONS_REQUIRING_CXX "UMF_BUILD_TESTS" "UMF_BUILD_LIBUMF_POOL_DISJOINT"
-                          "UMF_BUILD_BENCHMARKS_MT" "UMF_BUILD_BENCHMARKS")
+set(OPTIONS_REQUIRING_CXX "UMF_BUILD_TESTS" "UMF_BUILD_BENCHMARKS_MT"
+                          "UMF_BUILD_BENCHMARKS")
 foreach(option_name ${OPTIONS_REQUIRING_CXX})
     if(${option_name})
         enable_language(CXX)
@@ -350,6 +625,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)
@@ -365,12 +657,33 @@ if(UMF_USE_MSAN)
                     "prevent reporting false-positives")
     add_sanitizer_flag(memory)
 endif()
+
 # Fuzzer instrumentation for the whole library
-if(UMF_BUILD_FUZZTESTS
-   AND CMAKE_CXX_COMPILER_ID MATCHES "Clang"
-   AND LINUX)
-    add_compile_options("-fsanitize=fuzzer-no-link")
-    add_link_options("-fsanitize=fuzzer-no-link")
+if(UMF_BUILD_FUZZTESTS)
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND LINUX)
+        add_compile_options("-fsanitize=fuzzer-no-link")
+        add_link_options("-fsanitize=fuzzer-no-link")
+
+        # We need to find the fuzzer lib in the LLVM installation dir and link
+        # it statically as UMF does not define the main function used by fuzzer
+        # as well as __sancov_* functions
+        find_library(FUZZER_NO_MAIN_LIB
+                     NAMES libclang_rt.fuzzer_no_main-x86_64.a)
+
+        if(FUZZER_NO_MAIN_LIB)
+            message(STATUS "Found fuzzer lib: ${FUZZER_NO_MAIN_LIB}")
+            # Fuzzer lib requires libstdc++
+            link_libraries(${FUZZER_NO_MAIN_LIB} "stdc++")
+        else()
+            message(FATAL_ERROR "libclang_rt.fuzzer_no_main-x86_64 not found!")
+        endif()
+    else()
+        message(
+            FATAL_ERROR
+                "UMF_BUILD_FUZZTESTS option is set, but fuzz tests are supported only on Linux with Clang"
+        )
+        set(UMF_BUILD_FUZZTESTS OFF)
+    endif()
 endif()
 
 # A header-only lib to specify include directories in transitive dependencies
@@ -402,7 +715,7 @@ pkg_check_modules(TBB tbb)
 if(NOT TBB_FOUND)
     find_package(TBB OPTIONAL_COMPONENTS tbb)
 endif()
-if(TBB_FOUND OR TBB_LIBRARY_DIRS)
+if(TBB_FOUND)
     # add PATH to DLL on Windows
     set(DLL_PATH_LIST "${DLL_PATH_LIST};PATH=path_list_append:${TBB_DLL_DIRS}")
     set(UMF_POOL_SCALABLE_ENABLED TRUE)
@@ -414,19 +727,6 @@ else()
     set(UMF_POOL_SCALABLE_ENABLED FALSE)
 endif()
 
-if(UMF_BUILD_LIBUMF_POOL_JEMALLOC)
-    pkg_check_modules(JEMALLOC jemalloc)
-    if(NOT JEMALLOC_FOUND)
-        find_package(JEMALLOC REQUIRED jemalloc)
-    endif()
-    if(JEMALLOC_FOUND OR JEMALLOC_LIBRARIES)
-        set(UMF_POOL_JEMALLOC_ENABLED TRUE)
-        # add PATH to DLL on Windows
-        set(DLL_PATH_LIST
-            "${DLL_PATH_LIST};PATH=path_list_append:${JEMALLOC_DLL_DIRS}")
-    endif()
-endif()
-
 if(WINDOWS)
     # TODO: enable the proxy library in the Debug build on Windows
     #
@@ -447,9 +747,7 @@ if(WINDOWS)
 endif()
 
 # set UMF_PROXY_LIB_ENABLED
-if(UMF_DISABLE_HWLOC)
-    message(STATUS "Disabling the proxy library, because HWLOC is disabled")
-elseif(NOT UMF_BUILD_SHARED_LIBRARY)
+if(NOT UMF_BUILD_SHARED_LIBRARY)
     # TODO enable this scenario
     message(
         STATUS
@@ -467,14 +765,14 @@ elseif(UMF_PROXY_LIB_BASED_ON_POOL STREQUAL SCALABLE)
         )
     endif()
 elseif(UMF_PROXY_LIB_BASED_ON_POOL STREQUAL JEMALLOC)
-    if(UMF_BUILD_LIBUMF_POOL_JEMALLOC)
+    if(UMF_POOL_JEMALLOC_ENABLED)
         set(UMF_PROXY_LIB_ENABLED ON)
         set(PROXY_LIB_USES_JEMALLOC_POOL ON)
-        set(PROXY_LIBS jemalloc_pool umf)
+        set(PROXY_LIBS umf)
     else()
         message(
             STATUS
-                "Disabling the proxy library, because UMF_PROXY_LIB_BASED_ON_POOL==JEMALLOC but UMF_BUILD_LIBUMF_POOL_JEMALLOC is OFF"
+                "Disabling the proxy library, because UMF_PROXY_LIB_BASED_ON_POOL==JEMALLOC but the jemalloc pool is disabled"
         )
     endif()
 else()
@@ -484,18 +782,6 @@ else()
     )
 endif()
 
-if((UMF_BUILD_GPU_TESTS OR UMF_BUILD_GPU_EXAMPLES) AND UMF_BUILD_CUDA_PROVIDER)
-    find_package(CUDA REQUIRED cuda)
-    if(CUDA_LIBRARIES)
-        set(UMF_CUDA_ENABLED TRUE)
-    else()
-        message(
-            STATUS "Disabling tests and examples that use the CUDA provider "
-                   "because the CUDA libraries they require were not found.")
-    endif()
-    # TODO do the same for ze_loader
-endif()
-
 add_subdirectory(src)
 
 if(UMF_BUILD_TESTS)
@@ -506,7 +792,7 @@ if(UMF_BUILD_BENCHMARKS)
     add_subdirectory(benchmark)
 endif()
 
-if(UMF_BUILD_EXAMPLES AND NOT UMF_DISABLE_HWLOC)
+if(UMF_BUILD_EXAMPLES)
     add_subdirectory(examples)
 endif()
 
@@ -625,7 +911,7 @@ if(UMF_FORMAT_CODE_STYLE)
         add_custom_target(
             cmake-format-apply
             COMMAND ${CMAKE_FORMAT} --in-place ${format_cmake_list}
-            COMMENT "Format Cmake files using cmake-format")
+            COMMENT "Format CMake files using cmake-format")
     endif()
 
     if(BLACK)
@@ -675,20 +961,44 @@ 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()
 endif()
 
+find_package(Python3 3.8)
+if(Python3_FOUND)
+    message(STATUS "Adding 'docs' target for creating a documentation.")
+    add_custom_target(
+        docs
+        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+        COMMAND UMF_VERSION=${UMF_CMAKE_VERSION} ${Python3_EXECUTABLE}
+                ${UMF_CMAKE_SOURCE_DIR}/docs/generate_docs.py
+        COMMENT "Generate HTML documentation using Doxygen")
+endif()
+
 # --------------------------------------------------------------------------- #
 # Configure make install/uninstall and packages
 # --------------------------------------------------------------------------- #
+# Install the umfd library files as part of the umfd component
+if(WINDOWS AND UMF_USE_DEBUG_POSTFIX)
+    if(UMF_BUILD_SHARED_LIBRARY)
+        install(
+            FILES ${UMFD_DLL}
+            DESTINATION ${CMAKE_INSTALL_BINDIR}
+            COMPONENT umfd)
+    endif()
+    install(
+        FILES ${UMFD_LIB}
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        COMPONENT umfd)
+endif()
+
 install(FILES ${PROJECT_SOURCE_DIR}/LICENSE.TXT
         DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/doc/${PROJECT_NAME}/")
 install(
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index 58dba18db6..2e7fbf7d6c 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -5,7 +5,7 @@
 We as members, contributors, and leaders pledge to make participation in our
 community a harassment-free experience for everyone, regardless of age, body
 size, visible or invisible disability, ethnicity, sex characteristics, gender
-identity and expression, level of experience, education, socio-economic status,
+identity and expression, level of experience, education, socioeconomic status,
 nationality, personal appearance, race, caste, color, religion, or sexual
 identity and orientation.
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7b9749c491..cb2f9de1f0 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -6,6 +6,7 @@
   - [Opening new issues](#opening-new-issues)
   - [Submitting Pull Requests](#submitting-pull-requests)
     - [Building and testing](#building-and-testing)
+    - [Building/Rebuilding Docker Images](#buildingrebuilding-docker-images)
     - [Code style](#code-style)
     - [When my PR is merged?](#when-my-pr-is-merged)
     - [Extending public API](#extending-public-api)
@@ -13,8 +14,9 @@
     - [Adding new dependency](#adding-new-dependency)
   - [Code coverage](#code-coverage)
   - [Debugging](#debugging)
-    - [Checking the UMF version and CMake variables (Linux only)](#checking-the-umf-version-and-cmake-variables-linux-only)
-      - [Requirements](#requirements)
+    - [Checking UMF version and build options](#checking-umf-version-and-build-options)
+      - [Linux](#linux)
+      - [Windows](#windows)
 
 Below you'll find instructions on how to contribute to UMF, either with code changes
 or issues. All contributions are most welcome!
@@ -66,6 +68,13 @@ To enable additional checks (including `-Werror` / `/WX` compilation flag), swit
 `UMF_DEVELOPER_MODE`. To read more about all available CMake options please see
 ["CMake standard options"](./README.md#cmake-standard-options) section in the top-level Readme.
 
+### Building/Rebuilding Docker Images
+
+If you want to rebuild existing Docker images or add a new one, you must open a separate pull 
+request dedicated to Docker-related changes. This PR must be merged into the main branch first.
+
+The updated Docker images will be available for use in workflows only when this PR is merged.
+
 ### Code style
 We use `clang-format` to verify and apply code style changes to C/C++ source files.
 To see all rules we require, please take a look at `.clang-format` file in the 
@@ -229,9 +238,17 @@ $ genhtml -o html_report coverage.info
 
 ## Debugging
 
-### Checking the UMF version and CMake variables (Linux only)
+### Checking UMF version and build options
 
-Strings with the UMF version and useful CMake variables can be grepped in the following way:
+From an already built UMF shared library you can obtain UMF precise version and
+CMake variables/options it was built with. It's not only useful to verify what should
+be included within the library, but also for debugging. If you're filing an issue to
+UMF project, please include this information in your ticket.
+
+#### Linux
+
+Make sure the `binutils` package is installed in your system. Then, you can use
+the following grep command:
 
 ```bash
 $ strings libumf.so | grep "@(#)"
@@ -239,6 +256,11 @@ $ strings libumf.so | grep "@(#)"
 @(#) Intel(R) UMF CMake variables: "CMAKE_BUILD_TYPE:Debug,...
 ```
 
-#### Requirements
+Please note, that version available in the name of library file (e.g. `libumf.so.0.11.0`)
+may be not accurate - version coded inside of the library is far more precise.
+
+#### Windows
 
-- binutils package (Linux)
+On Windows, DLL's metadata can be accessed e.g. looking into *Properties* of the dll file
+in the explorer. Look into the *Details* tab for "Product version" and "File description"
+(it contains UMF's build options).
diff --git a/ChangeLog b/ChangeLog
index 0736379f85..0de579ecf8 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,90 @@
+Tue Sep 16 2025 Łukasz Stolarczuk <lukasz.stolarczuk@intel.com>
+
+	* Version 1.0.3
+
+	This patch release contains following change:
+	- load libcuda.so.1 instead of libcuda.so on linux (#1518)
+
+Wed Sep 03 2025 Łukasz Stolarczuk <lukasz.stolarczuk@intel.com>
+
+	* Version 1.0.2
+
+	This patch release contains following change:
+	- initialize hwloc topology only before first fork, not always (#1509)
+
+Fri Aug 08 2025 Łukasz Stolarczuk <lukasz.stolarczuk@intel.com>
+
+	* Version 1.0.1
+
+	This patch release contains following changes:
+	- make topology_init faster (#1469)
+	- verify if the provider supports the split operation (#1465)
+	- fix build failure when building for jemalloc with ninja (#1474)
+
+Mon Jul 21 2025 Łukasz Stolarczuk <lukasz.stolarczuk@intel.com>
+
+	* Version 1.0.0
+
+	The Unified Memory Framework (UMF) is a library for constructing allocators and memory pools.
+	It also contains broadly useful abstractions and utilities for memory management.
+	UMF allows users to manage multiple memory pools characterized by different attributes,
+	allowing certain allocation types to be isolated from others and allocated using different
+	hardware resources as required.
+
+	While this is the first UMF release with the backward compatibility guarantee,
+	part of the library's API (at the moment: CTL, memspace, memtarget, and mempolicy)
+	is still experimental and may change in future releases.
+
+	Due to cleanup and improvements there have been some API changes made:
+	- add const qualifier to parameters, where applicable (#1257, #1266)
+	- unify return values (#1387, #1370)
+	- make pool get name an obligatory pool function (#1398)
+	- make out parameters the last functions' arguments (#1408)
+
+	This release contains also:
+	- new experimental CTL API (i.a. #913, #1073, #1206)
+	- add umfPoolGetName (#1320)
+	- use multiple arenas in Jemalloc pool (#1214)
+	- make umfInit thread-safe (#1399)
+	- add umfd debug library on Windows (#1219, #1238)
+	- deprecate UMF_DISABLE_HWLOC CMake build option (#1308)
+	- fix: numanode index retrieval (#1309)
+	- fix: reset base allocator destroy flag (#1326)
+
+Mon May 12 2025 Łukasz Stolarczuk <lukasz.stolarczuk@intel.com>
+
+	* Version 0.11.2
+
+	This patch release contains following changes:
+	- retrieve numanode object by os index instead of logical index (#1309)
+
+Thu May 08 2025 Łukasz Stolarczuk <lukasz.stolarczuk@intel.com>
+
+	* Version 0.11.1
+
+	This patch release contains following changes:
+	- check global state destruction in destructors (#1297)
+	- a minor change in UMF logs (#1299)
+
+Thu Apr 17 2025 Łukasz Stolarczuk <lukasz.stolarczuk@intel.com>
+
+	* Version 0.11.0
+
+	This release contains:
+	- make disjoint pool a C structure #898
+	- add fixed provider #976
+	- remove the Coarse provider #934 and replace with internal coarse library #931, #932
+	- implement umfPool[Set/Get]Tag #962
+	- L0 provider: implement support for defer and blocking free #963
+	- add set/restore context in CUDA provider free() #1049
+	- L0 provider: implement min/recommended page size query #1059
+	- add support for CUDA allocation flags #1079
+	- increase refcount to ze_loader/CUDA libraries #1086
+	- implement size limit for the cache of opened IPC handles #998
+	- allow creating fixed provider based on allocations from another pool #1143
+	- multiple benchmark improvements
+	- new tests and CI workflows, incl. backward compatibility checks (#1087, #1163)
+
 Fri Jan 10 2025 Łukasz Stolarczuk <lukasz.stolarczuk@intel.com>
 
 	* Version 0.10.1
@@ -31,6 +118,12 @@ Mon Dec 09 2024 Łukasz Stolarczuk <lukasz.stolarczuk@intel.com>
 	- extended logging
 	- yet more fixes in the building system
 
+Tue Nov 12 2024 Łukasz Stolarczuk <lukasz.stolarczuk@intel.com>
+
+	* Version 0.9.1
+
+	This patch release contains only 3 small fixes in build system of UMF.
+
 Thu Sep 12 2024 Łukasz Stolarczuk <lukasz.stolarczuk@intel.com>
 
 	* Version 0.9.0
diff --git a/README.md b/README.md
index 6f1233c639..cf5d24be75 100644
--- a/README.md
+++ b/README.md
@@ -4,6 +4,7 @@
 [![Coverage](https://gist.githubusercontent.com/bb-ur/3f66c77d7035df39aa75dda8a2ac75b3/raw/umf_coverage_badge.svg)](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/pr_push.yml?query=branch%3Amain)
 [![GitHubPages](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/docs.yml/badge.svg?branch=main)](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/docs.yml)
 [![Nightly](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/nightly.yml/badge.svg?branch=main)](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/nightly.yml)
+[![Weekly](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/weekly.yml/badge.svg)](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/weekly.yml)
 [![Coverity build](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/coverity.yml/badge.svg?branch=main)](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/coverity.yml)
 [![Coverity report](https://scan.coverity.com/projects/29761/badge.svg?flat=0)](https://scan.coverity.com/projects/oneapi-src-unified-memory-framework)
 [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/oneapi-src/unified-memory-framework/badge)](https://securityscorecards.dev/viewer/?uri=github.com/oneapi-src/unified-memory-framework)
@@ -18,29 +19,36 @@ For a quick introduction to UMF usage, please see
 [examples](https://oneapi-src.github.io/unified-memory-framework/examples.html)
 documentation, which includes the code of the
 [basic example](https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/basic/basic.c).
-The are also more advanced that allocates USM memory from the 
-[Level Zero device](https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/level_zero_shared_memory/level_zero_shared_memory.c)
-using the Level Zero API and UMF Level Zero memory provider and [CUDA device](https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/cuda_shared_memory/cuda_shared_memory.c)
-using the CUDA API and UMF CUDA memory provider.
+There are also more advanced examples that allocate USM memory from the [Level Zero device](examples/level_zero_shared_memory/level_zero_shared_memory.c) using the Level Zero API and UMF Level Zero memory provider and [CUDA device](examples/cuda_shared_memory/cuda_shared_memory.c) using the CUDA API and UMF CUDA memory provider.
+
+UMF's experimental CTL API is showcased in the [CTL example](examples/ctl/ctl.c),
+which explores provider and pool statistics, and in the [custom CTL example](examples/ctl/custom_ctl.c), which wires CTL support into a custom memory provider. These examples rely on experimental headers which may change in future releases.
 
 ## Build
 
 ### Requirements
 
 Required packages:
+
 - libhwloc-dev >= 2.3.0 (Linux) / hwloc >= 2.3.0 (Windows)
 - C compiler
 - [CMake](https://cmake.org/) >= 3.14.0
 
 For development and contributions:
+
 - clang-format-15.0 (can be installed with `python -m pip install clang-format==15.0.7`)
 - cmake-format-0.6 (can be installed with `python -m pip install cmake-format==0.6.13`)
 - black (can be installed with `python -m pip install black==24.3.0`)
 
-For building tests, multithreaded benchmarks and Disjoint Pool:
+> **Note**: All devs dependencies are defined in `third-party/requirements.txt`
+> and can be installed, for example: `pip install -r third_party/requirements.txt`.
+
+For building tests and multithreaded benchmarks:
+
 - C++ compiler with C++17 support
 
 For Level Zero memory provider tests:
+
 - Level Zero headers and libraries
 - compatible GPU with installed driver
 
@@ -50,8 +58,8 @@ Executable and binaries will be in **build/bin**.
 The `{build_config}` can be either `Debug` or `Release`.
 
 ```bash
-$ cmake -B build -DCMAKE_BUILD_TYPE={build_config}
-$ cmake --build build -j $(nproc)
+cmake -B build -DCMAKE_BUILD_TYPE={build_config}
+cmake --build build -j $(nproc)
 ```
 
 ### Windows
@@ -60,8 +68,8 @@ Generating Visual Studio Project. EXE and binaries will be in **build/bin/{build
 The `{build_config}` can be either `Debug` or `Release`.
 
 ```bash
-$ cmake -B build -G "Visual Studio 15 2017 Win64"
-$ cmake --build build --config {build_config} -j $Env:NUMBER_OF_PROCESSORS
+cmake -B build -G "Visual Studio 15 2017 Win64"
+cmake --build build --config {build_config} -j $Env:NUMBER_OF_PROCESSORS
 ```
 
 ### Benchmark
@@ -71,26 +79,42 @@ In order to build the benchmark, the `UMF_BUILD_BENCHMARKS` CMake configuration
 
 UMF also provides multithreaded benchmarks that can be enabled by setting both
 `UMF_BUILD_BENCHMARKS` and `UMF_BUILD_BENCHMARKS_MT` CMake
-configuration flags to `ON`. Multithreaded benchmarks require a C++ support.
+configuration flags to `ON`. Multithreaded benchmarks require C++ support.
 
-The Scalable Pool requirements can be found in the relevant 'Memory Pool 
+The Scalable Pool requirements can be found in the relevant 'Memory Pool
 managers' section below.
 
 ### Sanitizers
 
 List of sanitizers available on Linux:
+
 - AddressSanitizer
 - UndefinedBehaviorSanitizer
 - ThreadSanitizer
-   - Is mutually exclusive with other sanitizers.
+  - Is mutually exclusive with other sanitizers.
 - MemorySanitizer
-   - Requires linking against MSan-instrumented libraries to prevent false positive reports. More information [here](https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo).
+  - Requires linking against MSan-instrumented libraries to prevent false positive reports. More information [here](https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo).
 
 List of sanitizers available on Windows:
+
 - AddressSanitizer
 
 Listed sanitizers can be enabled with appropriate [CMake options](#cmake-standard-options).
 
+### Fuzz testing
+
+To enable fuzz testing, the `UMF_BUILD_FUZZTESTS` CMake configuration flag must
+be set to `ON`. Note, that this feature is supported only on Linux and requires
+Clang. Additionally, ensure that the `CMAKE_PREFIX_PATH` includes the directory
+containing the libraries necessary for fuzzing (e.g., Clang's
+libclang_rt.fuzzer_no_main-x86_64.a).
+
+Example:
+
+```bash
+cmake -B build -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_BUILD_TYPE=Debug -DUMF_BUILD_FUZZTESTS=ON -DCMAKE_PREFIX_PATH=/path/to/fuzzer/libs
+```
+
 ### CMake standard options
 
 List of options provided by CMake:
@@ -100,15 +124,14 @@ List of options provided by CMake:
 | UMF_BUILD_SHARED_LIBRARY | Build UMF as shared library | ON/OFF | OFF |
 | UMF_BUILD_LEVEL_ZERO_PROVIDER | Build Level Zero memory provider | ON/OFF | ON |
 | UMF_BUILD_CUDA_PROVIDER | Build CUDA memory provider | ON/OFF | ON |
-| UMF_BUILD_LIBUMF_POOL_DISJOINT | Build the libumf_pool_disjoint static library | ON/OFF | OFF |
 | UMF_BUILD_LIBUMF_POOL_JEMALLOC | Build the libumf_pool_jemalloc static library | ON/OFF | OFF |
 | UMF_BUILD_TESTS | Build UMF tests | ON/OFF | ON |
 | UMF_BUILD_GPU_TESTS | Build UMF GPU tests | ON/OFF | OFF |
 | UMF_BUILD_BENCHMARKS | Build UMF benchmarks | ON/OFF | OFF |
 | UMF_BUILD_EXAMPLES | Build UMF examples | ON/OFF | ON |
-| UMF_BUILD_FUZZTESTS | Build UMF fuzz tests | ON/OFF | OFF |
+| UMF_BUILD_FUZZTESTS | Build UMF fuzz tests (supported only on Linux with Clang) | ON/OFF | OFF |
 | UMF_BUILD_GPU_EXAMPLES | Build UMF GPU examples | ON/OFF | OFF |
-| UMF_DEVELOPER_MODE | Enable additional developer checks | ON/OFF | OFF |
+| UMF_DEVELOPER_MODE | Enable additional developer checks and logs | ON/OFF | OFF |
 | UMF_FORMAT_CODE_STYLE | Add clang, cmake, and black -format-check and -format-apply targets to make | ON/OFF | OFF |
 | UMF_TESTS_FAIL_ON_SKIP | Treat skips in tests as fail | ON/OFF | OFF |
 | UMF_USE_ASAN | Enable AddressSanitizer checks | ON/OFF | OFF |
@@ -117,81 +140,106 @@ List of options provided by CMake:
 | UMF_USE_MSAN | Enable MemorySanitizer checks | ON/OFF | OFF |
 | UMF_USE_VALGRIND | Enable Valgrind instrumentation | ON/OFF | OFF |
 | UMF_USE_COVERAGE | Build with coverage enabled (Linux only) | ON/OFF | OFF |
-| UMF_LINK_HWLOC_STATICALLY | Link UMF with HWLOC library statically (Windows+Release only) | ON/OFF | OFF |
-| UMF_DISABLE_HWLOC | Disable features that requires hwloc (OS provider, memory targets, topology discovery) | ON/OFF | OFF |
+| UMF_LINK_HWLOC_STATICALLY | Link UMF with HWLOC library statically (proxy library will be disabled on Windows+Debug build) | ON/OFF | OFF |
 
 ## Architecture: memory pools and providers
 
-A UMF memory pool is a combination of a pool allocator and a memory provider. A memory provider is responsible for coarse-grained memory allocations and management of memory pages, while the pool allocator controls memory pooling and handles fine-grained memory allocations.
+A UMF memory pool is a combination of a pool allocator and a memory provider. A memory provider is responsible for
+coarse-grained memory allocations and management of memory pages, while the pool allocator controls memory pooling
+and handles fine-grained memory allocations.
 
 Pool allocator can leverage existing allocators (e.g. jemalloc or tbbmalloc) or be written from scratch.
 
-UMF comes with predefined pool allocators (see include/pool) and providers (see include/provider). UMF can also work with user-defined pools and providers that implement a specific interface (see include/umf/memory_pool_ops.h and include/umf/memory_provider_ops.h).
+UMF comes with predefined pool allocators (see [`include/umf/pools`](include/umf/pools)) and providers
+(see [`include/umf/providers`](include/umf/providers)). UMF can also work with user-defined pools and
+providers that implement a specific interface (see [`include/umf/memory_pool_ops.h`](include/umf/memory_pool_ops.h)
+and [`include/umf/memory_provider_ops.h`](include/umf/memory_provider_ops.h)).
 
-More detailed documentation is available here: https://oneapi-src.github.io/unified-memory-framework/
+More detailed documentation is available here: <https://oneapi-src.github.io/unified-memory-framework/>
 
 ### Memory providers
 
-#### Coarse Provider
+#### Fixed memory provider
 
-A memory provider that can provide memory from:
-1) a given pre-allocated buffer (the fixed-size memory provider option) or
-2) from an additional upstream provider (e.g. provider that does not support the free() operation
-   like the File memory provider or the DevDax memory provider - see below).
+A memory provider that can provide memory from a given pre-allocated buffer.
 
 #### OS memory provider
 
 A memory provider that provides memory from an operating system.
 
 OS memory provider supports two types of memory mappings (set by the `visibility` parameter):
+
 1) private memory mapping (`UMF_MEM_MAP_PRIVATE`)
 2) shared memory mapping (`UMF_MEM_MAP_SHARED` - supported on Linux only yet)
 
 IPC API requires the `UMF_MEM_MAP_SHARED` memory `visibility` mode
 (`UMF_RESULT_ERROR_INVALID_ARGUMENT` is returned otherwise).
 
+IPC API uses file descriptor duplication, which requires the `pidfd_getfd(2)` system call to obtain
+a duplicate of another process's file descriptor. This system call is supported since Linux 5.6.
+Required permission ("restricted ptrace") is governed by the `PTRACE_MODE_ATTACH_REALCREDS` check
+(see `ptrace(2)`). To allow file descriptor duplication in a binary that opens IPC handle, you can call
+`prctl(PR_SET_PTRACER, ...)` in the producer binary that gets the IPC handle.
+Alternatively you can change the `ptrace_scope` globally in the system, e.g.:
+
+```sh
+sudo bash -c "echo 0 > /proc/sys/kernel/yama/ptrace_scope"
+```
+
 There are available two mechanisms for the shared memory mapping:
+
 1) a named shared memory object (used if the `shm_name` parameter is not NULL) or
 2) an anonymous file descriptor (used if the `shm_name` parameter is NULL)
 
 The `shm_name` parameter should be a null-terminated string of up to NAME_MAX (i.e., 255) characters none of which are slashes.
 
 An anonymous file descriptor for the shared memory mapping will be created using:
+
 1) `memfd_secret()` syscall - (if it is implemented and) if the `UMF_MEM_FD_FUNC` environment variable does not contain the "memfd_create" string or
 2) `memfd_create()` syscall - otherwise (and if it is implemented).
 
 ##### Requirements
 
-Required packages for tests (Linux-only yet):
-   - libnuma-dev
+IPC API on Linux requires the `PTRACE_MODE_ATTACH_REALCREDS` permission (see `ptrace(2)`)
+to duplicate another process's file descriptor (see above).
+
+Packages required for tests (Linux-only yet):
+
+- libnuma-dev
 
 #### Level Zero memory provider
 
 A memory provider that provides memory from L0 device.
 
+IPC API uses file descriptor duplication, which requires the `pidfd_getfd(2)` system call to obtain
+a duplicate of another process's file descriptor. This system call is supported since Linux 5.6.
+Required permission ("restricted ptrace") is governed by the `PTRACE_MODE_ATTACH_REALCREDS` check
+(see `ptrace(2)`). To allow file descriptor duplication in a binary that opens IPC handle, you can call
+`prctl(PR_SET_PTRACER, ...)` in the producer binary that gets the IPC handle.
+Alternatively you can change the `ptrace_scope` globally in the system, e.g.:
+
+```sh
+sudo bash -c "echo 0 > /proc/sys/kernel/yama/ptrace_scope"
+```
 ##### Requirements
 
 1) Linux or Windows OS
 2) The `UMF_BUILD_LEVEL_ZERO_PROVIDER` option turned `ON` (by default)
+3) IPC API on Linux requires the `PTRACE_MODE_ATTACH_REALCREDS` permission (see `ptrace(2)`)
+   to duplicate another process's file descriptor (see above).
 
 Additionally, required for tests:
 
-3) The `UMF_BUILD_GPU_TESTS` option turned `ON`
-4) System with Level Zero compatible GPU
-5) Required packages:
+4) The `UMF_BUILD_GPU_TESTS` option turned `ON`
+5) System with Level Zero compatible GPU
+6) Required packages:
    - liblevel-zero-dev (Linux) or level-zero-sdk (Windows)
 
 #### DevDax memory provider (Linux only)
 
-A memory provider that provides memory from a device DAX (a character device file /dev/daxX.Y).
+A memory provider that provides memory from a device DAX (a character device file like `/dev/daxX.Y`).
 It can be used when large memory mappings are needed.
 
-The DevDax memory provider does not support the free operation
-(`umfMemoryProviderFree()` always returns `UMF_RESULT_ERROR_NOT_SUPPORTED`),
-so it should be used with a pool manager that will take over
-the managing of the provided memory - for example the jemalloc pool
-with the `disable_provider_free` parameter set to true.
-
 ##### Requirements
 
 1) Linux OS
@@ -201,12 +249,6 @@ with the `disable_provider_free` parameter set to true.
 
 A memory provider that provides memory by mapping a regular, extendable file.
 
-The file memory provider does not support the free operation
-(`umfMemoryProviderFree()` always returns `UMF_RESULT_ERROR_NOT_SUPPORTED`),
-so it should be used with a pool manager that will take over
-the managing of the provided memory - for example the jemalloc pool
-with the `disable_provider_free` parameter set to true.
-
 IPC API requires the `UMF_MEM_MAP_SHARED` memory `visibility` mode
 (`UMF_RESULT_ERROR_INVALID_ARGUMENT` is returned otherwise).
 
@@ -241,28 +283,41 @@ This memory pool is distributed as part of libumf. It forwards all requests to t
 memory provider. Currently umfPoolRealloc, umfPoolCalloc and umfPoolMallocUsableSize functions
 are not supported by the proxy pool.
 
-To enable this feature, the `UMF_BUILD_SHARED_LIBRARY` option needs to be turned `ON`.
-
-#### Disjoint pool
-
-TODO: Add a description
-
-##### Requirements
+#### Disjoint pool (part of libumf)
 
-To enable this feature, the `UMF_BUILD_LIBUMF_POOL_DISJOINT` option needs to be turned `ON`.
+The Disjoint pool is designed to keep internal metadata separate from user data.
+This separation is particularly useful when user data needs to be placed in memory with relatively high latency,
+such as GPU memory or disk storage.
 
 #### Jemalloc pool
 
-Jemalloc pool is a [jemalloc](https://github.com/jemalloc/jemalloc)-based memory 
+Jemalloc pool is a [jemalloc](https://github.com/jemalloc/jemalloc)-based memory
 pool manager built as a separate static library: libjemalloc_pool.a on Linux and
 jemalloc_pool.lib on Windows.
 The `UMF_BUILD_LIBUMF_POOL_JEMALLOC` option has to be turned `ON` to build this library.
 
+[jemalloc](https://github.com/jemalloc/jemalloc) is required to build the jemalloc pool.
+
+In case of Linux OS jemalloc is built from the (fetched) sources with the following
+non-default options enabled:
+
+- `--with-jemalloc-prefix=je_` - adds the `je_` prefix to all public APIs,
+- `--disable-cxx` - disables C++ integration, it will cause the `new` and the `delete`
+                    operators implementations to be omitted.
+- `--disable-initial-exec-tls` - disables the initial-exec TLS model for jemalloc's
+                    internal thread-local storage (on those platforms that support
+                    explicit settings), it can allow jemalloc to be dynamically
+                    loaded after program startup (e.g. using `dlopen()`).
+
+The default jemalloc package is required on Windows.
+
 ##### Requirements
 
 1) The `UMF_BUILD_LIBUMF_POOL_JEMALLOC` option turned `ON`
-2) Required packages:
-   - libjemalloc-dev (Linux) or jemalloc (Windows)
+2) jemalloc is required:
+
+- on Linux and MacOS: jemalloc is fetched and built from sources (a custom build),
+- on Windows: the default jemalloc package is required
 
 #### Scalable Pool (part of libumf)
 
@@ -272,10 +327,13 @@ It is distributed as part of libumf. To use this pool, TBB must be installed in
 ##### Requirements
 
 Packages required for using this pool and executing tests/benchmarks (not required for build):
-   - libtbb-dev (libtbbmalloc.so.2) on Linux or tbb (tbbmalloc.dll) on Windows
+
+- libtbb-dev (libtbbmalloc.so.2) on Linux or tbb (tbbmalloc.dll) on Windows
 
 ### Memspaces (Linux-only)
 
+> **Note**: The memspace, memtarget and mempolicy APIs are experimental and may change in future releases.
+
 TODO: Add general information about memspaces.
 
 #### Host all memspace
@@ -303,19 +361,22 @@ Querying the latency value requires HMAT support on the platform. Calling `umfMe
 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.
 
+To enable this feature, the `UMF_BUILD_SHARED_LIBRARY` option needs to be turned `ON`.
+
 #### 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
+LD_PRELOAD=/usr/lib/libumf_proxy.so myprogram
 ```
 
 The memory used by the proxy memory allocator is mmap'ed:
+
 1) with the `MAP_PRIVATE` flag by default or
 2) with the `MAP_SHARED` flag if the `UMF_PROXY` environment variable contains one of two following strings: `page.disposition=shared-shm` or `page.disposition=shared-fd`. These two options differ in a mechanism used during IPC:
    - `page.disposition=shared-shm` - IPC uses the named shared memory. An SHM name is generated using the `umf_proxy_lib_shm_pid_$PID` pattern, where `$PID` is the PID of the process. It creates the `/dev/shm/umf_proxy_lib_shm_pid_$PID` file.
-   - `page.disposition=shared-fd` - IPC uses the file descriptor duplication. It requires using `pidfd_getfd(2)` to obtain a duplicate of another process's file descriptor. Permission to duplicate another process's file descriptor is governed by a ptrace access mode `PTRACE_MODE_ATTACH_REALCREDS` check (see `ptrace(2)`) that can be changed using the `/proc/sys/kernel/yama/ptrace_scope` interface. `pidfd_getfd(2)` is supported since Linux 5.6.
+   - `page.disposition=shared-fd` -  IPC API uses file descriptor duplication, which requires the `pidfd_getfd(2)` system call to obtain a duplicate of another process's file descriptor. This system call is supported since Linux 5.6. Required permission ("restricted ptrace") is governed by the `PTRACE_MODE_ATTACH_REALCREDS` check (see `ptrace(2)`). To allow file descriptor duplication in a binary that opens IPC handle, you can call `prctl(PR_SET_PTRACER, ...)` in the producer binary that gets the IPC handle. Alternatively you can change the `ptrace_scope` globally in the system, e.g.: `sudo bash -c "echo 0 > /proc/sys/kernel/yama/ptrace_scope"`.
 
 **Size threshold**
 
@@ -327,6 +388,7 @@ It can be enabled by adding the `size.threshold=<value>` string to the `UMF_PROX
 #### 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.
@@ -340,3 +402,28 @@ an issue or a Pull Request, please read [Contribution Guide](./CONTRIBUTING.md).
 
 To enable logging in UMF source files please follow the guide in the
 [web documentation](https://oneapi-src.github.io/unified-memory-framework/introduction.html#logging).
+
+## CMake integration
+
+Integration of UMF into another project via CMake's
+[FetchContent](https://cmake.org/cmake/help/latest/module/FetchContent.html),
+is possible with:
+
+```cmake
+include(FetchContent)
+
+FetchContent_Declare(
+    unified-memory-framework
+    GIT_REPOSITORY https://github.com/oneapi-src/unified-memory-framework.git
+    GIT_TAG main  # This will pull the latest (potentially unstable) changes from the main branch
+)
+FetchContent_MakeAvailable(unified-memory-framework)
+
+add_executable(some_example some_example.cpp)
+target_include_directories(some_example PRIVATE ${unified-memory-framework_SOURCE_DIR}/include)
+target_link_libraries(some_example PRIVATE umf::umf umf::headers)
+```
+
+## Notices
+
+The contents of this repository may have been developed with support from one or more Intel-operated generative artificial intelligence solutions.
diff --git a/RELEASE_STEPS.md b/RELEASE_STEPS.md
index ec6e5b6906..75ca16bae8 100644
--- a/RELEASE_STEPS.md
+++ b/RELEASE_STEPS.md
@@ -4,8 +4,8 @@ This document contains all the steps required to make a new release of UMF.
 
 As a helper, we use in this guide these 2 variables:
 ```bash
-  set $VERSION = new full version (e.g., 0.1.0-rc1) # -rc1 included just as an example
-  set $VER = new major+minor only version (e.g., 0.1)
+  $VERSION=1.1.0-rc1  # New full version, including optional rc suffix as an example
+  $VER=1.1            # New major+minor only version
 ```
 
 **Note:**
@@ -19,44 +19,67 @@ will be released for a oneAPI release. Once all changes planned for UMF release
 we follow the process (described in more detail below):
 
 1. Checkout the appropriate branch (`main` or "stable" `v$VER.x`).
-2. Make changes for the release.
-3. Create a new tag based on the latest commit - it takes the form
+1. Make sure remotes are up-to-date on your machine (`git remote update`).
+1. Make changes for the release.
+1. Create a new tag based on the latest commit - it should follow the format:
   `v<major>.<minor>.<patch>` (e.g., `v0.1.0`).
-4. Push the tag and branch to the upstream.
-5. Create a new GitHub release using the tag created in the previous step.
-6. Update downstream projects to utilize the release tag. If any issues arise
+1. Push the tag and branch to the upstream.
+1. Create a new GitHub release using the tag created in the previous step.
+1. Update dependent/downstream projects to use the new release tag. If any issues arise
    from integration, apply any necessary hot fixes to `v$VER.x`
    branch and go back to step 2 - to create a patch release. This step can also be tested
    using `rc` version, potentially followed by another `rc` tag.
 
 ## Make a release locally
 
-Do changes for a release:
-- Start of appropriate branch:
+Prepare changes for the release:
+- Start of appropriate up-to-date branch:
+  - Fetch remotes
+    - `git remote update`
   - For patch release, do it from a stable branch:
     - `git checkout v$VER.x` (e.g., checkout `v0.1.x` if this is a `v0.1.1` patch)
     - If previously we decided not to create such branch, create it now, based on the appropriate minor or major tag
   - For major/minor release start from the `main` branch
-- Add an entry to ChangeLog, remember to change the day of the week in the release date
-  - For major and minor (prior 1.0.0) releases mention API and ABI compatibility with the previous release
-- Update project's version in a few places:
-  - For major and minor releases: `UMF_VERSION_CURRENT` in `include/umf/base.h` (the API version)
-  - `release` variable in `scripts/docs_config/conf.py` (for docs)
-  - `UMF_VERSION` variable in `.github/workflows/basic.yml` (for installation test)
-- For major and minor (prior 1.0.0) releases update ABI version in `.map` and `.def` files
+- Add a new entry to the `ChangeLog`, remember to change the day of the week in the release date
+  - For major releases mention API and ABI compatibility with the previous releases
+- For major and minor releases, update `UMF_VERSION_CURRENT` in `include/umf/base.h` (the API version)
+  - For changes in ops structures, update corresponding UMF_*_OPS_VERSION_CURRENT
+- For major and minor releases update ABI version in `.map` and `.def` files
   - These files are defined for all public libraries (`libumf` and `proxy_lib`, at the moment)
+  - For minor releases acceptable is only adding new functions/symbols!
+- Once all changes are done, build locally (and/or verify changes on CI), including:
+  - Verify if scanners/linters/checkers passed
+  - Verify if version is set properly, especially in `.dll` and `.so` files
+- Create/update a VERSION file for GitHub ZIP downloads (users without git):
+  - `echo "$VERSION" > VERSION`
+  - It will always contain "the last released version". In logs/CMake build it will introduce itself as `$VERSION-dev`, only if git is not available
 - Commit these changes and tag the release:
+  - `git add VERSION`
   - `git commit -a -S -m "$VERSION release"`
   - `git tag -a -s -m "Version $VERSION" v$VERSION`
+- Verify if commit and tag are properly signed:
+  - `git verify-commit <commit's sha>`
+  - `git verify-tag v$VERSION`
 - For major/minor release:
   - If stable branch for this release is required, create it:
     - `git checkout -b v$VER.x`
-    - For some early versions (like `0.1.0`) we may omit creation of the branch
+    - For some short-lived versions, creation of this branch may be skipped
+- For major/minor release, when release is done, add an extra "dev" tag on the `main` branch:
+  - `git tag -a -s -m "Development version $VERSION+1 - dev1" v$VERSION+1-dev1`
+    - for example, when `v0.1.0` is released, the dev tag would be `v0.2.0-dev1`
+    - if needed, further in time, an extra dev tag can be introduced, e.g. `v0.2.0-dev2`
+  - This way, the `main` branch will introduce itself as the next version
+  - "dev" tag can and should be added right after we merge changes from stable to main
 
 ## Publish changes
 
 As patch releases should be done on the stable branches, pushing tags and branches differ a little.
 
+**Note:**
+> Before pushing to "upstream" it's preferred to push changes into your own fork.
+> This allows you to verify the branch and tag manually in GitHub interface, and it will
+> trigger the CI on your fork.
+
 For patch release:
   - `git push upstream HEAD:v$VER.x v$VERSION` - push branch and tag
 
@@ -67,13 +90,17 @@ For major/minor release:
     - `git checkout v$VER.x`
     - `git push upstream HEAD:v$VER.x`
 
+When final release is done it's best to merge back changes from stable branch to main.
+This situation can happen if the stable branch was created before the final release (e.g.
+with one of the RC versions). Thanks to that all the changes, including ChangeLog will land
+on the main branch. After such merge-back it's advised to add "dev" tag (described above).
+
 ## Announce release
 
 To make the release official:
 - Go to [GitHub's releases tab](https://github.com/oneapi-src/unified-memory-framework/releases/new):
   - Tag version: `v$VERSION`, release title: UMF $VERSION, description: copy entry from ChangeLog and format it with no tabs and no characters limit in line
-  - Prior to version 1.0.0, check the *Set as a pre-release* tick box.
-- Announce the release, where needed
+- Announce the release in all appropriate channels
 
 ## More information
 
diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
index 5605519ee2..1c417af67d 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -1,23 +1,29 @@
-# 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(FetchContent)
-FetchContent_Declare(
-    googlebenchmark
-    GIT_REPOSITORY https://github.com/google/benchmark.git
-    GIT_TAG v1.9.0)
-
-set(BENCHMARK_ENABLE_GTEST_TESTS
-    OFF
-    CACHE BOOL "" FORCE)
-set(BENCHMARK_ENABLE_TESTING
-    OFF
-    CACHE BOOL "" FORCE)
-set(BENCHMARK_ENABLE_INSTALL
-    OFF
-    CACHE BOOL "" FORCE)
-FetchContent_MakeAvailable(googlebenchmark)
+set(GBENCH_VERSION 1.9.0)
+
+find_package(benchmark ${GBENCH_VERSION} QUIET)
+
+if(NOT benchmark_FOUND)
+    include(FetchContent)
+    FetchContent_Declare(
+        googlebenchmark
+        GIT_REPOSITORY https://github.com/google/benchmark.git
+        GIT_TAG v${GBENCH_VERSION})
+
+    set(BENCHMARK_ENABLE_GTEST_TESTS
+        OFF
+        CACHE BOOL "" FORCE)
+    set(BENCHMARK_ENABLE_TESTING
+        OFF
+        CACHE BOOL "" FORCE)
+    set(BENCHMARK_ENABLE_INSTALL
+        OFF
+        CACHE BOOL "" FORCE)
+    FetchContent_MakeAvailable(googlebenchmark)
+endif()
 
 # In MSVC builds, there is no way to determine the actual build type during the
 # CMake configuration step. Therefore, this message is printed in all MSVC
@@ -40,8 +46,9 @@ function(add_umf_benchmark)
     # * SRCS - source files
     # * LIBS - libraries to be linked with
     # * LIBDIRS - directories of libraries to be linked with
+    # * TESTARGS - additional arguments to be passed to the add_test
     set(oneValueArgs NAME)
-    set(multiValueArgs SRCS LIBS LIBDIRS)
+    set(multiValueArgs SRCS LIBS LIBDIRS TESTARGS)
     cmake_parse_arguments(
         ARG
         ""
@@ -51,7 +58,7 @@ function(add_umf_benchmark)
 
     set(BENCH_NAME umf-${ARG_NAME})
 
-    set(BENCH_LIBS ${ARG_LIBS} umf)
+    set(BENCH_LIBS ${ARG_LIBS} umf umf_utils)
 
     add_umf_executable(
         NAME ${BENCH_NAME}
@@ -59,14 +66,16 @@ function(add_umf_benchmark)
         LIBS ${BENCH_LIBS})
 
     target_include_directories(
-        ${BENCH_NAME} PRIVATE ${UMF_CMAKE_SOURCE_DIR}/include
-                              ${UMF_CMAKE_SOURCE_DIR}/src/utils)
+        ${BENCH_NAME}
+        PRIVATE ${UMF_CMAKE_SOURCE_DIR}/include
+                ${UMF_CMAKE_SOURCE_DIR}/src/utils
+                ${UMF_CMAKE_SOURCE_DIR}/test/common)
 
     target_link_directories(${BENCH_NAME} PRIVATE ${ARG_LIBDIRS})
 
     add_test(
         NAME ${BENCH_NAME}
-        COMMAND ${BENCH_NAME}
+        COMMAND ${BENCH_NAME} ${ARG_TESTARGS}
         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
     if("${BENCH_NAME}" STREQUAL "umf-ubench")
@@ -87,10 +96,6 @@ function(add_umf_benchmark)
                                                  "${DLL_PATH_LIST}")
     endif()
 
-    if(UMF_BUILD_LIBUMF_POOL_DISJOINT)
-        target_compile_definitions(${BENCH_NAME}
-                                   PRIVATE UMF_POOL_DISJOINT_ENABLED=1)
-    endif()
     if(UMF_POOL_JEMALLOC_ENABLED)
         target_compile_definitions(${BENCH_NAME}
                                    PRIVATE UMF_POOL_JEMALLOC_ENABLED=1)
@@ -99,16 +104,16 @@ function(add_umf_benchmark)
         target_compile_definitions(${BENCH_NAME}
                                    PRIVATE UMF_POOL_SCALABLE_ENABLED=1)
     endif()
-    if(UMF_BUILD_LEVEL_ZERO_PROVIDER)
+    if(UMF_LEVEL_ZERO_ENABLED)
         target_compile_definitions(${BENCH_NAME}
                                    PRIVATE UMF_PROVIDER_LEVEL_ZERO_ENABLED=1)
-        target_include_directories(
-            ${BENCH_NAME} PRIVATE ${UMF_CMAKE_SOURCE_DIR}/test/common
-                                  ${LEVEL_ZERO_INCLUDE_DIRS})
+        target_include_directories(${BENCH_NAME}
+                                   PRIVATE ${LEVEL_ZERO_INCLUDE_DIRS})
     endif()
-    if(UMF_BUILD_CUDA_PROVIDER)
+    if(UMF_CUDA_ENABLED)
         target_compile_definitions(${BENCH_NAME}
                                    PRIVATE UMF_BUILD_CUDA_PROVIDER=1)
+        target_include_directories(${BENCH_NAME} PRIVATE ${CUDA_INCLUDE_DIRS})
     endif()
     if(UMF_BUILD_GPU_TESTS)
         target_compile_definitions(${BENCH_NAME} PRIVATE UMF_BUILD_GPU_TESTS=1)
@@ -118,18 +123,12 @@ endfunction()
 set(LIB_DIRS ${LIBHWLOC_LIBRARY_DIRS})
 
 # optional libraries
-if(UMF_BUILD_LIBUMF_POOL_DISJOINT)
-    set(LIBS_OPTIONAL ${LIBS_OPTIONAL} disjoint_pool)
-endif()
-if(UMF_BUILD_LIBUMF_POOL_JEMALLOC)
-    set(LIBS_OPTIONAL ${LIBS_OPTIONAL} jemalloc_pool ${JEMALLOC_LIBRARIES})
-    set(LIB_DIRS ${LIB_DIRS} ${JEMALLOC_LIBRARY_DIRS})
-endif()
 if(LINUX)
     set(LIBS_OPTIONAL ${LIBS_OPTIONAL} m)
 endif()
-if(UMF_BUILD_GPU_TESTS AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
+if(UMF_BUILD_GPU_TESTS AND UMF_LEVEL_ZERO_ENABLED)
     set(SRCS_OPTIONAL ${SRCS_OPTIONAL} ../src/utils/utils_level_zero.cpp)
+    set(LIB_DIRS ${LIB_DIRS} ${ZE_LOADER_LIBRARY_DIRS})
     set(LIBS_OPTIONAL ${LIBS_OPTIONAL} ze_loader)
     # TODO add CUDA
 endif()
@@ -146,7 +145,9 @@ add_umf_benchmark(
     NAME benchmark
     SRCS benchmark.cpp
     LIBS ${LIBS_OPTIONAL} benchmark::benchmark
-    LIBDIRS ${LIB_DIRS})
+    # limit running benchmarks in CI tests to single-threaded
+    LIBDIRS ${LIB_DIRS}
+    TESTARGS --benchmark_filter=threads:1$)
 
 if(UMF_BUILD_BENCHMARKS_MT)
     add_umf_benchmark(
diff --git a/benchmark/benchmark.cpp b/benchmark/benchmark.cpp
index c10bbda877..d4375fe9d1 100644
--- a/benchmark/benchmark.cpp
+++ b/benchmark/benchmark.cpp
@@ -1,341 +1,119 @@
 /*
- * 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
  *
  */
 
-#include <benchmark/benchmark.h>
-#include <umf/pools/pool_proxy.h>
-#ifdef UMF_POOL_SCALABLE_ENABLED
-#include <umf/pools/pool_scalable.h>
-#endif
-#include <umf/providers/provider_os_memory.h>
-
-#ifdef UMF_POOL_DISJOINT_ENABLED
-#include <umf/pools/pool_disjoint.h>
-#endif
-
-#ifdef UMF_POOL_JEMALLOC_ENABLED
-#include <umf/pools/pool_jemalloc.h>
-#endif
-
 #include "benchmark.hpp"
 
-struct glibc_malloc : public allocator_interface {
-    unsigned SetUp([[maybe_unused]] ::benchmark::State &state,
-                   unsigned argPos) override {
-        return argPos;
-    }
-    void TearDown([[maybe_unused]] ::benchmark::State &state) override{};
-    void *benchAlloc(size_t size) override { return malloc(size); }
-    void benchFree(void *ptr, [[maybe_unused]] size_t size) override {
-        free(ptr);
-    }
-    static std::string name() { return "glibc"; }
-};
-
-struct os_provider : public provider_interface {
-    umf_os_memory_provider_params_handle_t params = NULL;
-    os_provider() {
-        umfOsMemoryProviderParamsCreate(&params);
-        return;
-    }
+#include <iostream>
 
-    ~os_provider() {
-        if (params != NULL) {
-            umfOsMemoryProviderParamsDestroy(params);
-        }
-    }
-
-    void *getParams() override { return params; }
-    umf_memory_provider_ops_t *getOps() override {
-        return umfOsMemoryProviderOps();
-    }
-    static std::string name() { return "os_provider"; }
-};
-
-template <typename Provider>
-struct proxy_pool : public pool_interface<Provider> {
-    umf_memory_pool_ops_t *
-    getOps([[maybe_unused]] ::benchmark::State &state) override {
-        return umfProxyPoolOps();
-    }
-    void *getParams([[maybe_unused]] ::benchmark::State &state) override {
-        return nullptr;
-    }
-    static std::string name() { return "proxy_pool<" + Provider::name() + ">"; }
-};
-
-#ifdef UMF_POOL_DISJOINT_ENABLED
-template <typename Provider>
-struct disjoint_pool : public pool_interface<Provider> {
-    umf_disjoint_pool_params_handle_t disjoint_memory_pool_params;
-
-    disjoint_pool() {
-        disjoint_memory_pool_params = NULL;
-        auto ret = umfDisjointPoolParamsCreate(&disjoint_memory_pool_params);
-        if (ret != UMF_RESULT_SUCCESS) {
-            return;
-        }
-
-        // those function should never fail, so error handling is minimal.
-        ret = umfDisjointPoolParamsSetSlabMinSize(disjoint_memory_pool_params,
-                                                  4096);
-        if (ret != UMF_RESULT_SUCCESS) {
-            goto err;
-        }
-
-        ret = umfDisjointPoolParamsSetCapacity(disjoint_memory_pool_params, 4);
-        if (ret != UMF_RESULT_SUCCESS) {
-            goto err;
-        }
-
-        ret = umfDisjointPoolParamsSetMinBucketSize(disjoint_memory_pool_params,
-                                                    4096);
-        if (ret != UMF_RESULT_SUCCESS) {
-            goto err;
-        }
-
-        ret = umfDisjointPoolParamsSetMaxPoolableSize(
-            disjoint_memory_pool_params, 4096 * 16);
-
-        if (ret != UMF_RESULT_SUCCESS) {
-            goto err;
-        }
-        return;
-    err:
-
-        umfDisjointPoolParamsDestroy(disjoint_memory_pool_params);
-        disjoint_memory_pool_params = NULL;
-    }
-
-    ~disjoint_pool() {
-        if (disjoint_memory_pool_params != NULL) {
-            umfDisjointPoolParamsDestroy(disjoint_memory_pool_params);
-        }
-    }
+#include <benchmark/benchmark.h>
 
-    umf_memory_pool_ops_t *
-    getOps([[maybe_unused]] ::benchmark::State &state) override {
-        return umfDisjointPoolOps();
+#define UMF_BENCHMARK_TEMPLATE_DEFINE(BaseClass, Method, ...)                  \
+    BENCHMARK_TEMPLATE_DEFINE_F(BaseClass, Method, __VA_ARGS__)                \
+    (benchmark::State & state) {                                               \
+        for (auto _ : state) {                                                 \
+            bench(state);                                                      \
+        }                                                                      \
     }
-    void *getParams([[maybe_unused]] ::benchmark::State &state) override {
-
-        if (disjoint_memory_pool_params == NULL) {
-            state.SkipWithError("Failed to create disjoint pool params");
-        }
 
-        return disjoint_memory_pool_params;
-    }
-    static std::string name() {
-        return "disjoint_pool<" + Provider::name() + ">";
-    }
-};
-#endif
+#define UMF_BENCHMARK_REGISTER_F(BaseClass, Method)                            \
+    BENCHMARK_REGISTER_F(BaseClass, Method)                                    \
+        ->Apply(                                                               \
+            &BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method)::defaultArgs)
 
-#ifdef UMF_POOL_JEMALLOC_ENABLED
-template <typename Provider>
-struct jemalloc_pool : public pool_interface<Provider> {
-    umf_memory_pool_ops_t *
-    getOps([[maybe_unused]] ::benchmark::State &state) override {
-        return umfJemallocPoolOps();
-    }
-    void *getParams([[maybe_unused]] ::benchmark::State &state) override {
-        return NULL;
-    }
-    static std::string name() {
-        return "jemalloc_pool<" + Provider::name() + ">";
-    }
-};
-#endif
-
-#ifdef UMF_POOL_SCALABLE_ENABLED
-template <typename Provider>
-struct scalable_pool : public pool_interface<Provider> {
-    virtual umf_memory_pool_ops_t *
-    getOps([[maybe_unused]] ::benchmark::State &state) override {
-        return umfScalablePoolOps();
-    }
-    virtual void *
-    getParams([[maybe_unused]] ::benchmark::State &state) override {
-        return NULL;
-    }
-    static std::string name() {
-        return "scalable_pool<" + Provider::name() + ">";
-    }
-};
-#endif
 // Benchmarks scenarios:
 
-UMF_BENCHMARK_TEMPLATE_DEFINE(alloc_benchmark, glibc_fix, fixed_alloc_size,
-                              glibc_malloc);
-
 // The benchmark arguments specified in Args() are, in order:
 // benchmark arguments, allocator arguments, size generator arguments.
 // The exact meaning of each argument depends on the benchmark, allocator, and size components used.
 // Refer to the 'argsName()' function in each component to find detailed descriptions of these arguments.
-UMF_BENCHMARK_REGISTER_F(alloc_benchmark, glibc_fix)
-    ->Args({10000, 0, 4096})
-    ->Args({10000, 100000, 4096})
-    ->Threads(4)
-    ->Threads(1);
-
-UMF_BENCHMARK_TEMPLATE_DEFINE(alloc_benchmark, glibc_uniform,
-                              uniform_alloc_size, glibc_malloc);
-UMF_BENCHMARK_REGISTER_F(alloc_benchmark, glibc_uniform)
-    ->Args({10000, 0, 8, 64 * 1024, 8})
-    ->Threads(4)
-    ->Threads(1);
-
-UMF_BENCHMARK_TEMPLATE_DEFINE(alloc_benchmark, os_provider, fixed_alloc_size,
-                              provider_allocator<os_provider>);
-UMF_BENCHMARK_REGISTER_F(alloc_benchmark, os_provider)
-    ->Args({10000, 0, 4096})
-    ->Args({10000, 100000, 4096})
-    ->Threads(4)
-    ->Threads(1);
-
-UMF_BENCHMARK_TEMPLATE_DEFINE(alloc_benchmark, proxy_pool, fixed_alloc_size,
-                              pool_allocator<proxy_pool<os_provider>>);
 
-UMF_BENCHMARK_REGISTER_F(alloc_benchmark, proxy_pool)
-    ->Args({1000, 0, 4096})
-    ->Args({1000, 100000, 4096})
-    ->Threads(4)
-    ->Threads(1);
+static void multithreaded(benchmark::internal::Benchmark *benchmark) {
+    benchmark->Threads(1);
+    benchmark->Threads(4);
+}
 
-#ifdef UMF_POOL_DISJOINT_ENABLED
-UMF_BENCHMARK_TEMPLATE_DEFINE(alloc_benchmark, disjoint_pool_fix,
-                              fixed_alloc_size,
-                              pool_allocator<disjoint_pool<os_provider>>);
-UMF_BENCHMARK_REGISTER_F(alloc_benchmark, disjoint_pool_fix)
-    ->Args({10000, 0, 4096})
-    ->Args({10000, 100000, 4096})
-    ->Threads(4)
-    ->Threads(1);
-
-// TODO: debug why this crashes
-/*UMF_BENCHMARK_TEMPLATE_DEFINE(alloc_benchmark, disjoint_pool_uniform,
-                              uniform_alloc_size,
-                              pool_allocator<disjoint_pool<os_provider>>);
-UMF_BENCHMARK_REGISTER_F(alloc_benchmark, disjoint_pool_uniform)
-    ->Args({10000, 0, 8, 64 * 1024, 8})
-    //    ->Threads(4)
-    ->Threads(1);
-*/
-#endif
+static void singlethreaded(benchmark::internal::Benchmark *benchmark) {
+    benchmark->Threads(1);
+}
 
-#ifdef UMF_POOL_JEMALLOC_ENABLED
-UMF_BENCHMARK_TEMPLATE_DEFINE(alloc_benchmark, jemalloc_pool_fix,
-                              fixed_alloc_size,
-                              pool_allocator<jemalloc_pool<os_provider>>);
-UMF_BENCHMARK_REGISTER_F(alloc_benchmark, jemalloc_pool_fix)
-    ->Args({10000, 0, 4096})
-    ->Args({10000, 100000, 4096})
-    ->Threads(4)
-    ->Threads(1);
+static void
+default_multiple_alloc_fix_size(benchmark::internal::Benchmark *benchmark) {
+    benchmark->Args({10000, 1, 4096});
+    benchmark->Iterations(500000);
+}
 
-UMF_BENCHMARK_TEMPLATE_DEFINE(alloc_benchmark, jemalloc_pool_uniform,
-                              uniform_alloc_size,
-                              pool_allocator<jemalloc_pool<os_provider>>);
-UMF_BENCHMARK_REGISTER_F(alloc_benchmark, jemalloc_pool_uniform)
-    ->Args({10000, 0, 8, 64 * 1024, 8})
-    ->Threads(4)
-    ->Threads(1);
-
-#endif
-#ifdef UMF_POOL_SCALABLE_ENABLED
-UMF_BENCHMARK_TEMPLATE_DEFINE(alloc_benchmark, scalable_pool_fix,
-                              fixed_alloc_size,
-                              pool_allocator<scalable_pool<os_provider>>);
-
-UMF_BENCHMARK_REGISTER_F(alloc_benchmark, scalable_pool_fix)
-    ->Args({10000, 0, 4096})
-    ->Args({10000, 100000, 4096})
-    ->Threads(4)
-    ->Threads(1);
-
-UMF_BENCHMARK_TEMPLATE_DEFINE(alloc_benchmark, scalable_pool_uniform,
-                              uniform_alloc_size,
-                              pool_allocator<scalable_pool<os_provider>>);
-
-UMF_BENCHMARK_REGISTER_F(alloc_benchmark, scalable_pool_uniform)
-    ->Args({10000, 0, 8, 64 * 1024, 8})
-    ->Threads(4)
-    ->Threads(1);
-#endif
-// Multiple allocs/free
+static void
+default_multiple_alloc_uniform_size(benchmark::internal::Benchmark *benchmark) {
+    benchmark->Args({10000, 1, 8, 4096, 8});
+    benchmark->Args({10000, 1, 8, 128, 8});
+    benchmark->Iterations(500000);
+}
 
 UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark, glibc_fix,
                               fixed_alloc_size, glibc_malloc);
 
 UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, glibc_fix)
-    ->Args({10000, 4096})
-    ->Threads(4)
-    ->Threads(1);
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
 
 UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark, glibc_uniform,
                               uniform_alloc_size, glibc_malloc);
 UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, glibc_uniform)
-    ->Args({10000, 8, 64 * 1024, 8})
-    ->Threads(4)
-    ->Threads(1);
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
 
 UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark, proxy_pool,
                               fixed_alloc_size,
                               pool_allocator<proxy_pool<os_provider>>);
 
 UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, proxy_pool)
-    ->Args({10000, 4096})
-    ->Threads(4)
-    ->Threads(1);
+    ->Apply(&default_multiple_alloc_fix_size)
+    // reduce iterations, as this benchmark is slower than others
+    ->Iterations(50000)
+    ->Apply(&singlethreaded);
 
 UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark, os_provider,
                               fixed_alloc_size,
                               provider_allocator<os_provider>);
 UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, os_provider)
-    ->Args({10000, 4096})
-    ->Threads(4)
-    ->Threads(1);
+    ->Apply(&default_multiple_alloc_fix_size)
+    // reduce iterations, as this benchmark is slower than others
+    ->Iterations(50000)
+    ->Apply(&singlethreaded);
 
-#ifdef UMF_POOL_DISJOINT_ENABLED
 UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark, disjoint_pool_fix,
                               fixed_alloc_size,
                               pool_allocator<disjoint_pool<os_provider>>);
 UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, disjoint_pool_fix)
-    ->Args({10000, 4096})
-    ->Threads(4)
-    ->Threads(1);
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
 
-// TODO: debug why this crashes
-/*UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark,
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark,
                               disjoint_pool_uniform, uniform_alloc_size,
                               pool_allocator<disjoint_pool<os_provider>>);
 UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, disjoint_pool_uniform)
-    ->Args({10000, 0, 8, 64 * 1024, 8})
-    ->Threads(4)
-    ->Threads(1);
-*/
-#endif
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
 
 #ifdef UMF_POOL_JEMALLOC_ENABLED
 UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark, jemalloc_pool_fix,
                               fixed_alloc_size,
                               pool_allocator<jemalloc_pool<os_provider>>);
 UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, jemalloc_pool_fix)
-    ->Args({10000, 4096})
-    ->Threads(4)
-    ->Threads(1);
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
 
 UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark,
                               jemalloc_pool_uniform, uniform_alloc_size,
                               pool_allocator<jemalloc_pool<os_provider>>);
 UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, jemalloc_pool_uniform)
-    ->Args({1000, 8, 64 * 1024, 8})
-    ->Threads(4)
-    ->Threads(1);
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
 
 #endif
 
@@ -345,18 +123,144 @@ UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark, scalable_pool_fix,
                               pool_allocator<scalable_pool<os_provider>>);
 
 UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, scalable_pool_fix)
-    ->Args({10000, 4096})
-    ->Threads(4)
-    ->Threads(1);
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
 
 UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark,
                               scalable_pool_uniform, uniform_alloc_size,
                               pool_allocator<scalable_pool<os_provider>>);
 
 UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, scalable_pool_uniform)
-    ->Args({10000, 8, 64 * 1024, 8})
-    ->Threads(4)
-    ->Threads(1);
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
+
+#endif
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark,
+                              proxy_pool_fixedprovider, fixed_alloc_size,
+                              pool_allocator<proxy_pool<fixed_provider>>);
+
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark,
+                         proxy_pool_fixedprovider)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&singlethreaded)
+    // reduce iterations, to match os_provider benchmark
+    ->Iterations(50000);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark, fixed_provider,
+                              fixed_alloc_size,
+                              provider_allocator<fixed_provider>);
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, fixed_provider)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&singlethreaded)
+    // reduce iterations, to match os_provider benchmark
+    ->Iterations(50000);
+
+// peak
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, glibc_fix, fixed_alloc_size,
+                              glibc_malloc);
+
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, glibc_fix)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, glibc_uniform,
+                              uniform_alloc_size, glibc_malloc);
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, glibc_uniform)
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, disjoint_pool_fix,
+                              fixed_alloc_size,
+                              pool_allocator<disjoint_pool<os_provider>>);
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, disjoint_pool_fix)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, disjoint_pool_uniform,
+                              uniform_alloc_size,
+                              pool_allocator<disjoint_pool<os_provider>>);
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, disjoint_pool_uniform)
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
+
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, jemalloc_pool_fix,
+                              fixed_alloc_size,
+                              pool_allocator<jemalloc_pool<os_provider>>);
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, jemalloc_pool_fix)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, jemalloc_pool_uniform,
+                              uniform_alloc_size,
+                              pool_allocator<jemalloc_pool<os_provider>>);
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, jemalloc_pool_uniform)
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
+
+#endif
+
+#ifdef UMF_POOL_SCALABLE_ENABLED
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, scalable_pool_fix,
+                              fixed_alloc_size,
+                              pool_allocator<scalable_pool<os_provider>>);
+
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, scalable_pool_fix)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, scalable_pool_uniform,
+                              uniform_alloc_size,
+                              pool_allocator<scalable_pool<os_provider>>);
+
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, scalable_pool_uniform)
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
 
 #endif
-BENCHMARK_MAIN();
+
+// stacked pool benchmarks
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark,
+                              disjoint_pool_stack_fix, fixed_alloc_size,
+                              pool_stacked_allocator<os_provider>);
+
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark,
+                         disjoint_pool_stack_fix)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark,
+                              disjoint_pool_stack_uniform, uniform_alloc_size,
+                              pool_stacked_allocator<os_provider>);
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark,
+                         disjoint_pool_stack_uniform)
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, disjoint_pool_stack_fix,
+                              fixed_alloc_size,
+                              pool_stacked_allocator<os_provider>);
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, disjoint_pool_stack_fix)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, disjoint_pool_stack_uniform,
+                              uniform_alloc_size,
+                              pool_stacked_allocator<os_provider>);
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, disjoint_pool_stack_uniform)
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
+
+//BENCHMARK_MAIN();
+int main(int argc, char **argv) {
+    if (initAffinityMask()) {
+        std::cerr << "initAffinityMask failed" << std::endl;
+        return -1;
+    }
+
+    benchmark::Initialize(&argc, argv);
+    benchmark::RunSpecifiedBenchmarks();
+    benchmark::Shutdown();
+}
diff --git a/benchmark/benchmark.hpp b/benchmark/benchmark.hpp
index ead6b39e75..201c9e3825 100644
--- a/benchmark/benchmark.hpp
+++ b/benchmark/benchmark.hpp
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -70,179 +70,256 @@
  * - Additional benchmarking scenarios can be created by extending `benchmark_interface`.
  */
 
-#include <benchmark/benchmark.h>
+#include <list>
+#include <malloc.h>
 #include <random>
+#include <stdexcept>
+
+#include <benchmark/benchmark.h>
 #include <umf/memory_pool.h>
 #include <umf/memory_provider.h>
 
-#include "benchmark_interfaces.hpp"
+#include "benchmark_size.hpp"
+#include "benchmark_umf.hpp"
 
 struct alloc_data {
     void *ptr;
     size_t size;
 };
 
-#define UMF_BENCHMARK_TEMPLATE_DEFINE(BaseClass, Method, ...)                  \
-    BENCHMARK_TEMPLATE_DEFINE_F(BaseClass, Method, __VA_ARGS__)                \
-    (benchmark::State & state) {                                               \
-        for (auto _ : state) {                                                 \
-            bench(state);                                                      \
-        }                                                                      \
+struct next_alloc_data {
+    bool alloc; // true if allocation, false if deallocation
+    size_t offset;
+    size_t size;
+};
+
+#ifndef WIN32
+std::vector<cpu_set_t> affinityMask;
+
+int initAffinityMask() {
+    cpu_set_t mask;
+    CPU_ZERO(&mask);
+
+    if (sched_getaffinity(0, sizeof(mask), &mask) == -1) {
+        perror("sched_getaffinity");
+        return 1;
+    }
+
+    for (int cpu = 0; cpu < CPU_SETSIZE; cpu++) {
+        if (CPU_ISSET(cpu, &mask)) {
+            cpu_set_t mask;
+            CPU_ZERO(&mask);
+            CPU_SET(cpu, &mask);
+            affinityMask.push_back(mask);
+        }
+    }
+    // we reverse affinityMask to avoid using cpu 0 if possible.
+    // CPU 0 is usually the most used one by other applications on the system.
+    std::reverse(affinityMask.begin(), affinityMask.end());
+    return 0;
+}
+
+void setAffinity(benchmark::State &state) {
+    size_t tid = state.thread_index();
+    if (tid >= affinityMask.size()) {
+        state.SkipWithError("Not enough CPUs available to set affinity");
     }
 
-#define UMF_BENCHMARK_REGISTER_F(BaseClass, Method)                            \
-    BENCHMARK_REGISTER_F(BaseClass, Method)                                    \
-        ->ArgNames(                                                            \
-            BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method)::argsName())      \
-        ->Name(BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method)::name())       \
-        ->MinWarmUpTime(1)
+    auto &mask = affinityMask[tid];
 
-class fixed_alloc_size : public alloc_size_interface {
+    if (sched_setaffinity(0, sizeof(mask), &mask) != 0) {
+        state.SkipWithError("Failed to set affinity");
+    }
+}
+
+#else
+int initAffinityMask() {
+    printf(
+        "Affinity set not supported on Windows, benchmark can be unstable\n");
+    return 0;
+}
+
+void setAffinity([[maybe_unused]] benchmark::State &state) {
+    // Not implemented for Windows
+}
+
+#endif
+
+// function that ensures that all threads have reached the same point
+inline void waitForAllThreads(const benchmark::State &state) {
+    static std::atomic<int> count{0};
+    static std::atomic<int> generation{0};
+
+    const int totalThreads = state.threads();
+    int gen = generation.load(std::memory_order_relaxed);
+
+    int c = count.fetch_add(1, std::memory_order_acq_rel) + 1;
+
+    if (c == totalThreads) {
+        // Last thread - reset count and bump generation
+        count.store(0, std::memory_order_relaxed);
+        generation.fetch_add(1, std::memory_order_acq_rel);
+    } else {
+        // Not the last thread: spin until the generation changes
+        while (generation.load(std::memory_order_acquire) == gen) {
+            std::this_thread::yield();
+        }
+    }
+}
+
+template <typename Provider, typename = std::enable_if_t<std::is_base_of<
+                                 provider_interface, Provider>::value>>
+class provider_allocator : public allocator_interface {
   public:
     unsigned SetUp(::benchmark::State &state, unsigned argPos) override {
-        size = state.range(argPos);
-        return argPos + 1;
+        provider.SetUp(state);
+        return argPos;
     }
-    void TearDown([[maybe_unused]] ::benchmark::State &state) override {}
-    size_t nextSize() override { return size; };
-    static std::vector<std::string> argsName() { return {"size"}; }
 
-  private:
-    size_t size;
-};
+    void preBench(::benchmark::State &state) override {
+        provider.preBench(state);
+    }
 
-class uniform_alloc_size : public alloc_size_interface {
-    using distribution = std::uniform_int_distribution<int64_t>;
+    void postBench(::benchmark::State &state) override {
+        provider.postBench(state);
+    }
 
-  public:
-    unsigned SetUp(::benchmark::State &state, unsigned argPos) override {
-        auto min = state.range(argPos++);
-        auto max = state.range(argPos++);
-        auto gran = state.range(argPos++);
-        if (min % gran != 0 && max % gran != 0) {
-            state.SkipWithError("min and max must be divisible by granularity");
-            return argPos;
-        }
+    void TearDown(::benchmark::State &state) override {
+        provider.TearDown(state);
+    }
 
-        dist.param(distribution::param_type(min / gran, max / gran));
-        multiplier = gran;
-        return argPos;
+    void *benchAlloc(size_t size) override {
+        void *ptr;
+        if (umfMemoryProviderAlloc(provider.provider, size, 0, &ptr) !=
+            UMF_RESULT_SUCCESS) {
+            return NULL;
+        }
+        return ptr;
     }
-    void TearDown([[maybe_unused]] ::benchmark::State &state) override {}
-    size_t nextSize() override { return dist(generator) * multiplier; }
-    static std::vector<std::string> argsName() {
-        return {"min size", "max size", "granularity"};
+
+    void benchFree(void *ptr, size_t size) override {
+        umfMemoryProviderFree(provider.provider, ptr, size);
     }
 
+    static std::string name() { return Provider::name(); }
+
   private:
-    std::default_random_engine generator;
-    distribution dist;
-    size_t multiplier;
+    Provider provider;
 };
 
-// This class benchmarks speed of alloc() operations.
-template <
-    typename Size, typename Alloc,
-    typename =
-        std::enable_if_t<std::is_base_of<alloc_size_interface, Size>::value>,
-    typename =
-        std::enable_if_t<std::is_base_of<allocator_interface, Alloc>::value>>
-class alloc_benchmark : public benchmark_interface<Size, Alloc> {
+// TODO: assert Pool to be a pool_interface<provider_interface>.
+template <typename Pool> class pool_allocator : public allocator_interface {
   public:
-    size_t max_allocs = 1000;
-    size_t pre_allocs = 0;
-    void SetUp(::benchmark::State &state) override {
-        if (state.thread_index() != 0) {
-            return;
-        }
+    virtual unsigned SetUp(::benchmark::State &state,
+                           unsigned argPos) override {
+        pool.SetUp(state);
+        return argPos;
+    }
 
-        // unpack arguments
-        int argPos = 0;
-        max_allocs = state.range(argPos++);
-        pre_allocs = state.range(argPos++);
-        // pass rest of the arguments to "alloc_size" and "allocator"
-        argPos = base::alloc_size.SetUp(state, argPos);
-        base::allocator.SetUp(state, argPos);
-
-        // initialize allocations tracking vectors (one per thread)
-        // and iterators for these vectors.
-        allocations.resize(state.threads());
-        iters.resize(state.threads());
-
-        for (auto &i : iters) {
-            i = pre_allocs;
-        }
+    virtual void preBench(::benchmark::State &state) override {
+        pool.preBench(state);
+    }
+    virtual void postBench(::benchmark::State &state) override {
+        pool.postBench(state);
+    }
 
-        // do "pre_alloc" allocations before actual benchmark.
-        for (auto &i : allocations) {
-            i.resize(max_allocs + pre_allocs);
+    virtual void TearDown(::benchmark::State &state) override {
+        pool.TearDown(state);
+    }
 
-            for (size_t j = 0; j < pre_allocs; j++) {
-                i[j].ptr =
-                    base::allocator.benchAlloc(base::alloc_size.nextSize());
-                if (i[j].ptr == NULL) {
-                    state.SkipWithError("preallocation failed");
-                    return;
-                }
-                i[j].size = base::alloc_size.nextSize();
-            }
-        }
+    virtual void *benchAlloc(size_t size) override {
+        return umfPoolMalloc(pool.pool, size);
     }
 
-    void TearDown(::benchmark::State &state) override {
-        if (state.thread_index() != 0) {
-            return;
-        }
-        for (auto &i : allocations) {
-            for (auto &j : i) {
-                if (j.ptr != NULL) {
-                    base::allocator.benchFree(j.ptr, j.size);
-                    j.ptr = NULL;
-                    j.size = 0;
-                }
+    virtual void benchFree(void *ptr, [[maybe_unused]] size_t size) override {
+        umfPoolFree(pool.pool, ptr);
+    }
+
+    static std::string name() { return Pool::name(); }
+
+  protected:
+    Pool pool;
+};
+
+template <typename Provider>
+class pool_stacked_allocator
+    : public pool_allocator<disjoint_pool_stack<Provider>> {
+    using base = pool_allocator<disjoint_pool_stack<Provider>>;
+
+  public:
+    virtual void preBench([[maybe_unused]] ::benchmark::State &state) override {
+        // we do not measure fragmentation for stack pools
+    }
+    virtual void
+    postBench([[maybe_unused]] ::benchmark::State &state) override {
+        // we do not measure fragmentation for stack pools
+    }
+    void *benchAlloc(size_t size) override {
+        static thread_local int counter = 0;
+        static auto pool_number = base::pool.pools.size();
+        // stacked pools has limited space, so we might need a few
+        // tries to find one with free space
+        auto retry = pool_number;
+        while (retry--) {
+            void *ptr = umfPoolMalloc(
+                base::pool.pools[(++counter % pool_number)], size);
+            if (ptr != NULL) {
+                return ptr;
             }
         }
+        return NULL;
+    }
 
-        base::TearDown(state);
+    void benchFree(void *ptr, [[maybe_unused]] size_t size) override {
+        umfFree(ptr);
     }
+};
 
-    void bench(benchmark::State &state) override {
-        auto tid = state.thread_index();
-        auto s = base::alloc_size.nextSize();
-        auto &i = iters[tid];
-        allocations[tid][i].ptr = base::allocator.benchAlloc(s);
-        if (allocations[tid][i].ptr == NULL) {
-            state.SkipWithError("allocation failed");
-            return;
+template <typename Size, typename Allocator>
+struct benchmark_interface : public benchmark::Fixture {
+    int parseArgs(::benchmark::State &state, int argPos) {
+        Size generator;
+        argPos = generator.SetUp(state, argPos);
+        argPos = allocator.SetUp(state, argPos);
+        alloc_sizes.resize(state.threads());
+        for (auto &i : alloc_sizes) {
+            i = generator;
         }
-        allocations[tid][i].size = s;
-        i++;
-        if (i >= max_allocs + pre_allocs) {
-            // This benchmark tests only allocations -
-            // if allocation tracker is full we pause benchmark to dealloc all allocations -
-            // excluding pre-allocated ones.
-            state.PauseTiming();
-            while (i > pre_allocs) {
-                auto &allocation = allocations[tid][--i];
-                base::allocator.benchFree(allocation.ptr, allocation.size);
-                allocation.ptr = NULL;
-                allocation.size = 0;
-            }
-            state.ResumeTiming();
+        return argPos;
+    }
+    void SetUp(::benchmark::State &state) { parseArgs(state, 0); }
+
+    void TearDown(::benchmark::State &state) {
+        for (auto &i : alloc_sizes) {
+            i.TearDown(state);
         }
+        allocator.TearDown(state);
     }
-    static std::vector<std::string> argsName() {
-        auto n = benchmark_interface<Size, Alloc>::argsName();
-        std::vector<std::string> res = {"max_allocs", "pre_allocs"};
-        res.insert(res.end(), n.begin(), n.end());
+
+    void bench([[maybe_unused]] ::benchmark::State &state){};
+
+    virtual std::vector<std::string> argsName() {
+        auto s = Size::argsName();
+        auto a = Allocator::argsName();
+        std::vector<std::string> res = {};
+        res.insert(res.end(), s.begin(), s.end());
+        res.insert(res.end(), a.begin(), a.end());
         return res;
     }
-    static std::string name() { return base::name() + "/alloc"; }
 
-  protected:
-    using base = benchmark_interface<Size, Alloc>;
-    std::vector<std::vector<alloc_data>> allocations;
-    std::vector<size_t> iters;
+    virtual std::string name() { return Allocator::name(); }
+
+    static void defaultArgs(Benchmark *benchmark) {
+        auto *bench =
+            static_cast<benchmark_interface<Size, Allocator> *>(benchmark);
+        benchmark->ArgNames(bench->argsName())->Name(bench->name());
+    }
+
+    void custom_counters(::benchmark::State &state) {
+        allocator.custom_counters(state);
+    }
+    std::vector<Size> alloc_sizes;
+    Allocator allocator;
 };
 
 // This class benchmarks performance of random deallocations and (re)allocations
@@ -252,131 +329,335 @@ template <
         std::enable_if_t<std::is_base_of<alloc_size_interface, Size>::value>,
     typename =
         std::enable_if_t<std::is_base_of<allocator_interface, Alloc>::value>>
-class multiple_malloc_free_benchmark : public alloc_benchmark<Size, Alloc> {
-    using distribution = std::uniform_int_distribution<size_t>;
-    using base = alloc_benchmark<Size, Alloc>;
+class multiple_malloc_free_benchmark : public benchmark_interface<Size, Alloc> {
+  protected:
+    template <class T> using vector2d = std::vector<std::vector<T>>;
+    using base = benchmark_interface<Size, Alloc>;
+    int allocsPerIterations = 10;
+    bool thread_local_allocations = true;
+    size_t max_allocs = 0;
+
+    vector2d<alloc_data> allocations;
+    vector2d<next_alloc_data> next;
+    using next_alloc_data_iterator =
+        typename std::vector<next_alloc_data>::const_iterator;
+    std::vector<std::unique_ptr<next_alloc_data_iterator>> next_iter;
+    int64_t iterations;
+    bool log_fragmentation;
+    multiple_malloc_free_benchmark(bool log_fragmentation = true)
+        : log_fragmentation(log_fragmentation) {}
 
   public:
-    int reallocs = 100;
     void SetUp(::benchmark::State &state) override {
-        if (state.thread_index() != 0) {
-            return;
+        auto tid = state.thread_index();
+
+        if (tid == 0) {
+            // unpack arguments
+            iterations = state.max_iterations;
+            int argPos = 0;
+            max_allocs = state.range(argPos++);
+            thread_local_allocations = state.range(argPos++);
+            base::parseArgs(state, argPos);
+
+            allocations.resize(state.threads());
+            next.resize(state.threads());
+            next_iter.resize(state.threads());
+
+#ifndef WIN32
+            // Ensure that system malloc does not have memory pooled on the heap
+            malloc_trim(0);
+#endif
         }
-        // unpack arguments
-        int argPos = 0;
-        base::max_allocs = state.range(argPos++);
-
-        // pass rest of the arguments to "alloc_size" and "allocator"
-        argPos = base::alloc_size.SetUp(state, argPos);
-        base::allocator.SetUp(state, argPos);
-
-        // perform initial allocations which will be later freed and reallocated
-        base::allocations.resize(state.threads());
-        for (auto &i : base::allocations) {
-            i.resize(base::max_allocs);
-
-            for (size_t j = 0; j < base::max_allocs; j++) {
-                i[j].ptr =
-                    base::allocator.benchAlloc(base::alloc_size.nextSize());
-                if (i[j].ptr == NULL) {
-                    state.SkipWithError("preallocation failed");
-                    return;
-                }
-                i[j].size = base::alloc_size.nextSize();
-            }
+        setAffinity(state);
+        // sync thread to ensure that thread 0 parsed args and did all initialization
+        waitForAllThreads(state);
+        // Prepare workload for warp up
+        prealloc(state);
+        prepareWorkload(state);
+        // Start warm up with all threads at once
+        waitForAllThreads(state);
+        // warm up
+        for (int j = 0; j < iterations; j++) {
+            bench(state);
         }
-        dist.param(distribution::param_type(0, base::max_allocs - 1));
+        waitForAllThreads(state);
+        // prepare workload for actual benchmark.
+        freeAllocs(state);
+
+        prealloc(state);
+        prepareWorkload(state);
+        waitForAllThreads(state);
+        base::allocator.preBench(state);
     }
 
-    void bench(benchmark::State &state) override {
+    void TearDown(::benchmark::State &state) override {
+        base::allocator.postBench(state);
         auto tid = state.thread_index();
-        auto &allocation = base::allocations[tid];
-        std::vector<size_t> to_alloc;
-        for (int j = 0; j < reallocs; j++) {
-            auto idx = dist(generator);
-            if (allocation[idx].ptr == NULL) {
-                continue;
+        if (tid == 0 && log_fragmentation) {
+            size_t current_memory_allocated = 0;
+            for (const auto &allocationsPerThread : allocations) {
+                for (const auto &allocation : allocationsPerThread) {
+                    current_memory_allocated += allocation.size;
+                }
+            }
+
+            auto memory_used = state.counters["provider_memory_allocated"];
+
+            if (memory_used != 0) {
+                state.counters["benchmark_memory_allocated"] =
+                    static_cast<double>(current_memory_allocated);
+                state.counters["memory_overhead"] =
+                    100.0 * (memory_used - current_memory_allocated) /
+                    memory_used;
+            } else {
+                state.counters.erase("provider_memory_allocated");
             }
-            to_alloc.push_back(idx);
+        }
 
-            base::allocator.benchFree(allocation[idx].ptr,
-                                      allocation[idx].size);
-            allocation[idx].ptr = NULL;
-            allocation[idx].size = 0;
+        waitForAllThreads(state);
+        freeAllocs(state);
+        waitForAllThreads(state);
+        if (tid == 0) {
+            // release memory used by benchmark
+            next.clear();
+            next_iter.clear();
+            allocations.clear();
         }
+        base::TearDown(state);
+    }
 
-        for (auto idx : to_alloc) {
-            auto s = base::alloc_size.nextSize();
-            allocation[idx].ptr = base::allocator.benchAlloc(s);
-            if (allocation[idx].ptr == NULL) {
-                state.SkipWithError("allocation failed");
+    void bench(benchmark::State &state) {
+        auto tid = state.thread_index();
+        auto &allocation = allocations[tid];
+        auto &iter = next_iter[tid];
+
+        for (int i = 0; i < allocsPerIterations; i++) {
+            auto &n = *(*iter)++;
+            auto &alloc = allocation[n.offset];
+            if (n.alloc) {
+                alloc.ptr = base::allocator.benchAlloc(n.size);
+                if (alloc.ptr == NULL) {
+                    state.SkipWithError("allocation failed");
+                }
+                alloc.size = n.size;
+            } else {
+                base::allocator.benchFree(alloc.ptr, alloc.size);
+                alloc.ptr = NULL;
+                alloc.size = 0;
             }
-            allocation[idx].size = s;
         }
     }
 
-    static std::string name() {
-        return base::base::name() + "/multiple_malloc_free";
+    virtual std::string name() {
+        return base::name() + "/multiple_malloc_free";
     }
-    static std::vector<std::string> argsName() {
+
+    virtual std::vector<std::string> argsName() {
         auto n = benchmark_interface<Size, Alloc>::argsName();
-        std::vector<std::string> res = {"max_allocs"};
+        std::vector<std::string> res = {"max_allocs",
+                                        "thread_local_allocations"};
         res.insert(res.end(), n.begin(), n.end());
         return res;
     }
-    std::default_random_engine generator;
-    distribution dist;
-};
 
-template <typename Provider, typename = std::enable_if_t<std::is_base_of<
-                                 provider_interface, Provider>::value>>
-class provider_allocator : public allocator_interface {
-  public:
-    unsigned SetUp(::benchmark::State &state, unsigned r) override {
-        provider.SetUp(state);
-        return r;
+  private:
+    virtual void prealloc(benchmark::State &state) {
+        auto tid = state.thread_index();
+        auto &i = allocations[tid];
+        i.resize(max_allocs);
+        auto sizeGenerator = base::alloc_sizes[tid];
+
+        // Preallocate half of the available slots, for allocations
+        for (size_t j = 0; j < max_allocs / 2; j++) {
+            auto size = sizeGenerator.nextSize();
+            i[j].ptr = base::allocator.benchAlloc(size);
+            if (i[j].ptr == NULL) {
+                state.SkipWithError("preallocation failed");
+                return;
+            }
+            i[j].size = size;
+        }
     }
 
-    void TearDown(::benchmark::State &state) override {
-        provider.TearDown(state);
+    void freeAllocs(benchmark::State &state) {
+        auto tid = state.thread_index();
+        auto &i = allocations[tid];
+        for (auto &j : i) {
+            if (j.ptr != NULL) {
+                base::allocator.benchFree(j.ptr, j.size);
+                j.ptr = NULL;
+                j.size = 0;
+            }
+        }
     }
 
-    void *benchAlloc(size_t size) override {
-        void *ptr;
-        if (umfMemoryProviderAlloc(provider.provider, size, 0, &ptr) !=
-            UMF_RESULT_SUCCESS) {
-            return NULL;
+    virtual void prepareWorkload(benchmark::State &state) {
+        auto tid = state.thread_index();
+        auto &n = next[tid];
+
+        // Create generators for random index selection and binary decision.
+        using distribution = std::uniform_int_distribution<size_t>;
+        std::default_random_engine generator;
+        distribution dist_offset(0, max_allocs - 1);
+        distribution dist_opt_type(0, 1);
+        generator.seed(0);
+
+        auto sizeGenerator = base::alloc_sizes[tid];
+        std::vector<size_t> free;
+        std::vector<size_t> allocated;
+        free.reserve(max_allocs / 2);
+        allocated.reserve(max_allocs / 2);
+        // Preallocate memory: initially, half the indices are allocated.
+        // See prealloc() function;
+        size_t i = 0;
+        while (i < max_allocs / 2) {
+            allocated.push_back(i++);
+        }
+        // The remaining indices are marked as free.
+        while (i < max_allocs) {
+            free.push_back(i++);
         }
-        return ptr;
-    }
-    void benchFree(void *ptr, size_t size) override {
-        umfMemoryProviderFree(provider.provider, ptr, size);
-    }
-    static std::string name() { return Provider::name(); }
 
-  private:
-    Provider provider;
+        n.clear();
+        for (int64_t j = 0; j < state.max_iterations * allocsPerIterations;
+             j++) {
+            // Decide whether to allocate or free:
+            // - If no allocations exist, allocation is forced.
+            // - If there is maximum number of allocation, free is forced
+            // - Otherwise, use a binary random choice (0 or 1)
+            if (allocated.empty() ||
+                (dist_opt_type(generator) == 0 && !free.empty())) {
+                // Allocation:
+                std::swap(free[dist_offset(generator) % free.size()],
+                          free.back());
+                auto offset = free.back();
+                free.pop_back();
+
+                n.push_back({true, offset, sizeGenerator.nextSize()});
+                allocated.push_back(offset);
+            } else {
+                // Free
+                std::swap(allocated[dist_offset(generator) % allocated.size()],
+                          allocated.back());
+                auto offset = allocated.back();
+                allocated.pop_back();
+
+                n.push_back({false, offset, 0});
+                free.push_back(offset);
+            }
+        }
+
+        next_iter[tid] = std::make_unique<next_alloc_data_iterator>(n.cbegin());
+    }
 };
+// This class benchmarks performance by randomly allocating and freeing memory.
+// Initially, it slowly increases the memory footprint, and later decreases it.
+template <
+    typename Size, typename Alloc,
+    typename =
+        std::enable_if_t<std::is_base_of<alloc_size_interface, Size>::value>,
+    typename =
+        std::enable_if_t<std::is_base_of<allocator_interface, Alloc>::value>>
+class peak_alloc_benchmark
+    : public multiple_malloc_free_benchmark<Size, Alloc> {
+
+    using base = multiple_malloc_free_benchmark<Size, Alloc>;
 
-// TODO: assert Pool to be a pool_interface<provider_interface>.
-template <typename Pool> class pool_allocator : public allocator_interface {
   public:
-    unsigned SetUp(::benchmark::State &state, unsigned r) override {
-        pool.SetUp(state);
-        return r;
-    }
+    peak_alloc_benchmark() : base(false) {}
 
-    void TearDown(::benchmark::State &state) override { pool.TearDown(state); }
+    virtual void prepareWorkload(benchmark::State &state) override {
+        // Retrieve the thread index and corresponding operation buffer.
+        auto tid = state.thread_index();
+        auto &n = this->next[tid];
+
+        // Set up the random generators for index selection and decision making.
+        std::default_random_engine generator;
+        std::uniform_int_distribution<size_t> dist_offset(0,
+                                                          this->max_allocs - 1);
+        std::uniform_real_distribution<double> dist_opt_type(0, 1);
+        generator.seed(0);
+        auto sizeGenerator = this->alloc_sizes[tid];
+
+        n.clear();
+        std::vector<size_t> free;
+        std::vector<size_t> allocated;
+        free.reserve(this->max_allocs);
+        // Initially, all indices are available.
+        for (size_t i = 0; i < this->max_allocs; i++) {
+            free.push_back(i);
+        }
 
-    virtual void *benchAlloc(size_t size) override {
-        return umfPoolMalloc(pool.pool, size);
-    }
-    virtual void benchFree(void *ptr, [[maybe_unused]] size_t size) override {
-        umfPoolFree(pool.pool, ptr);
+        // Total number of allocation/free operations to simulate.
+        int64_t operations_number =
+            state.max_iterations * this->allocsPerIterations;
+        for (int64_t j = 0; j < operations_number; j++) {
+            int64_t target_allocation;
+
+            // Determine the target number of allocations based on the progress of the iterations.
+            // In the first half of the iterations, the target allocation increases linearly.
+            // In the second half, it decreases linearly.
+            if (j < operations_number / 2) {
+                target_allocation = 2 * static_cast<int64_t>(this->max_allocs) *
+                                    j / operations_number;
+            } else {
+                target_allocation = -2 *
+                                        static_cast<int64_t>(this->max_allocs) *
+                                        j / operations_number +
+                                    2 * static_cast<int64_t>(this->max_allocs);
+            }
+
+            // x represents the gap between the target and current allocations.
+            auto x = static_cast<double>(target_allocation -
+                                         static_cast<double>(allocated.size()));
+
+            // Use a normal CDF with high sigma so that when x is positive,
+            // we are slightly more likely to allocate,
+            // and when x is negative, slightly more likely to free memory,
+            // keeping the overall change gradual.
+
+            const double sigma = 1000;
+            auto cdf = normalCDF(x, sigma);
+
+            // Decide whether to allocate or free:
+            // - If no allocations exist, allocation is forced.
+            // - If there is maximum number of allocation, free is forced
+            // - Otherwise, Based on the computed probability, choose whether to allocate or free
+            if (allocated.empty() ||
+                (!free.empty() && cdf > dist_opt_type(generator))) {
+                // Allocation
+                std::swap(free[dist_offset(generator) % free.size()],
+                          free.back());
+                auto offset = free.back();
+                free.pop_back();
+                n.push_back({true, offset, sizeGenerator.nextSize()});
+                allocated.push_back(offset);
+            } else {
+                // Free
+                std::swap(allocated[dist_offset(generator) % allocated.size()],
+                          allocated.back());
+                auto offset = allocated.back();
+                allocated.pop_back();
+                n.push_back({false, offset, 0});
+                free.push_back(offset);
+            }
+        }
+
+        this->next_iter[tid] =
+            std::make_unique<std::vector<next_alloc_data>::const_iterator>(
+                n.cbegin());
     }
 
-    static std::string name() { return Pool::name(); }
+    virtual void prealloc(benchmark::State &state) {
+        auto tid = state.thread_index();
+        auto &i = base::allocations[tid];
+        i.resize(base::max_allocs);
+    }
+    virtual std::string name() { return base::base::name() + "/peak_alloc"; }
 
   private:
-    Pool pool;
+    // Function to calculate the CDF of a normal distribution
+    double normalCDF(double x, double sigma = 1.0, double mu = 0.0) {
+        return 0.5 * (1 + std::erf((x - mu) / (sigma * std::sqrt(2.0))));
+    }
 };
diff --git a/benchmark/benchmark_interfaces.hpp b/benchmark/benchmark_interfaces.hpp
deleted file mode 100644
index 8681160626..0000000000
--- a/benchmark/benchmark_interfaces.hpp
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright (C) 2024 Intel Corporation
- *
- * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- *
- */
-
-#include <string>
-#include <thread>
-#include <vector>
-
-#include <benchmark/benchmark.h>
-#include <umf/memory_pool.h>
-#include <umf/memory_provider.h>
-
-class alloc_size_interface {
-  public:
-    virtual unsigned SetUp([[maybe_unused]] ::benchmark::State &state,
-                           [[maybe_unused]] unsigned argPos) = 0;
-    virtual void TearDown([[maybe_unused]] ::benchmark::State &state) = 0;
-    virtual size_t nextSize() = 0;
-    static std::vector<std::string> argsName() { return {""}; };
-};
-
-class allocator_interface {
-  public:
-    virtual unsigned SetUp([[maybe_unused]] ::benchmark::State &state,
-                           [[maybe_unused]] unsigned argPos) = 0;
-    virtual void TearDown([[maybe_unused]] ::benchmark::State &state) = 0;
-    virtual void *benchAlloc(size_t size) = 0;
-    virtual void benchFree(void *ptr, [[maybe_unused]] size_t size) = 0;
-    static std::vector<std::string> argsName() { return {}; }
-};
-
-template <typename Size, typename Allocator>
-struct benchmark_interface : public benchmark::Fixture {
-    void SetUp(::benchmark::State &state) {
-        int argPos = alloc_size.SetUp(state, 0);
-        allocator.SetUp(state, argPos);
-    }
-    void TearDown(::benchmark::State &state) {
-        alloc_size.TearDown(state);
-        allocator.TearDown(state);
-    }
-
-    virtual void bench(::benchmark::State &state) = 0;
-
-    static std::vector<std::string> argsName() {
-        auto s = Size::argsName();
-        auto a = Allocator::argsName();
-        std::vector<std::string> res = {};
-        res.insert(res.end(), s.begin(), s.end());
-        res.insert(res.end(), a.begin(), a.end());
-        return res;
-    }
-    static std::string name() { return Allocator::name(); }
-
-    Size alloc_size;
-    Allocator allocator;
-};
-
-struct provider_interface {
-    umf_memory_provider_handle_t provider = NULL;
-    virtual void SetUp(::benchmark::State &state) {
-        if (state.thread_index() != 0) {
-            return;
-        }
-        auto umf_result =
-            umfMemoryProviderCreate(getOps(), getParams(), &provider);
-        if (umf_result != UMF_RESULT_SUCCESS) {
-            state.SkipWithError("umfMemoryProviderCreate() failed");
-        }
-    }
-
-    virtual void TearDown([[maybe_unused]] ::benchmark::State &state) {
-        if (state.thread_index() != 0) {
-            return;
-        }
-
-        if (provider) {
-            umfMemoryProviderDestroy(provider);
-        }
-    }
-
-    virtual umf_memory_provider_ops_t *getOps() { return nullptr; }
-    virtual void *getParams() { return nullptr; }
-};
-
-template <typename T,
-          typename =
-              std::enable_if_t<std::is_base_of<provider_interface, T>::value>>
-struct pool_interface {
-    virtual void SetUp(::benchmark::State &state) {
-        provider.SetUp(state);
-        if (state.thread_index() != 0) {
-            return;
-        }
-        auto umf_result = umfPoolCreate(getOps(state), provider.provider,
-                                        getParams(state), 0, &pool);
-        if (umf_result != UMF_RESULT_SUCCESS) {
-            state.SkipWithError("umfPoolCreate() failed");
-        }
-    }
-    virtual void TearDown([[maybe_unused]] ::benchmark::State &state) {
-        if (state.thread_index() != 0) {
-            return;
-        }
-        // TODO: The scalable pool destruction process can race with other threads
-        // performing TLS (Thread-Local Storage) destruction.
-        // As a temporary workaround, we introduce a delay (sleep)
-        // to ensure the pool is destroyed only after all threads have completed.
-        // Issue: #933
-        std::this_thread::sleep_for(std::chrono::milliseconds(500));
-        if (pool) {
-            umfPoolDestroy(pool);
-        }
-    };
-
-    virtual umf_memory_pool_ops_t *
-    getOps([[maybe_unused]] ::benchmark::State &state) {
-        return nullptr;
-    }
-    virtual void *getParams([[maybe_unused]] ::benchmark::State &state) {
-        return nullptr;
-    }
-    T provider;
-    umf_memory_pool_handle_t pool;
-};
diff --git a/benchmark/benchmark_size.hpp b/benchmark/benchmark_size.hpp
new file mode 100644
index 0000000000..44e4bf1da8
--- /dev/null
+++ b/benchmark/benchmark_size.hpp
@@ -0,0 +1,63 @@
+/*
+ * 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
+ *
+ */
+
+#include <benchmark/benchmark.h>
+#include <string>
+#include <vector>
+
+class alloc_size_interface {
+  public:
+    virtual unsigned SetUp([[maybe_unused]] ::benchmark::State &state,
+                           [[maybe_unused]] unsigned argPos) = 0;
+    virtual void TearDown([[maybe_unused]] ::benchmark::State &state) = 0;
+    virtual size_t nextSize() = 0;
+    static std::vector<std::string> argsName() { return {""}; };
+};
+
+class fixed_alloc_size : public alloc_size_interface {
+  public:
+    unsigned SetUp(::benchmark::State &state, unsigned argPos) override {
+        size = state.range(argPos);
+        return argPos + 1;
+    }
+    void TearDown([[maybe_unused]] ::benchmark::State &state) override {}
+    size_t nextSize() override { return size; };
+    static std::vector<std::string> argsName() { return {"size"}; }
+
+  private:
+    size_t size;
+};
+
+class uniform_alloc_size : public alloc_size_interface {
+    using distribution = std::uniform_int_distribution<int64_t>;
+
+  public:
+    unsigned SetUp(::benchmark::State &state, unsigned argPos) override {
+        auto min = state.range(argPos++);
+        auto max = state.range(argPos++);
+        auto gran = state.range(argPos++);
+        if (min % gran != 0 && max % gran != 0) {
+            state.SkipWithError("min and max must be divisible by granularity");
+            return argPos;
+        }
+        generator.seed(0);
+        dist.param(distribution::param_type(min / gran, max / gran));
+        multiplier = gran;
+        return argPos;
+    }
+    void TearDown([[maybe_unused]] ::benchmark::State &state) override {}
+    size_t nextSize() override { return dist(generator) * multiplier; }
+    static std::vector<std::string> argsName() {
+        return {"min_size", "max_size", "granularity"};
+    }
+
+  private:
+    std::default_random_engine generator;
+    distribution dist;
+    size_t multiplier = 1;
+};
diff --git a/benchmark/benchmark_umf.hpp b/benchmark/benchmark_umf.hpp
new file mode 100644
index 0000000000..d2d41b84b4
--- /dev/null
+++ b/benchmark/benchmark_umf.hpp
@@ -0,0 +1,483 @@
+/*
+ * 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
+ *
+ */
+#include <memory>
+#include <thread>
+
+#include <benchmark/benchmark.h>
+#include <umf/experimental/ctl.h>
+#include <umf/memory_pool.h>
+#include <umf/memory_provider.h>
+#include <umf/pools/pool_disjoint.h>
+#include <umf/pools/pool_proxy.h>
+
+#ifdef UMF_POOL_SCALABLE_ENABLED
+#include <umf/pools/pool_scalable.h>
+#endif
+#include <umf/providers/provider_fixed_memory.h>
+#include <umf/providers/provider_os_memory.h>
+
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+#include <umf/pools/pool_jemalloc.h>
+#endif
+
+struct provider_interface {
+    using params_ptr = std::unique_ptr<void, void (*)(void *)>;
+
+    umf_memory_provider_handle_t provider = NULL;
+    void SetUp(::benchmark::State &state) {
+        if (state.thread_index() != 0) {
+            return;
+        }
+        auto params = getParams(state);
+        auto umf_result =
+            umfMemoryProviderCreate(getOps(state), params.get(), &provider);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            state.SkipWithError("umfMemoryProviderCreate() failed");
+        }
+    }
+
+    void preBench([[maybe_unused]] ::benchmark::State &state) {
+        if (state.thread_index() != 0) {
+            return;
+        }
+        umfCtlExec("umf.provider.by_handle.{}.stats.peak_memory.reset", NULL, 0,
+                   provider);
+    }
+
+    void postBench([[maybe_unused]] ::benchmark::State &state) {
+        if (state.thread_index() != 0) {
+            return;
+        }
+        size_t arg;
+        umf_result_t ret =
+            umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory", &arg,
+                      sizeof(arg), provider);
+        if (ret == UMF_RESULT_SUCCESS) {
+            state.counters["provider_memory_allocated"] =
+                static_cast<double>(arg);
+        }
+    }
+
+    void TearDown([[maybe_unused]] ::benchmark::State &state) {
+        if (state.thread_index() != 0) {
+            return;
+        }
+
+        if (provider) {
+            umfMemoryProviderDestroy(provider);
+        }
+    }
+
+    virtual const umf_memory_provider_ops_t *
+    getOps([[maybe_unused]] ::benchmark::State &state) = 0;
+
+    virtual params_ptr getParams([[maybe_unused]] ::benchmark::State &state) {
+        return {nullptr, [](void *) {}};
+    }
+};
+
+template <typename T,
+          typename =
+              std::enable_if_t<std::is_base_of<provider_interface, T>::value>>
+struct pool_interface {
+    using params_ptr = std::unique_ptr<void, void (*)(void *)>;
+
+    void SetUp(::benchmark::State &state) {
+        provider.SetUp(state);
+        if (state.thread_index() != 0) {
+            return;
+        }
+        auto params = getParams(state);
+        auto umf_result = umfPoolCreate(getOps(state), provider.provider,
+                                        params.get(), 0, &pool);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            state.SkipWithError("umfPoolCreate() failed");
+        }
+    }
+
+    void preBench([[maybe_unused]] ::benchmark::State &state) {
+        provider.preBench(state);
+        if (state.thread_index() != 0) {
+            return;
+        }
+    }
+
+    void postBench([[maybe_unused]] ::benchmark::State &state) {
+        provider.postBench(state);
+        if (state.thread_index() != 0) {
+            return;
+        }
+    }
+
+    void TearDown([[maybe_unused]] ::benchmark::State &state) {
+        if (state.thread_index() != 0) {
+            return;
+        }
+        // TODO: The scalable pool destruction process can race with other threads
+        // performing TLS (Thread-Local Storage) destruction.
+        // As a temporary workaround, we introduce a delay (sleep)
+        // to ensure the pool is destroyed only after all threads have completed.
+        // Issue: #933
+        std::this_thread::sleep_for(std::chrono::milliseconds(500));
+        if (pool) {
+            umfPoolDestroy(pool);
+        }
+
+        provider.TearDown(state);
+    };
+
+    virtual const umf_memory_pool_ops_t *
+    getOps([[maybe_unused]] ::benchmark::State &state) = 0;
+
+    virtual params_ptr getParams([[maybe_unused]] ::benchmark::State &state) {
+        return {nullptr, [](void *) {}};
+    }
+
+    T provider;
+    umf_memory_pool_handle_t pool;
+};
+
+class allocator_interface {
+  public:
+    virtual unsigned SetUp([[maybe_unused]] ::benchmark::State &state,
+                           [[maybe_unused]] unsigned argPos) = 0;
+    virtual void preBench([[maybe_unused]] ::benchmark::State &state) = 0;
+    virtual void postBench([[maybe_unused]] ::benchmark::State &state) = 0;
+    virtual void TearDown([[maybe_unused]] ::benchmark::State &state) = 0;
+    virtual void *benchAlloc(size_t size) = 0;
+    virtual void benchFree(void *ptr, [[maybe_unused]] size_t size) = 0;
+    static std::vector<std::string> argsName() { return {}; }
+};
+
+struct glibc_malloc : public allocator_interface {
+    unsigned SetUp([[maybe_unused]] ::benchmark::State &state,
+                   unsigned argPos) override {
+        return argPos;
+    }
+    void preBench([[maybe_unused]] ::benchmark::State &state) override {}
+    void postBench([[maybe_unused]] ::benchmark::State &state) override {}
+    void TearDown([[maybe_unused]] ::benchmark::State &state) override {}
+    void *benchAlloc(size_t size) override { return malloc(size); }
+    void benchFree(void *ptr, [[maybe_unused]] size_t size) override {
+        free(ptr);
+    }
+    static std::string name() { return "glibc"; }
+};
+
+struct os_provider : public provider_interface {
+    provider_interface::params_ptr
+    getParams(::benchmark::State &state) override {
+        umf_os_memory_provider_params_handle_t raw_params = nullptr;
+        umfOsMemoryProviderParamsCreate(&raw_params);
+        if (!raw_params) {
+            state.SkipWithError("Failed to create os provider params");
+            return {nullptr, [](void *) {}};
+        }
+
+        // Use a lambda as the custom deleter
+        auto deleter = [](void *p) {
+            auto handle =
+                static_cast<umf_os_memory_provider_params_handle_t>(p);
+            umfOsMemoryProviderParamsDestroy(handle);
+        };
+
+        return {static_cast<provider_interface::params_ptr::element_type *>(
+                    raw_params),
+                deleter};
+    }
+
+    const umf_memory_provider_ops_t *
+    getOps([[maybe_unused]] ::benchmark::State &state) override {
+        return umfOsMemoryProviderOps();
+    }
+    static std::string name() { return "os_provider"; }
+};
+
+struct fixed_provider : public provider_interface {
+  private:
+    char *mem = NULL;
+    const size_t size = 1024 * 1024 * 1024; // 1GB
+  public:
+    void SetUp(::benchmark::State &state) {
+        if (state.thread_index() != 0) {
+            return;
+        }
+
+        if (!mem) {
+            mem = new char[size];
+        }
+
+        provider_interface::SetUp(state);
+    }
+
+    void TearDown(::benchmark::State &state) {
+        if (state.thread_index() != 0) {
+            return;
+        }
+
+        delete[] mem;
+        mem = nullptr;
+
+        provider_interface::TearDown(state);
+    }
+
+    provider_interface::params_ptr
+    getParams(::benchmark::State &state) override {
+        umf_fixed_memory_provider_params_handle_t raw_params = nullptr;
+        umfFixedMemoryProviderParamsCreate(mem, size, &raw_params);
+        if (!raw_params) {
+            state.SkipWithError("Failed to create fixed provider params");
+            return {nullptr, [](void *) {}};
+        }
+
+        // Use a lambda as the custom deleter
+        auto deleter = [](void *p) {
+            auto handle =
+                static_cast<umf_fixed_memory_provider_params_handle_t>(p);
+            umfFixedMemoryProviderParamsDestroy(handle);
+        };
+
+        return {static_cast<provider_interface::params_ptr::element_type *>(
+                    raw_params),
+                deleter};
+    }
+
+    const umf_memory_provider_ops_t *
+    getOps([[maybe_unused]] ::benchmark::State &state) override {
+        return umfFixedMemoryProviderOps();
+    }
+    static std::string name() { return "fixed_provider"; }
+};
+
+template <typename Provider>
+struct proxy_pool : public pool_interface<Provider> {
+    const umf_memory_pool_ops_t *
+    getOps([[maybe_unused]] ::benchmark::State &state) override {
+        return umfProxyPoolOps();
+    }
+
+    static std::string name() { return "proxy_pool<" + Provider::name() + ">"; }
+};
+
+template <typename Provider>
+struct disjoint_pool : public pool_interface<Provider> {
+    const umf_memory_pool_ops_t *
+    getOps([[maybe_unused]] ::benchmark::State &state) override {
+        return umfDisjointPoolOps();
+    }
+
+    typename pool_interface<Provider>::params_ptr
+    getParams(::benchmark::State &state) override {
+        umf_disjoint_pool_params_handle_t raw_params = nullptr;
+        auto ret = umfDisjointPoolParamsCreate(&raw_params);
+        if (ret != UMF_RESULT_SUCCESS) {
+            state.SkipWithError("Failed to create disjoint pool params");
+            return {nullptr, [](void *) {}};
+        }
+
+        typename pool_interface<Provider>::params_ptr params(
+            raw_params, [](void *p) {
+                umfDisjointPoolParamsDestroy(
+                    static_cast<umf_disjoint_pool_params_handle_t>(p));
+            });
+
+        ret = umfDisjointPoolParamsSetSlabMinSize(raw_params, 4096);
+        if (ret != UMF_RESULT_SUCCESS) {
+            state.SkipWithError("Failed to set slab min size");
+            return {nullptr, [](void *) {}};
+        }
+
+        ret = umfDisjointPoolParamsSetCapacity(raw_params, 4);
+        if (ret != UMF_RESULT_SUCCESS) {
+            state.SkipWithError("Failed to set capacity");
+            return {nullptr, [](void *) {}};
+        }
+
+        ret = umfDisjointPoolParamsSetMinBucketSize(raw_params, 8);
+        if (ret != UMF_RESULT_SUCCESS) {
+            state.SkipWithError("Failed to set min bucket size");
+            return {nullptr, [](void *) {}};
+        }
+
+        ret = umfDisjointPoolParamsSetMaxPoolableSize(raw_params, 4096 * 16);
+        if (ret != UMF_RESULT_SUCCESS) {
+            state.SkipWithError("Failed to set max poolable size");
+            return {nullptr, [](void *) {}};
+        }
+
+        return params;
+    }
+
+    static std::string name() {
+        return "disjoint_pool<" + Provider::name() + ">";
+    }
+};
+
+// benchmark tracking provider, by creating big number pools(2^7) stacked
+template <typename Provider>
+struct disjoint_pool_stack : public disjoint_pool<Provider> {
+    using base = disjoint_pool<Provider>;
+
+    std::vector<umf_memory_provider_handle_t> providers;
+    std::vector<umf_memory_pool_handle_t> pools;
+    std::vector<void *> pool_ptrs;
+
+    static constexpr size_t firstPoolSize = 2ull * 1024 * 1024 * 1024; // 2GB
+    static constexpr size_t levels = 7;
+
+    void SetUp(::benchmark::State &state) {
+        base::provider.SetUp(state);
+        if (state.thread_index() != 0) {
+            return;
+        }
+
+        providers.push_back(base::provider.provider);
+        base::provider.provider = nullptr;
+
+        auto params = base::getParams(state);
+        umf_memory_pool_handle_t rootPool = nullptr;
+        auto umf_result = umfPoolCreate(base::getOps(state), providers[0],
+                                        params.get(), 0, &rootPool);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            state.SkipWithError("umfPoolCreate() failed");
+            return;
+        }
+
+        pools.push_back(rootPool); // root pool
+
+        umf_fixed_memory_provider_params_handle_t params_fixed = nullptr;
+        umf_result = umfFixedMemoryProviderParamsCreate((void *)0x1, 0x1,
+                                                        &params_fixed); // dummy
+
+        size_t poolSize = firstPoolSize;
+        size_t level_start = 0;
+        size_t level_pools = 1;
+
+        for (size_t level = 1; level < levels; ++level) {
+            // split each pools for 3 parts - two for children, and third from other allocations from this pool
+            poolSize /= 3;
+            size_t new_level_pools = level_pools * 2;
+
+            for (size_t parent_idx = 0; parent_idx < level_pools;
+                 ++parent_idx) {
+                umf_memory_pool_handle_t parent_pool =
+                    pools[level_start + parent_idx];
+
+                for (int child = 0; child < 2; ++child) {
+                    void *ptr = umfPoolMalloc(parent_pool, poolSize);
+                    if (!ptr) {
+                        state.SkipWithError("umfPoolMalloc() failed");
+                        return;
+                    }
+                    pool_ptrs.push_back(ptr);
+
+                    umf_result = umfFixedMemoryProviderParamsSetMemory(
+                        params_fixed, ptr, poolSize);
+                    umf_memory_provider_handle_t prov;
+                    umf_result = umfMemoryProviderCreate(
+                        umfFixedMemoryProviderOps(), params_fixed, &prov);
+                    if (umf_result != UMF_RESULT_SUCCESS) {
+                        state.SkipWithError("umfMemoryProviderCreate() failed");
+                        return;
+                    }
+                    providers.push_back(prov);
+
+                    umf_memory_pool_handle_t newPool;
+                    umf_result = umfPoolCreate(base::getOps(state), prov,
+                                               params.get(), 0, &newPool);
+                    if (umf_result != UMF_RESULT_SUCCESS) {
+                        state.SkipWithError("umfPoolCreate() failed");
+                        return;
+                    }
+
+                    pools.push_back(newPool);
+                }
+            }
+
+            level_start += level_pools;
+            level_pools = new_level_pools;
+        }
+
+        umfFixedMemoryProviderParamsDestroy(params_fixed);
+    }
+
+    void TearDown(::benchmark::State &state) {
+        if (state.thread_index() != 0) {
+            return;
+        }
+
+        size_t pool_index = pools.size();
+        size_t provider_index = providers.size();
+        size_t ptr_index = pool_ptrs.size();
+
+        // Go from last level to first (excluding level 0, root)
+        for (int level = levels - 1; level > 0; --level) {
+            size_t level_pools = 1ull << level; // 2^level pools
+
+            // Destroy pools
+            for (size_t i = 0; i < level_pools; ++i) {
+                --pool_index;
+                umfPoolDestroy(pools[pool_index]);
+            }
+
+            // Destroy providers and free pointers
+            for (size_t i = 0; i < level_pools; ++i) {
+                --provider_index;
+                umfMemoryProviderDestroy(providers[provider_index]);
+
+                --ptr_index;
+                void *ptr = pool_ptrs[ptr_index];
+                if (ptr) {
+                    umfFree(ptr);
+                }
+            }
+        }
+
+        // Root pool and provider
+        umfPoolDestroy(pools[0]);
+        umfMemoryProviderDestroy(providers[0]);
+
+        pools.clear();
+        providers.clear();
+        pool_ptrs.clear();
+
+        base::TearDown(state);
+    }
+
+    static std::string name() {
+        return "disjoint_pool_stacked<" + Provider::name() + ">";
+    }
+};
+
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+template <typename Provider>
+struct jemalloc_pool : public pool_interface<Provider> {
+    const umf_memory_pool_ops_t *
+    getOps([[maybe_unused]] ::benchmark::State &state) override {
+        return umfJemallocPoolOps();
+    }
+
+    static std::string name() {
+        return "jemalloc_pool<" + Provider::name() + ">";
+    }
+};
+#endif
+
+#ifdef UMF_POOL_SCALABLE_ENABLED
+template <typename Provider>
+struct scalable_pool : public pool_interface<Provider> {
+    const umf_memory_pool_ops_t *
+    getOps([[maybe_unused]] ::benchmark::State &state) override {
+        return umfScalablePoolOps();
+    }
+
+    static std::string name() {
+        return "scalable_pool<" + Provider::name() + ">";
+    }
+};
+#endif
diff --git a/benchmark/multithread.cpp b/benchmark/multithread.cpp
index 4558942ecb..fac2d063a3 100644
--- a/benchmark/multithread.cpp
+++ b/benchmark/multithread.cpp
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -27,8 +27,9 @@ struct bench_params {
     size_t alloc_size = 64;
 };
 
-using poolCreateExtParams = std::tuple<umf_memory_pool_ops_t *, void *,
-                                       umf_memory_provider_ops_t *, void *>;
+using poolCreateExtParams =
+    std::tuple<const umf_memory_pool_ops_t *, const void *,
+               const umf_memory_provider_ops_t *, const void *>;
 
 static auto poolCreateExtUnique(poolCreateExtParams params) {
     umf_memory_pool_handle_t hPool;
@@ -121,7 +122,7 @@ int main() {
     std::cout << "skipping jemalloc_pool mt_alloc_free" << std::endl;
 #endif
 
-#if defined(UMF_POOL_DISJOINT_ENABLED)
+    // NOTE: disjoint pool is always enabled
     umf_disjoint_pool_params_handle_t hDisjointParams = nullptr;
     umf_result_t ret = umfDisjointPoolParamsCreate(&hDisjointParams);
     if (ret != UMF_RESULT_SUCCESS) {
@@ -132,9 +133,6 @@ int main() {
     std::cout << "disjoint_pool mt_alloc_free: ";
     mt_alloc_free(poolCreateExtParams{umfDisjointPoolOps(), hDisjointParams,
                                       umfOsMemoryProviderOps(), osParams});
-#else
-    std::cout << "skipping disjoint_pool mt_alloc_free" << std::endl;
-#endif
 
     // ctest looks for "PASSED" in the output
     std::cout << "PASSED" << std::endl;
diff --git a/benchmark/ubench.c b/benchmark/ubench.c
index 5f1bfe9e48..5beaa62be7 100644
--- a/benchmark/ubench.c
+++ b/benchmark/ubench.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -15,23 +15,19 @@
 
 #include <umf/ipc.h>
 #include <umf/memory_pool.h>
+#include <umf/pools/pool_disjoint.h>
 #include <umf/pools/pool_proxy.h>
 #include <umf/pools/pool_scalable.h>
 #include <umf/providers/provider_level_zero.h>
 #include <umf/providers/provider_os_memory.h>
 
-#ifdef UMF_POOL_DISJOINT_ENABLED
-#include <umf/pools/pool_disjoint.h>
-#endif
-
 #ifdef UMF_POOL_JEMALLOC_ENABLED
 #include <umf/pools/pool_jemalloc.h>
 #endif
 
 #include "utils_common.h"
 
-#if (defined UMF_BUILD_LIBUMF_POOL_DISJOINT &&                                 \
-     defined UMF_BUILD_LEVEL_ZERO_PROVIDER && defined UMF_BUILD_GPU_TESTS)
+#if (defined UMF_PROVIDER_LEVEL_ZERO_ENABLED && defined UMF_BUILD_GPU_TESTS)
 #include "utils_level_zero.h"
 #endif
 
@@ -244,7 +240,6 @@ UBENCH_EX(simple, proxy_pool_with_os_memory_provider) {
     free(array);
 }
 
-#if (defined UMF_POOL_DISJOINT_ENABLED)
 ////////////////// DISJOINT POOL WITH OS MEMORY PROVIDER
 
 UBENCH_EX(simple, disjoint_pool_with_os_memory_provider) {
@@ -327,7 +322,6 @@ UBENCH_EX(simple, disjoint_pool_with_os_memory_provider) {
     umfMemoryProviderDestroy(os_memory_provider);
     free(array);
 }
-#endif /* (defined UMF_POOL_DISJOINT_ENABLED) */
 
 #if (defined UMF_POOL_JEMALLOC_ENABLED)
 ////////////////// JEMALLOC POOL WITH OS MEMORY PROVIDER
@@ -421,8 +415,7 @@ UBENCH_EX(simple, scalable_pool_with_os_memory_provider) {
 }
 #endif /* (defined UMF_POOL_SCALABLE_ENABLED) */
 
-#if (defined UMF_POOL_DISJOINT_ENABLED &&                                      \
-     defined UMF_BUILD_LEVEL_ZERO_PROVIDER && defined UMF_BUILD_GPU_TESTS)
+#if (defined UMF_PROVIDER_LEVEL_ZERO_ENABLED && defined UMF_BUILD_GPU_TESTS)
 static void do_ipc_get_put_benchmark(alloc_t *allocs, size_t num_allocs,
                                      size_t repeats,
                                      umf_ipc_handle_t *ipc_handles) {
@@ -445,14 +438,14 @@ static void do_ipc_get_put_benchmark(alloc_t *allocs, size_t num_allocs,
     }
 }
 
-int create_level_zero_params(ze_context_handle_t *context,
-                             ze_device_handle_t *device) {
+static int create_level_zero_params(ze_context_handle_t *context,
+                                    ze_device_handle_t *device) {
     uint32_t driver_idx = 0;
     ze_driver_handle_t driver = NULL;
 
     int ret = utils_ze_init_level_zero();
     if (ret != 0) {
-        fprintf(stderr, "Failed to init Level 0!\n");
+        fprintf(stderr, "Failed to init Level Zero!\n");
         return ret;
     }
 
@@ -630,7 +623,7 @@ UBENCH_EX(ipc, disjoint_pool_with_level_zero_provider) {
 err_destroy_context:
     utils_ze_destroy_context(context);
 }
-#endif /* (defined UMF_POLL_DISJOINT_ENABLED && defined UMF_BUILD_LEVEL_ZERO_PROVIDER && defined UMF_BUILD_GPU_TESTS) */
+#endif /* (defined UMF_BUILD_LEVEL_ZERO_PROVIDER && defined UMF_BUILD_GPU_TESTS) */
 
 // TODO add IPC benchmark for CUDA
 
diff --git a/cmake/FindCUDA.cmake b/cmake/FindCUDA.cmake
index 5e4e2eeada..cfc59b5ad3 100644
--- a/cmake/FindCUDA.cmake
+++ b/cmake/FindCUDA.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
 
@@ -7,6 +7,10 @@ message(STATUS "Checking for module 'cuda' using find_library()")
 find_library(CUDA_LIBRARY NAMES libcuda cuda)
 set(CUDA_LIBRARIES ${CUDA_LIBRARY})
 
+find_file(CUDA_HEADER NAMES "cuda.h")
+get_filename_component(CUDA_INCLUDE_DIR ${CUDA_HEADER} DIRECTORY)
+set(CUDA_INCLUDE_DIRS ${CUDA_INCLUDE_DIR})
+
 get_filename_component(CUDA_LIB_DIR ${CUDA_LIBRARIES} DIRECTORY)
 set(CUDA_LIBRARY_DIRS ${CUDA_LIB_DIR})
 
@@ -17,6 +21,7 @@ if(WINDOWS)
 endif()
 
 if(CUDA_LIBRARY)
+    set(CUDA_FOUND TRUE)
     message(STATUS "  Found cuda using find_library()")
     message(STATUS "    CUDA_LIBRARIES = ${CUDA_LIBRARIES}")
     message(STATUS "    CUDA_INCLUDE_DIRS = ${CUDA_INCLUDE_DIRS}")
@@ -30,6 +35,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 89d488ecc0..524191dcac 100644
--- a/cmake/FindJEMALLOC.cmake
+++ b/cmake/FindJEMALLOC.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
 
@@ -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()
 
@@ -34,19 +34,14 @@ if(WINDOWS)
 endif()
 
 if(JEMALLOC_LIBRARY)
+    set(JEMALLOC_FOUND TRUE)
     message(STATUS "  Found jemalloc using find_library()")
-    message(STATUS "    JEMALLOC_LIBRARIES = ${JEMALLOC_LIBRARIES}")
-    message(STATUS "    JEMALLOC_INCLUDE_DIRS = ${JEMALLOC_INCLUDE_DIRS}")
-    message(STATUS "    JEMALLOC_LIBRARY_DIRS = ${JEMALLOC_LIBRARY_DIRS}")
-    if(WINDOWS)
-        message(STATUS "    JEMALLOC_DLL_DIRS = ${JEMALLOC_DLL_DIRS}")
-    endif()
 else()
     set(MSG_NOT_FOUND
         "jemalloc NOT found (set CMAKE_PREFIX_PATH to point the location)")
     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 8d7998f8d5..f9d1dfe389 100644
--- a/cmake/FindLIBHWLOC.cmake
+++ b/cmake/FindLIBHWLOC.cmake
@@ -1,7 +1,17 @@
-# 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
 
+function(print_hwloc_dirs)
+    message(STATUS "    LIBHWLOC_LIBRARIES = ${LIBHWLOC_LIBRARIES}")
+    message(STATUS "    LIBHWLOC_INCLUDE_DIRS = ${LIBHWLOC_INCLUDE_DIRS}")
+    message(STATUS "    LIBHWLOC_LIBRARY_DIRS = ${LIBHWLOC_LIBRARY_DIRS}")
+    message(STATUS "    LIBHWLOC_API_VERSION = ${LIBHWLOC_API_VERSION}")
+    if(WINDOWS)
+        message(STATUS "    LIBHWLOC_DLL_DIRS = ${LIBHWLOC_DLL_DIRS}")
+    endif()
+endfunction()
+
 message(STATUS "Checking for module 'libhwloc' using find_library()")
 
 find_library(LIBHWLOC_LIBRARY NAMES ${UMF_HWLOC_NAME})
@@ -45,20 +55,16 @@ if(WINDOWS)
 endif()
 
 if(LIBHWLOC_LIBRARY)
-    message(STATUS "  Found libhwloc using find_library()")
-    message(STATUS "    LIBHWLOC_LIBRARIES = ${LIBHWLOC_LIBRARIES}")
-    message(STATUS "    LIBHWLOC_INCLUDE_DIRS = ${LIBHWLOC_INCLUDE_DIRS}")
-    message(STATUS "    LIBHWLOC_LIBRARY_DIRS = ${LIBHWLOC_LIBRARY_DIRS}")
-    message(STATUS "    LIBHWLOC_API_VERSION = ${LIBHWLOC_API_VERSION}")
-    if(WINDOWS)
-        message(STATUS "    LIBHWLOC_DLL_DIRS = ${LIBHWLOC_DLL_DIRS}")
-    endif()
+    set(LIBHWLOC_FOUND TRUE)
+    message(STATUS "  Found libhwloc: ${LIBHWLOC_LIBRARY}")
 
     if(LIBHWLOC_FIND_VERSION)
         if(NOT LIBHWLOC_API_VERSION)
+            print_hwloc_dirs()
             message(FATAL_ERROR "Failed to retrieve libhwloc version")
         elseif(NOT LIBHWLOC_API_VERSION VERSION_GREATER_EQUAL
                LIBHWLOC_FIND_VERSION)
+            print_hwloc_dirs()
             message(
                 FATAL_ERROR
                     "    Required version: ${LIBHWLOC_FIND_VERSION}, found ${LIBHWLOC_API_VERSION}"
@@ -67,11 +73,10 @@ if(LIBHWLOC_LIBRARY)
     endif()
 else()
     set(MSG_NOT_FOUND
-        "libhwloc NOT found (set CMAKE_PREFIX_PATH to point the location or disable with -DUMF_DISABLE_HWLOC=ON)"
-    )
+        "libhwloc NOT found in the system (will fetch it from GitHub)")
     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 8c23f481c7..e0445cfa44 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
 
@@ -8,6 +8,7 @@ find_library(LIBNUMA_LIBRARY NAMES libnuma numa)
 set(LIBNUMA_LIBRARIES ${LIBNUMA_LIBRARY})
 
 if(LIBNUMA_LIBRARY)
+    set(LIBNUMA_FOUND TRUE)
     message(STATUS "  Found libnuma using find_library()")
 else()
     set(MSG_NOT_FOUND
@@ -15,6 +16,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 6536e8c4ae..c1a098a79c 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()
 
@@ -32,6 +32,7 @@ if(WINDOWS)
 endif()
 
 if(TBB_LIBRARY)
+    set(TBB_FOUND TRUE)
     message(STATUS "  Found tbb using find_library()")
     message(STATUS "    TBB_LIBRARIES = ${TBB_LIBRARIES}")
     message(STATUS "    TBB_INCLUDE_DIRS = ${TBB_INCLUDE_DIRS}")
@@ -45,6 +46,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
new file mode 100644
index 0000000000..d87e546c24
--- /dev/null
+++ b/cmake/FindZE_LOADER.cmake
@@ -0,0 +1,40 @@
+# 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
+
+message(STATUS "Checking for module 'ze_loader' using find_library()")
+
+find_library(ZE_LOADER_LIBRARY NAMES libze_loader ze_loader)
+set(ZE_LOADER_LIBRARIES ${ZE_LOADER_LIBRARY})
+
+find_file(ZE_LOADER_HEADER NAMES "ze_api.h" "level_zero/ze_api.h")
+get_filename_component(ZE_LOADER_INCLUDE_DIR ${ZE_LOADER_HEADER} DIRECTORY)
+set(ZE_LOADER_INCLUDE_DIRS ${ZE_LOADER_INCLUDE_DIR})
+
+get_filename_component(ZE_LOADER_LIB_DIR ${ZE_LOADER_LIBRARIES} DIRECTORY)
+set(ZE_LOADER_LIBRARY_DIRS ${ZE_LOADER_LIB_DIR})
+
+if(WINDOWS)
+    find_file(ZE_LOADER_DLL NAMES "ze_loader.dll")
+    get_filename_component(ZE_LOADER_DLL_DIR ${ZE_LOADER_DLL} DIRECTORY)
+    set(ZE_LOADER_DLL_DIRS ${ZE_LOADER_DLL_DIR})
+endif()
+
+if(ZE_LOADER_LIBRARY)
+    set(ZE_LOADER_FOUND TRUE)
+    message(STATUS "  Found ZE_LOADER using find_library()")
+    message(STATUS "    ZE_LOADER_LIBRARIES = ${ZE_LOADER_LIBRARIES}")
+    message(STATUS "    ZE_LOADER_INCLUDE_DIRS = ${ZE_LOADER_INCLUDE_DIRS}")
+    message(STATUS "    ZE_LOADER_LIBRARY_DIRS = ${ZE_LOADER_LIBRARY_DIRS}")
+    if(WINDOWS)
+        message(STATUS "    ZE_LOADER_DLL_DIRS = ${ZE_LOADER_DLL_DIRS}")
+    endif()
+else()
+    set(MSG_NOT_FOUND "ZE_LOADER NOT found (set CMAKE_PREFIX_PATH to point the "
+                      "location)")
+    if(ZE_LOADER_FIND_REQUIRED)
+        message(FATAL_ERROR ${MSG_NOT_FOUND})
+    else()
+        message(STATUS ${MSG_NOT_FOUND})
+    endif()
+endif()
diff --git a/cmake/helpers.cmake b/cmake/helpers.cmake
index 2544a15186..8ee14bd377 100644
--- a/cmake/helpers.cmake
+++ b/cmake/helpers.cmake
@@ -1,4 +1,4 @@
-# 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
 
@@ -11,10 +11,12 @@ include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 
 # This function establishes version variables based on the git describe output.
-# If there's no git available in the system, the version will be set to "0.0.0".
-# If git reports only a hash, the version will be set to "0.0.0.git.<hash>".
-# Otherwise we'll use 3-component version: major.minor.patch, just for CMake's
-# sake. A few extra variables will be set for Win dll metadata.
+# If there's no git available in the system, it falls back to reading a VERSION
+# file from the project root. If neither git nor VERSION file is available, the
+# version will be set to "0.0.0". If git reports only a hash, the version will
+# be set to "0.0.0.git.<hash>". Otherwise we'll use 3-component version:
+# major.minor.patch, just for CMake's sake. A few extra variables will be set
+# for Win dll metadata.
 #
 # Important note: CMake does not support rc or git information. According to
 # semver rules, 1.5.1-rc1 should be less than 1.5.1, but it seems hard to
@@ -78,8 +80,24 @@ function(set_version_variables)
         OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)
 
     if(NOT GIT_VERSION)
-        # no git or it reported no version. Use default ver: "0.0.0"
-        return()
+        # no git or it reported no version. Try fallback to VERSION file
+        if(EXISTS "${UMF_CMAKE_SOURCE_DIR}/VERSION")
+            file(READ "${UMF_CMAKE_SOURCE_DIR}/VERSION" FILE_VERSION)
+            string(STRIP ${FILE_VERSION} FILE_VERSION)
+            if(FILE_VERSION)
+                set(GIT_VERSION "v${FILE_VERSION}-dev")
+                message(
+                    STATUS
+                        "Using version from VERSION file: ${FILE_VERSION}. To get detailed version, use git and fetch tags."
+                )
+            else()
+                # VERSION file exists but is empty, use default ver: "0.0.0"
+                return()
+            endif()
+        else()
+            # no git and no VERSION file. Use default ver: "0.0.0"
+            return()
+        endif()
     endif()
 
     # v1.5.0 - we're exactly on a tag -> UMF ver: "1.5.0"
@@ -121,12 +139,12 @@ function(set_version_variables)
         return()
     endif()
 
-    # v1.5.0-dev - we're on a development tag -> UMF ver: "1.5.0-dev"
-    string(REGEX MATCHALL "\^v([0-9]+\.[0-9]+\.[0-9]+)-dev\$" MATCHES
+    # v1.5.0-dev1 - we're on a development tag -> UMF ver: "1.5.0-dev1"
+    string(REGEX MATCHALL "\^v([0-9]+\.[0-9]+\.[0-9]+)-(dev[0-9]?)\$" MATCHES
                  ${GIT_VERSION})
     if(MATCHES)
         set(UMF_VERSION
-            "${CMAKE_MATCH_1}-dev"
+            "${CMAKE_MATCH_1}-${CMAKE_MATCH_2}"
             PARENT_SCOPE)
         set(UMF_CMAKE_VERSION
             "${CMAKE_MATCH_1}"
@@ -157,12 +175,12 @@ function(set_version_variables)
         return()
     endif()
 
-    # v1.5.0-dev-19-gb8f7a32 -> UMF ver: "1.5.0-dev.git19.gb8f7a32"
-    string(REGEX MATCHALL "v([0-9.]*)-dev-([0-9]*)-([0-9a-g]*)" MATCHES
+    # v1.5.0-dev2-19-gb8f7a32 -> UMF ver: "1.5.0-dev2.git19.gb8f7a32"
+    string(REGEX MATCHALL "v([0-9.]*)-(dev[0-9]?)-([0-9]*)-([0-9a-g]*)" MATCHES
                  ${GIT_VERSION})
     if(MATCHES)
         set(UMF_VERSION
-            "${CMAKE_MATCH_1}-dev.git${CMAKE_MATCH_2}.${CMAKE_MATCH_3}"
+            "${CMAKE_MATCH_1}-${CMAKE_MATCH_2}.git${CMAKE_MATCH_3}.${CMAKE_MATCH_4}"
             PARENT_SCOPE)
         set(UMF_CMAKE_VERSION
             "${CMAKE_MATCH_1}"
@@ -225,16 +243,17 @@ 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}
             PRIVATE -fPIC
                     -Wall
                     -Wextra
-                    -Wpedantic
                     -Wformat-security
-                    -Wcast-qual
+                    -Wno-cast-qual # TODO: remove this when const qualifier drop
+                                   # will be solved in CTL
                     $<$<CXX_COMPILER_ID:GNU>:-fdiagnostics-color=auto>)
         if(CMAKE_BUILD_TYPE STREQUAL "Release")
             target_compile_definitions(${name} PRIVATE -D_FORTIFY_SOURCE=2)
@@ -260,6 +279,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,8 +409,10 @@ 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/base_alloc
+                ${UMF_CMAKE_SOURCE_DIR}/src/coarse)
     add_umf_target_compile_options(${ARG_NAME})
     add_umf_target_link_options(${ARG_NAME})
 endfunction()
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 0000000000..737bb12595
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,32 @@
+# Documentation
+
+To generate HTML documentation, run the `generate_docs.py` script from any sub-directory of the repository (most likely `build`).
+To display the proper version of UMF in the documentation title, set the `UMF_VERSION` variable before running the script.
+
+```bash
+cd build
+$ UMF_VERSION=<your version, e.g. "0.12.1"> python ../docs/generate_docs.py
+```
+
+Documentation can also be built using the build target 'docs' (see details below).
+
+This script will create `./docs_build` sub-directory, where the intermediate and final files
+will be created. HTML docs will be in the `./docs_build/generated/html` directory.
+
+## make docs
+
+To run documentation generation via build target use CMake commands below.
+To enable this target, python executable (in required version) has to be found in the system.
+
+```bash
+cmake -B build
+cmake --build build --target docs
+```
+
+## Requirements
+
+Script to generate HTML docs requires:
+
+* [Doxygen](http://www.doxygen.nl/) at least v1.9.1
+* [Python](https://www.python.org/downloads/) at least v3.8
+* and python pip requirements, as defined in `third_party/requirements.txt`
diff --git a/scripts/assets/images/intro_architecture.png b/docs/assets/images/intro_architecture.png
similarity index 100%
rename from scripts/assets/images/intro_architecture.png
rename to docs/assets/images/intro_architecture.png
diff --git a/scripts/docs_config/Doxyfile b/docs/config/Doxyfile
similarity index 99%
rename from scripts/docs_config/Doxyfile
rename to docs/config/Doxyfile
index 43ff2a6037..9c520d46ce 100644
--- a/scripts/docs_config/Doxyfile
+++ b/docs/config/Doxyfile
@@ -445,7 +445,7 @@ INLINE_SIMPLE_STRUCTS  = NO
 # types are typedef'ed and only the typedef is referenced, never the tag name.
 # The default value is: NO.
 
-TYPEDEF_HIDES_STRUCT   = NO
+TYPEDEF_HIDES_STRUCT   = YES
 
 # The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
 # cache is used to resolve symbols given their name and scope. Since this can be
@@ -466,7 +466,7 @@ LOOKUP_CACHE_SIZE      = 0
 # than 0 to get more control over the balance between CPU load and processing
 # speed. At this moment only the input processing can be done using multiple
 # threads. Since this is still an experimental feature the default is set to 1,
-# which efficively disables parallel processing. Please report any issues you
+# which effectively disables parallel processing. Please report any issues you
 # encounter. Generating dot graphs in parallel is controlled by the
 # DOT_NUM_THREADS setting.
 # Minimum value: 0, maximum value: 32, default value: 1.
@@ -2058,7 +2058,7 @@ GENERATE_XML           = YES
 # The default directory is: xml.
 # This tag requires that the tag GENERATE_XML is set to YES.
 
-XML_OUTPUT             = ../docs/xml
+XML_OUTPUT             = docs_build/doxyxml
 
 # If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
 # listings (including syntax highlighting and cross-referencing information) to
diff --git a/scripts/docs_config/api.rst b/docs/config/api.rst
similarity index 60%
rename from scripts/docs_config/api.rst
rename to docs/config/api.rst
index 7f734cad24..609ffc147c 100644
--- a/scripts/docs_config/api.rst
+++ b/docs/config/api.rst
@@ -58,6 +58,9 @@ supported by the Proxy Pool.
 
 Scalable Pool
 ------------------------------------------
+
+A oneTBB-based memory pool manager.
+
 .. doxygenfile:: pool_scalable.h
     :sections: define enum typedef func var
 
@@ -80,17 +83,12 @@ and operate on the provider.
 .. doxygenfile:: memory_provider.h
     :sections: define enum typedef func var
 
-Coarse Provider
+Fixed Memory Provider
 ------------------------------------------
 
-A memory provider that can provide memory from:
-
-1) A given pre-allocated buffer (the fixed-size memory provider option) or
-2) From an additional upstream provider (e.g. provider that does not support 
-   the free() operation like the File memory provider or the DevDax memory 
-   provider - see below).
+A memory provider that can provide memory from a given preallocated buffer.
 
-.. doxygenfile:: provider_coarse.h
+.. doxygenfile:: provider_fixed_memory.h
     :sections: define enum typedef func var
 
 OS Memory Provider
@@ -109,10 +107,18 @@ A memory provider that provides memory from L0 device.
 .. doxygenfile:: provider_level_zero.h
     :sections: define enum typedef func var
 
+CUDA Provider
+------------------------------------------
+
+A memory provider that provides memory from CUDA device.
+
+.. doxygenfile:: provider_cuda.h
+    :sections: define enum typedef func var
+
 DevDax Memory Provider
 ------------------------------------------
 
-A memory provider that provides memory from a device DAX (a character device file /dev/daxX.Y).
+A memory provider that provides memory from a device DAX (a character device file like /dev/daxX.Y).
 
 .. doxygenfile:: provider_devdax_memory.h
     :sections: define enum typedef func var
@@ -130,9 +136,12 @@ Memspace
 
 TODO: Add general information about memspaces.
 
+.. note::
+   The memspace APIs are experimental and may change in future releases.
+
 Memspace
 ------------------------------------------
-.. doxygenfile:: memspace.h
+.. doxygenfile:: experimental/memspace.h
     :sections: define enum typedef func
 
 Mempolicy             
@@ -140,9 +149,12 @@ Mempolicy
 
 TODO: Add general information about mempolicies.
 
+.. note::
+   The mempolicy APIs are experimental and may change in future releases.
+
 Mempolicy
 ------------------------------------------
-.. doxygenfile:: mempolicy.h
+.. doxygenfile:: experimental/mempolicy.h
     :sections: define enum typedef func
 
 Memtarget
@@ -150,11 +162,34 @@ Memtarget
 
 TODO: Add general information about memtargets.
 
+.. note::
+   The memtarget APIs are experimental and may change in future releases.
+
 Memtarget
 ------------------------------------------
-.. doxygenfile:: memtarget.h
+.. doxygenfile:: experimental/memtarget.h
     :sections: define enum typedef func
 
+Memory Properties
+==========================================
+
+Memory properties in UMF describe the characteristics and capabilities of 
+different memory regions or allocations. These properties can include 
+information such as memory type, allocation size, context and device used for 
+allocation, and other attributes that are relevant for memory management.
+
+The Memory Properties API allows users to retrieve and interpret these 
+attributes for memory managed by UMF, enabling advanced memory management 
+strategies and improved interoperability with heterogeneous systems.
+
+.. note::
+   The memory properties APIs are experimental and may change in future releases.
+
+Memory Properties
+------------------------------------------
+.. doxygenfile::  experimental/memory_properties.h
+    :sections: define enum typedef func var
+
 Inter-Process Communication
 ==========================================
 
@@ -162,6 +197,26 @@ IPC API allows retrieving IPC handles for the memory buffers allocated from
 UMF memory pools. The memory provider used by the pool should support IPC 
 operations for this API to work. Otherwise IPC APIs return an error.
 
+IPC caching
+------------------------------------------
+
+UMF employs IPC caching to avoid multiple IPC handles being created for the same 
+coarse-grain memory region allocated by the memory provider. UMF guarantees that 
+for each coarse-grain memory region allocated by the memory provider, only one 
+IPC handle is created when the :any:`umfGetIPCHandle` function is called. All 
+subsequent calls to the :any:`umfGetIPCHandle` function for the pointer to the 
+same memory region will return the entry from the cache.
+
+The same is true for the :any:`umfOpenIPCHandle` function. The actual mapping
+of the IPC handle to the virtual address space is created only once, and all
+subsequent calls to open the same IPC handle will return the entry from the cache.
+The size of the cache for opened IPC handles is controlled by the ``UMF_MAX_OPENED_IPC_HANDLES``
+environment variable. By default, the cache size is unlimited. However, if the environment 
+variable is set and the cache size exceeds the limit, old items will be evicted. UMF tracks 
+the ref count for each entry in the cache and can evict only items with the ref count equal to 0. 
+The ref count is increased when the :any:`umfOpenIPCHandle` function is called and decreased 
+when the :any:`umfCloseIPCHandle` function is called for the corresponding IPC handle.
+
 .. _ipc-api:
 
 IPC API
diff --git a/scripts/docs_config/conf.py b/docs/config/conf.py
similarity index 79%
rename from scripts/docs_config/conf.py
rename to docs/config/conf.py
index 77d9856274..ae698ba98c 100644
--- a/scripts/docs_config/conf.py
+++ b/docs/config/conf.py
@@ -1,3 +1,5 @@
+import os
+
 # Configuration file for the Sphinx documentation builder.
 #
 # This file only contains a selection of the most common options. For a full
@@ -22,15 +24,22 @@
 author = "Intel"
 
 # The full version, including alpha/beta/rc tags
-release = "0.10.1"
-
+release = os.getenv("UMF_VERSION", "")
+print(
+    f"UMF_VERSION used in docs: {release}"
+    if release != ""
+    else "please set UMF_VERSION environment variable before running this script"
+)
 
 # -- General configuration ---------------------------------------------------
 
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
-extensions = ["breathe"]
+extensions = ["breathe", "sphinxcontrib.spelling"]
+
+spelling_show_suggestions = True
+spelling_word_list_filename = "spelling_exceptions.txt"
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
@@ -49,7 +58,9 @@
 # -- Extension configuration -------------------------------------------------
 
 # -- Options for breathe extension -------------------------------------------
-breathe_projects = {project: "../../docs/xml"}
+# 'doxyxml' dir is generated with Doxygen; it's supposed to be in a directory
+# one above the config directory.
+breathe_projects = {project: "../doxyxml"}
 breathe_default_project = project
 breathe_show_include = False
 breathe_default_members = ("members", "undoc-members")
diff --git a/docs/config/ctl.rst b/docs/config/ctl.rst
new file mode 100644
index 0000000000..abd622aaab
--- /dev/null
+++ b/docs/config/ctl.rst
@@ -0,0 +1,717 @@
+================
+CTL
+================
+
+UMF's CTL is a mechanism for advanced configuration and control of UMF pools
+and providers. It allows programmatic access to provider- or pool-specific
+configuration options, statistics and auxiliary APIs. CTL entries can also be
+set through environment variables or a configuration file, allowing adjustment
+of UMF behavior without modifying the program.
+
+.. note::
+   The CTL API is experimental and may change in future releases.
+
+Main concepts
+=============
+
+The core concept is a *path*. A path is a string of nodes separated by periods.
+You can imagine nodes as directories where the last element is a file that can
+be read, written or executed (similar to ``sysfs`` but with periods instead of
+slashes). Example path ``umf.logger.level`` controls the log level. You can
+access it with::
+
+  int level;
+  umf_result_t ret = umfCtlGet("umf.logger.level", &level, sizeof(level));
+
+To change the level programmatically use::
+
+  int level = LOG_WARNING;
+  umf_result_t ret = umfCtlSet("umf.logger.level", &level, sizeof(level));
+
+Accessing pool or provider paths is slightly more involved. For example::
+
+  size_t alloc_count;
+  umf_memory_pool_handle_t hPool = createPool();
+  umf_result_t ret = umfCtlGet("umf.pool.by_handle.{}.stats.alloc_count",
+                               &alloc_count, sizeof(alloc_count), hPool);
+
+The ``umf.pool.by_handle`` prefix selects a pool addressed by its handle.
+Every ``{}`` in the path is replaced with an extra argument passed to the CTL
+function. Alternative addressing methods are described below.
+
+Pool / Provider addressing
+============================
+
+Two addressing schemes are provided: ``by_handle`` and ``by_name``. Each pool
+and provider has a unique handle and an optional user-defined name that can be
+queried with ``umfMemoryProviderGetName()`` or ``umfMemoryPoolGetName()``.
+When using ``by_name`` the name appears in the path, e.g.::
+
+  umfCtlGet("umf.pool.by_name.myPool.stats.alloc_count",
+            &alloc_count, sizeof(alloc_count));
+
+If multiple pools share a name, read operations must disambiguate the target by
+appending an index after the name::
+
+  umfCtlGet("umf.pool.by_name.myPool.0.stats.alloc_count",
+            &alloc_count, sizeof(alloc_count));
+
+The number of pools with a given name can be obtained with the ``count`` node.
+
+Wildcards
+===========
+
+A ``{}`` in the path acts as a wildcard and is replaced with successive
+arguments of ``umfCtlGet``, ``umfCtlSet`` or ``umfCtlExec``. Wildcards can
+replace any node, not only handles. For example::
+
+  size_t pool_count;
+  const char *name = "myPool";
+  umfCtlGet("umf.pool.by_name.{}.count", &pool_count, sizeof(pool_count),
+            name);
+  for (size_t i = 0; i < pool_count; i++) {
+      umfCtlGet("umf.pool.by_name.{}.{}.stats.alloc_count", &alloc_count,
+                sizeof(alloc_count), name, i);
+  }
+
+Ensure that the types of wildcard arguments match the expected node types.
+
+Default addressing
+===================
+
+``umf.provider.default`` and ``umf.pool.default`` store default values applied
+to providers or pools created after the defaults are set. For example::
+
+  size_t capacity = 16;
+  umfCtlSet("umf.pool.default.disjoint.params.capacity", &capacity,
+            sizeof(capacity));
+
+Every subsequently created disjoint pool will use ``16`` as its starting
+capacity overriding its creation parameters. Defaults are keyed by the
+name returned from the provider or pool ``get_name`` callback, so if pool/provider
+has custom name it must be addressed explicitly.  Defaults may be supplied programmatically
+or via environment variable and are saved internally and applied during initialization of a
+matching provider or pool.
+
+Environment variables
+=====================
+
+CTL entries may also be specified in the ``UMF_CONF`` environment variable or
+a configuration file specified in the ``UMF_CONF_FILE``.
+Multiple entries are separated with semicolons, e.g.::
+
+  UMF_CONF="umf.logger.output=stdout;umf.logger.level=0"
+
+CTL options available through environment variables are limited — you can only
+target default nodes when addressing pools. This means that configuration
+strings can influence values consumed during pool creation but cannot alter
+runtime-only parameters.
+
+============
+CTL nodes
+============
+
+The CTL hierarchy is rooted at ``umf``. The next component selects one of the
+major subsystems:
+
+* ``umf.logger`` – logging configuration and diagnostics.
+* ``umf.provider`` – provider-specific parameters, statistics and commands.
+* ``umf.pool`` – pool-specific parameters, statistics and inspection helpers.
+
+Within each subsystem the path continues with an addressing scheme followed by
+the module or leaf of interest.
+
+Reading below sections
+=======================
+
+Parameter annotations describe the values stored in the node rather than the
+pointer types passed to ``umfCtlGet``/``umfCtlSet``/``umfCtlExec``. The
+**Access** field indicates whether the node can be read, written, or executed.
+The **Defaults / Env** field notes whether the entry can be controlled through
+defaults written under ``umf.provider.default.<name>`` or
+``umf.pool.default.<name>`` and via ``UMF_CONF``/``UMF_CONF_FILE``. Nodes that do
+not accept either configuration source are marked as not supported.
+
+Logger nodes
+================
+
+.. py:function:: umf.logger.timestamp(enabled)
+
+   :param enabled: Receives or supplies ``0`` when timestamps are disabled and
+      ``1`` when they are emitted.
+   :type enabled: ``int``
+
+   **Access:** read-write.
+   **Defaults / Env:** supported.
+
+   Toggle timestamp prefixes in future log records. Logging starts with
+   timestamps disabled, and the flag affects only messages emitted after the
+   change.
+
+.. py:function:: umf.logger.pid(enabled)
+
+   :param enabled: Receives or supplies ``0`` to omit the process identifier and
+      ``1`` to include it in every message header.
+   :type enabled: ``int``
+
+   **Access:** read-write.
+   **Defaults / Env:** supported.
+
+   Controls whether each log line is annotated with the current process id.
+   Logging omits the pid by default. Setting non-boolean values results in
+   coercion to zero/non-zero; the change applies to subsequent messages only.
+
+.. py:function:: umf.logger.level(level)
+
+   :param level: Receives or supplies the minimum severity that will be written.
+   :type level: ``int`` (``0`` .. ``4``)
+
+   **Access:** read-write.
+   **Defaults / Env:** supported.
+
+   Sets the filtering threshold for the logger. Records below the configured
+   level are dropped. Writes that fall outside the enumerated range are
+   rejected. 0 means debug logs, 1 means info logs, 2 means warnings, 3 means
+   errors, and 4 means fatal logs. Until an output is selected the logger
+   ignores the level because logging is disabled.
+
+.. py:function:: umf.logger.flush_level(level)
+
+   :param level: Receives or supplies the severity at which the logger forces a
+      flush of the output stream.
+   :type level: ``int`` (``0`` .. ``4``)
+
+   **Access:** read-write.
+   **Defaults / Env:** supported.
+
+   Adjusts when buffered log data is synchronously flushed. Writes outside the
+   valid severity range fail, and lowering the level can incur additional flush
+   overhead for future messages. With logging disabled no flushing occurs.
+
+.. py:function:: umf.logger.output(path)
+
+   :param path: Receives the currently selected sink on reads. On writes, pass
+      ``"stdout"`` or ``"stderr"`` to redirect to standard streams, a
+      NULL-terminated file path to append to a file, or ``NULL`` to disable
+      logging altogether.
+   :type path: ``char *`` when reading, ``const char *`` when writing
+
+   **Access:** read-write.
+   **Defaults / Env:** supported.
+
+   Controls the destination for log messages. The logger closes any previously
+   opened file when switching targets. Providing a path longer than 256 bytes or
+   pointing to a file that cannot be opened causes the write to fail. Special
+   values ``"stdout"`` and ``"stderr"`` redirect output to the corresponding
+   streams. Passing ``NULL`` disables logging entirely, which is also the
+   initial state until a path is provided.
+
+Provider nodes
+================
+
+Provider entries are organized beneath ``umf.provider``. Use
+``umf.provider.by_handle.{provider}`` with a
+:type:`umf_memory_provider_handle_t` argument to reach a specific provider.
+Providers can also be addressed by name through ``umf.provider.by_name.{provider}``;
+append ``.{index}`` to address specific provider when multiple providers share the same label.
+Defaults for future providers reside under ``umf.provider.default.{provider}`` where ``{provider}`` is
+a name returned by each provider's ``get_name`` implementation. Providers have their
+default names (``OS``, ``FILE``, ``DEVDAX``, ``FIXED``, ``CUDA`` or ``LEVEL_ZERO``),
+unless their name was changed during creation, those renamed providers must be addressed explicitly.
+Defaults can be written via ``umf.provider.default.<name>`` either programmatically or through
+configuration strings. The entries below list only the suffix of each node;
+prefix them with the appropriate ``umf.provider`` path.
+
+Common provider statistics
+--------------------------
+
+.. py:function:: .stats.allocated_memory(bytes)
+
+   Accessible through both ``umf.provider.by_handle.{provider}`` and
+   ``umf.provider.by_name.{name}``. Supply the provider handle or name (with an
+   optional ``.{index}`` suffix for duplicates) as the first wildcard argument.
+
+   :param bytes: Receives the total number of bytes currently outstanding.
+   :type bytes: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Returns the amount of memory the provider has allocated but not yet freed.
+   The counter updates atomically as the provider serves requests and is not
+   resettable.
+
+.. py:function:: .stats.peak_memory(bytes)
+
+   Available via ``umf.provider.by_handle.{provider}`` or
+   ``umf.provider.by_name.{name}``. Pass the provider selector as the first
+   wildcard argument.
+
+   :param bytes: Receives the highest observed outstanding allocation size since
+      the last reset.
+   :type bytes: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Reports the historical maximum allocation footprint of the provider. Combine
+   with :py:func:`.stats.peak_memory.reset()` to discard stale peaks when
+   desired.
+
+.. py:function:: .stats.peak_memory.reset()
+
+   Invoke through ``umf.provider.by_handle.{provider}`` or
+   ``umf.provider.by_name.{name}`` after supplying the provider selector as the
+   first wildcard argument.
+
+   **Access:** execute.
+   **Defaults / Env:** not supported.
+
+   Resets the peak allocation counter to the provider's current outstanding
+   usage. The operation does not affect other statistics and can be invoked at
+   any time.
+
+OS memory provider (``OS``)
+---------------------------
+
+The OS provider supports the common statistics nodes described above and adds
+the following parameter entry.
+
+.. py:function:: .params.ipc_enabled(enabled)
+
+   :param enabled: Receives ``0`` when inter-process sharing is disabled and a
+      non-zero value when it is active.
+   :type enabled: ``int``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Indicates whether the OS memory provider has been initialized with IPC
+   support. The value is fixed at provider creation time and cannot be modified
+   afterwards.
+
+Fixed memory provider (``FIXED``)
+-----------------------------------
+
+The fixed-size allocation provider currently exposes only the common statistics
+nodes.
+
+DevDAX memory provider (``DEVDAX``)
+-------------------------------------
+
+The DevDAX provider exposes the common statistics nodes described earlier.
+
+File memory provider (``FILE``)
+-----------------------------------
+
+The file-backed provider exposes the common statistics nodes.
+
+CUDA memory provider (``CUDA``)
+-----------------------------------
+
+The CUDA provider currently exposes only the common statistics nodes.
+
+Level Zero memory provider (``LEVEL_ZERO``)
+-----------------------------------------------
+
+The Level Zero provider supports the common statistics nodes described above and 
+adds the following parameter entry.
+
+.. py:function:: .params.use_import_export_for_IPC(policy)
+
+   :param policy: Receives or supplies ``0`` to use IPC API for memory sharing 
+      and ``1`` to use import/export mechanism for memory sharing.
+   :type policy: ``int``
+
+   **Access:** read-write.
+   **Defaults / Env:** Supported.
+
+   Controls the memory exchange policy for inter-process communication 
+   operations. When set to ``0`` (default), the provider uses the IPC API 
+   for memory sharing between processes. When set to ``1``, the provider uses 
+   the import/export mechanism for memory sharing. This option is supported 
+   only on Windows with the Level Zero provider, where the default IPC mechanism
+   does not work. Note that enabling import/export adds overhead during 
+   allocation and deallocation for all allocations on the current provider.
+
+Pool nodes
+==========
+
+Pool entries mirror the provider layout. ``umf.pool.by_handle.{pool}`` accepts a
+:type:`umf_memory_pool_handle_t`, while ``umf.pool.by_name.{pool}`` addresses
+pools by name with an optional ``.{index}`` suffix when names are reused.
+Defaults for future pools reside under ``umf.pool.default.{pool}`` and track the
+name returned by each pool's ``get_name`` implementation. Pools that keep their
+default names (``disjoint``, ``scalable`` and ``jemalloc``) continue to match
+those entries, while renamed pools must be addressed explicitly. Defaults can be
+written via ``umf.pool.default.<pool>`` either programmatically or through
+configuration strings. The entries below list only the suffix of each node;
+prefix them with the appropriate ``umf.pool`` path.
+
+Common pool statistics
+--------------------------
+
+.. py:function:: .stats.alloc_count(count)
+
+   :param count: Receives the number of live allocations tracked by the pool.
+   :type count: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Counts the allocations currently outstanding according to the pool's public
+   allocation API. The value increments on successful allocations and
+   decrements when memory is released.
+
+Disjoint pool (``disjoint``)
+--------------------------------
+
+.. py:function:: .params.slab_min_size(bytes)
+
+   :param bytes: Receives or supplies the minimum slab size requested from the
+      provider.
+   :type bytes: ``size_t``
+
+   **Access:** read-write. (write is only available through defaults)
+   **Defaults / Env:** supported.
+
+   Governs how much memory the pool grabs in each slab. Lower values reduce
+   per-allocation slack while higher values amortize provider overhead. Writes
+   are accepted only before the pool completes its ``post_initialize`` phase.
+
+.. py:function:: .params.max_poolable_size(bytes)
+
+   :param bytes: Receives or supplies the largest allocation size that is still
+      cached by the pool.
+   :type bytes: ``size_t``
+
+   **Access:** read-write. (write is only available through defaults)
+   **Defaults / Env:** supported.
+
+   Sets the cut-off for pooling allocations. Requests larger than this value are
+   delegated directly to the provider. Updates must occur before
+   ``post_initialize`` completes.
+
+.. py:function:: .params.capacity(count)
+
+   :param count: Receives or supplies the maximum number of slabs each bucket
+      may retain.
+   :type count: ``size_t``
+
+   **Access:** read-write. (write is only available through defaults)
+   **Defaults / Env:** supported.
+
+   Caps the pool's cached slabs per bucket to limit memory retention. Shrinking
+   the capacity may cause future frees to return slabs to the provider. Writes
+   are rejected after ``post_initialize``.
+
+.. py:function:: .params.min_bucket_size(bytes)
+
+   :param bytes: Receives or supplies the minimal allocation size a bucket may
+      serve.
+   :type bytes: ``size_t``
+
+   **Access:** read-write. (write is only available through defaults)
+   **Defaults / Env:** supported.
+
+   Controls the smallest chunk size kept in the pool, which in turn affects the
+   number of buckets. Writes are validated for size correctness and disallowed
+   after ``post_initialize``.
+
+.. py:function:: .params.pool_trace(level)
+
+   :param level: Receives or supplies the tracing level for the pool.
+   :type level: ``int`` (``0`` disables tracing)
+
+   **Access:** read-write. (write is only available through defaults)
+   **Defaults / Env:** supported.
+
+   Controls the disjoint pool's tracing features. ``0`` disables tracing.
+   ``1`` records slab usage totals exposed through the ``.stats.curr_slabs_*``
+   and ``.stats.max_slabs_*`` nodes. ``2`` additionally tracks allocation and
+   free counters and prints a usage summary when the pool is destroyed. Values
+   greater than ``2`` also emit debug logs for every allocation and free.
+   Tracing must be activated before ``post_initialize``; attempting to change it
+   later fails with ``UMF_RESULT_ERROR_NOT_SUPPORTED``.
+
+.. py:function:: .stats.used_memory(bytes)
+
+   Available under ``umf.pool.by_handle.disjoint`` and
+   ``umf.pool.by_name.disjoint``. Provide the pool selector as the first wildcard
+   argument.
+
+   :param bytes: Receives the amount of memory that is presently allocated by
+      the pool's clients.
+   :type bytes: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Reports the memory currently in use across all slabs by active allocations.
+   Available even when ``pool_trace`` is disabled.
+
+.. py:function:: .stats.reserved_memory(bytes)
+
+   :param bytes: Receives the total number of bytes reserved in slabs that the
+      pool owns.
+   :type bytes: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Returns the total slab capacity reserved by the pool, including cached free
+   space. Available even when ``pool_trace`` is disabled.
+
+.. py:function:: .stats.alloc_num(count)
+
+   :param count: Receives the number of allocations the pool has issued.
+   :type count: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Requires tracing with ``pool_trace`` set to ``2`` or higher. Counts every
+   allocation handed out by the pool since it was created.
+
+.. py:function:: .stats.alloc_pool_num(count)
+
+   :param count: Receives the number of allocations served directly from cached
+      slabs.
+   :type count: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Requires tracing with ``pool_trace`` set to ``2`` or higher. Counts
+   allocations served from cached slabs without visiting the provider.
+
+.. py:function:: .stats.free_num(count)
+
+   :param count: Receives the total number of frees processed by the pool.
+   :type count: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Requires tracing with ``pool_trace`` set to ``2`` or higher. Tracks the
+   number of frees observed by the pool since its creation.
+
+.. py:function:: .stats.curr_slabs_in_use(count)
+
+   :param count: Receives the current number of slabs actively serving
+      allocations.
+   :type count: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Requires tracing with ``pool_trace`` of at least ``1``. Returns the number of
+   slabs that currently have live allocations.
+
+.. py:function:: .stats.curr_slabs_in_pool(count)
+
+   :param count: Receives how many slabs are cached and ready for reuse.
+   :type count: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Requires tracing with ``pool_trace`` of at least ``1``. Reports the slabs
+   retained in the pool for future reuse.
+
+.. py:function:: .stats.max_slabs_in_use(count)
+
+   :param count: Receives the historical maximum of simultaneously used slabs.
+   :type count: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Requires tracing with ``pool_trace`` of at least ``1``. Provides the peak
+   number of slabs that were in use at the same time.
+
+.. py:function:: .stats.max_slabs_in_pool(count)
+
+   :param count: Receives the largest number of slabs retained in the cache.
+   :type count: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Requires tracing with ``pool_trace`` of at least ``1``. Returns the highest
+   number of slabs ever retained in the cache simultaneously.
+
+.. py:function:: .buckets.count(count)
+
+   :param count: Receives the number of distinct bucket sizes.
+   :type count: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Returns the total number of buckets in the pool.
+
+.. py:function:: .buckets.{id}.size(bytes)
+
+   ``{id}`` denotes a bucket index of type ``size_t``. Valid indices range from
+   ``0`` to ``.buckets.count - 1``.
+
+   :param bytes: Receives the allocation size that the bucket serves.
+   :type bytes: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Reports the allocation size serviced by the selected bucket. This value is
+   available even when tracing is disabled.
+
+.. py:function:: .buckets.{id}.stats.alloc_num(count)
+
+   ``{id}`` denotes a bucket index of type ``size_t``. Valid indices range from
+   ``0`` to ``.buckets.count - 1``.
+
+   :param count: Receives the number of allocations performed by this bucket.
+   :type count: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Requires tracing with ``pool_trace`` set to ``2`` or higher. Counts every
+   allocation that passed through the specified bucket.
+
+.. py:function:: .buckets.{id}.stats.alloc_pool_num(count)
+
+   ``{id}`` denotes a bucket index of type ``size_t``. Valid indices range from
+   ``0`` to ``.buckets.count - 1``.
+
+   :param count: Receives the number of allocations satisfied from cached slabs
+      in this bucket.
+   :type count: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Requires tracing with ``pool_trace`` set to ``2`` or higher. Counts how many
+   allocations were served entirely from the bucket's cached slabs.
+
+.. py:function:: .buckets.{id}.stats.free_num(count)
+
+   ``{id}`` denotes a bucket index of type ``size_t``. Valid indices range from
+   ``0`` to ``.buckets.count - 1``.
+
+   :param count: Receives the number of frees recorded for this bucket.
+   :type count: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Requires tracing with ``pool_trace`` set to ``2`` or higher. Tracks the
+   number of frees observed for the bucket.
+
+.. py:function:: .buckets.{id}.stats.curr_slabs_in_use(count)
+
+   ``{id}`` denotes a bucket index of type ``size_t``. Valid indices range from
+   ``0`` to ``.buckets.count - 1``.
+
+   :param count: Receives how many slabs for this bucket currently serve
+      allocations.
+   :type count: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Requires tracing with ``pool_trace`` of at least ``1``. Returns the current
+   slab utilization for the bucket.
+
+.. py:function:: .buckets.{id}.stats.curr_slabs_in_pool(count)
+
+   Available through ``umf.pool.by_handle.disjoint`` and
+   ``umf.pool.by_name.disjoint``. Provide the pool selector and bucket index as
+   the first two wildcard arguments. ``{id}`` denotes a bucket index of type
+   ``size_t``. Valid indices range from ``0`` to ``.buckets.count - 1``.
+
+   :param count: Receives the number of slabs cached and immediately available
+      for this bucket.
+   :type count: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Requires tracing with ``pool_trace`` of at least ``1``. Reports cached slabs
+   that the bucket can reuse without a provider call.
+
+.. py:function:: .buckets.{id}.stats.max_slabs_in_use(count)
+
+   ``{id}`` denotes a bucket index of type ``size_t``. Valid indices range from
+   ``0`` to ``.buckets.count - 1``.
+
+   :param count: Receives the peak number of slabs in use for this bucket.
+   :type count: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Requires tracing with ``pool_trace`` of at least ``1``. Provides the
+   historical maximum of slabs simultaneously in use for the bucket.
+
+.. py:function:: .buckets.{id}.stats.max_slabs_in_pool(count)
+
+   ``{id}`` denotes a bucket index of type ``size_t``. Valid indices range from
+   ``0`` to ``.buckets.count - 1``.
+
+   :param count: Receives the largest number of slabs retained in the bucket's
+      cache.
+   :type count: ``size_t``
+
+   **Access:** read-only.
+   **Defaults / Env:** not supported.
+
+   Requires tracing with ``pool_trace`` of at least ``1``. Returns the maximum
+   number of slabs cached for later use by the bucket.
+
+
+Scalable pool (``scalable``)
+------------------------------
+
+The scalable pool currently exposes only the common statistics nodes.
+
+Jemalloc pool (``jemalloc``)
+--------------------------------
+
+The jemalloc-backed pool currently exposes only the common statistics nodes.
+
+================================================
+Adding CTL support to custom providers and pools
+================================================
+
+The :file:`examples/ctl/custom_ctl.c` source demonstrates how a minimal
+provider can expose configuration entries, statistics and runnables through the
+CTL API. To add similar support to your own provider or pool you must implement
+an ``ext_ctl`` callback – parse incoming CTL paths and handle
+``CTL_QUERY_READ``, ``CTL_QUERY_WRITE`` and ``CTL_QUERY_RUNNABLE`` requests.
+The callback receives a ``umf_ctl_query_source_t`` indicating whether the
+query came from the application or a configuration source.  Programmatic
+calls pass typed binary data, while configuration sources deliver strings
+that must be parsed.  Wildcards (``{}``) may appear in paths and are supplied
+as additional arguments.
+
+During initialization UMF will execute ``post_initialize`` on the callback after
+applying any queued defaults, allowing the provider or pool to finalize its
+state before it is used by the application.  The example converts wildcarded
+paths into ``printf``-style format strings with ``%s`` and uses ``vsnprintf`` to
+resolve the extra arguments.  It also shows a helper that accepts integers from
+either source, printing the final values from ``post_initialize``.
+
+Building and running the example:
+
+.. code-block:: bash
+
+   cmake -B build
+   cmake --build build
+   ./build/examples/umf_example_ctl
+
+An optional modulus can be supplied via the environment:
+
+.. code-block:: bash
+
+   UMF_CONF="umf.provider.default.ctl.m=10" ./build/examples/umf_example_ctl
diff --git a/scripts/docs_config/examples.rst b/docs/config/examples.rst
similarity index 79%
rename from scripts/docs_config/examples.rst
rename to docs/config/examples.rst
index c58e7fc223..28b6ab02e7 100644
--- a/scripts/docs_config/examples.rst
+++ b/docs/config/examples.rst
@@ -29,7 +29,7 @@ First, let's create a memory provider object for coarse-grained allocations.
 You have to include the `provider_os_memory.h`_ header with
 the OS Memory Provider API::
 
-    #include "umf/providers/provider_os_memory.h"
+    #include <umf/providers/provider_os_memory.h>
 
 Get a pointer to the OS memory provider operations struct::
 
@@ -74,7 +74,7 @@ Having created a memory ``provider``, you can create a Scalable Memory ``pool``
 to be used for fine-grained allocations. You have to include
 the `pool_scalable.h`_ header with the Scalable Memory Pool API::
 
-    #include "umf/pools/pool_scalable.h"
+    #include <umf/pools/pool_scalable.h>
 
 Use the default set of operations for the Scalable memory pool
 by retrieving an address of the default ops struct::
@@ -131,6 +131,9 @@ TODO
 Memspace
 ==============================================================================
 
+.. note::
+   Memspace examples rely on experimental APIs that may change in future releases.
+
 You can find the full examples code in the `examples/memspace`_ directory
 in the UMF repository.
 
@@ -144,6 +147,59 @@ in the UMF repository.
 
 TODO
 
+CTL example
+==============================================================================
+
+.. note::
+   The CTL API is experimental and may change in future releases.
+
+You can find the full example code in the `examples/ctl/ctl.c`_ file in the
+UMF repository.
+
+The sample configures an OS memory provider and a disjoint pool, reuses the
+provider's canonical ``OS`` selector obtained at runtime, assigns a custom pool
+name, and then mixes ``by_handle`` and ``by_name`` selectors to explore CTL
+statistics. Wildcard nodes are used to choose provider counters, build a
+four-segment ``{}.{}`` chain for the named pool, reset the peak tracker, and
+drill into per-bucket disjoint pool telemetry. The program prints hints on
+``stderr`` explaining which tracing level is necessary when a statistic is
+unavailable.
+
+Build and run the example with::
+
+   cmake -B build
+   cmake --build build
+   ./build/examples/umf_example_ctl_statistics
+
+Detailed disjoint pool counters are disabled unless tracing is configured
+before pool creation. Enable them through the environment::
+
+   UMF_CONF="umf.pool.default.disjoint.params.pool_trace=2" ./build/examples/umf_example_ctl_statistics
+
+Tracing level ``1`` enables slab usage counters, level ``2`` adds allocation
+and free statistics, and level ``3`` additionally emits verbose log messages
+from the pool implementation.
+
+Custom CTL example
+==============================================================================
+
+You can find the full example code in the `examples/ctl/custom_ctl.c`_ file in
+the UMF repository. The program implements a minimal memory provider with CTL
+hooks that accept configuration values, execute runnables, and expose provider
+state through the experimental API. It highlights converting wildcard segments
+to ``printf``-style format strings and reading integers supplied via
+configuration defaults.
+
+Build and run the example with::
+
+   cmake -B build
+   cmake --build build
+   ./build/examples/umf_example_ctl
+
+Optionally supply a modulus via configuration defaults::
+
+   UMF_CONF="umf.provider.default.ctl.m=10" ./build/examples/umf_example_ctl
+
 IPC example with Level Zero Memory Provider
 ==============================================================================
 The full code of the example is in the `examples/ipc_level_zero/ipc_level_zero.c`_ file in the UMF repository.
@@ -178,7 +234,7 @@ by a different library and the caller of the :any:`umfGetIPCHandle` function may
 The :any:`umfGetIPCHandle` function returns the IPC handle and its size. The IPC handle is a byte-copyable opaque
 data structure. The :any:`umf_ipc_handle_t` type is defined as a pointer to a byte array. The size of the handle
 might be different for different memory provider types. The code snippet below demonstrates how the IPC handle can
-be serialized for marshalling purposes.
+be serialized for marshaling purposes.
 
 .. code-block:: c
 
@@ -228,6 +284,8 @@ the :any:`umfCloseIPCHandle` function is called.
 .. _examples/cuda_shared_memory/cuda_shared_memory.c: https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/cuda_shared_memory/cuda_shared_memory.c
 .. _examples/ipc_level_zero/ipc_level_zero.c: https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/ipc_level_zero/ipc_level_zero.c
 .. _examples/custom_file_provider/custom_file_provider.c: https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/custom_file_provider/custom_file_provider.c
+.. _examples/ctl/ctl.c: https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/ctl/ctl.c
+.. _examples/ctl/custom_ctl.c: https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/ctl/custom_ctl.c
 .. _examples/memspace: https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/memspace/
 .. _README: https://github.com/oneapi-src/unified-memory-framework/blob/main/README.md#memory-pool-managers
 .. _umf/ipc.h: https://github.com/oneapi-src/unified-memory-framework/blob/main/include/umf/ipc.h
diff --git a/scripts/docs_config/glossary.rst b/docs/config/glossary.rst
similarity index 100%
rename from scripts/docs_config/glossary.rst
rename to docs/config/glossary.rst
diff --git a/scripts/docs_config/index.rst b/docs/config/index.rst
similarity index 82%
rename from scripts/docs_config/index.rst
rename to docs/config/index.rst
index 3bd20828ff..4447dcd74b 100644
--- a/scripts/docs_config/index.rst
+++ b/docs/config/index.rst
@@ -1,4 +1,4 @@
-.. Copyright 2023 Intel Corporation
+.. Copyright 2023-2025 Intel Corporation
    Intel Unified Memory Framework documentation
 
 Intel Unified Memory Framework documentation
@@ -10,4 +10,6 @@ Intel Unified Memory Framework documentation
    introduction.rst
    examples.rst
    api.rst
+   ctl.rst
    glossary.rst
+
diff --git a/scripts/docs_config/introduction.rst b/docs/config/introduction.rst
similarity index 100%
rename from scripts/docs_config/introduction.rst
rename to docs/config/introduction.rst
diff --git a/docs/config/spelling_exceptions.txt b/docs/config/spelling_exceptions.txt
new file mode 100644
index 0000000000..f329b7c6f3
--- /dev/null
+++ b/docs/config/spelling_exceptions.txt
@@ -0,0 +1,89 @@
+addr
+allocatable
+allocator
+allocators
+calloc
+copyable
+CUcontext
+CUdevice
+customizable
+CXL
+daxX
+deallocating
+deallocation
+deallocations
+dev
+Devdax
+Globals
+highPtr
+hMemtarget
+hPool
+hProvider
+interprocess
+io
+ipc
+jemalloc
+lowPtr
+malloc
+maxnode
+mem
+mempolicies
+mempolicy
+Mempolicy
+memspace
+Memspace
+memspaces
+Memtarget
+memtarget
+memtargets
+middleware
+minBytesToKeep
+multithreading
+Nodemask
+nodemask
+numa
+oneAPI
+oneTBB
+os
+params
+partList
+pid
+poolable
+preallocated
+programmatically
+propertyId
+providential
+providerIpcData
+ptr
+realloc
+runnables
+Scalable
+scalable
+stdout
+Tiering
+tiering
+topologies
+uint
+uintptr
+umf
+umfGetIPCHandle
+umfGetMemoryPropertySize
+umfMemoryProviderAlloc
+umfMemoryProviderGetLastNativeError
+umfMemoryProviderOpenIPCHandle
+umfMemspaceMemtargetAdd
+umfMemspaceUserFilter
+umfOsMemoryProviderParamsDestroy
+umfPool
+umfPoolCalloc
+umfPoolDestroy
+umfPoolGetTag
+umfPoolMallocUsableSize
+umfPoolRealloc
+umfMemspaceUserFilter
+umfMemspaceMemtargetAdd
+unfreed
+usm
+wildcarded
+zA
+ze
diff --git a/scripts/generate_docs.py b/docs/generate_docs.py
similarity index 71%
rename from scripts/generate_docs.py
rename to docs/generate_docs.py
index d5b2a01282..1697eacfe6 100644
--- a/scripts/generate_docs.py
+++ b/docs/generate_docs.py
@@ -6,17 +6,20 @@
 """
 
 from pathlib import Path
-from shutil import rmtree
+from shutil import rmtree, copytree
 import subprocess  # nosec B404
 import time
 
 
 def _check_cwd() -> None:
-    script_path = Path(__file__).resolve().parent
     cwd = Path.cwd()
-    if script_path != cwd:
+    include_dir = Path(cwd, "../include")
+    # Verify if include dir is one level up (as defined in Doxyfile)
+    if not include_dir.exists():
         print(
-            f"{__file__} script has to be run from the 'scripts' directory. Terminating..."
+            f"Include directory {include_dir.resolve()} not found! "
+            "Please run this script from <repo_root_dir>/build!",
+            flush=True,
         )
         exit(1)
 
@@ -66,8 +69,17 @@ def _generate_html(config_path: Path, docs_path: Path) -> None:
 
 def main() -> None:
     _check_cwd()
-    config_path = Path("docs_config").resolve()
-    docs_path = Path("..", "docs").resolve()
+
+    script_dir = Path(__file__).resolve().parent
+    docs_build_path = Path("docs_build").resolve()
+
+    # Sphinx and breathe require access to a Doxygen generated dir ('doxyxml')
+    # so we copy the whole content of the 'docs' dir to the build dir.
+    copytree(Path(script_dir), docs_build_path, dirs_exist_ok=True)
+
+    config_path = Path(docs_build_path, "config").resolve()
+    docs_path = Path(docs_build_path, "generated").resolve()
+
     start = time.time()
     _prepare_docs_dir(docs_path)
     _generate_xml(config_path, docs_path)
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 942579a303..c79e950ed2 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -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
 
@@ -18,7 +18,7 @@ set(EXAMPLE_NAME umf_example_basic)
 add_umf_executable(
     NAME ${EXAMPLE_NAME}
     SRCS basic/basic.c
-    LIBS umf ${LIBHWLOC_LIBRARIES})
+    LIBS umf ${UMF_HWLOC_NAME})
 
 target_include_directories(
     ${EXAMPLE_NAME} PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/utils
@@ -41,16 +41,14 @@ if(UMF_POOL_SCALABLE_ENABLED)
     endif()
 endif()
 
-if(UMF_BUILD_GPU_EXAMPLES
-   AND UMF_BUILD_LIBUMF_POOL_DISJOINT
-   AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
+if(UMF_BUILD_GPU_EXAMPLES AND UMF_LEVEL_ZERO_ENABLED)
     set(EXAMPLE_NAME umf_example_level_zero_shared_memory)
 
     add_umf_executable(
         NAME ${EXAMPLE_NAME}
         SRCS level_zero_shared_memory/level_zero_shared_memory.c
              common/examples_level_zero_helpers.c
-        LIBS disjoint_pool ze_loader umf)
+        LIBS ze_loader umf)
 
     target_include_directories(
         ${EXAMPLE_NAME}
@@ -58,7 +56,8 @@ if(UMF_BUILD_GPU_EXAMPLES
                 ${UMF_CMAKE_SOURCE_DIR}/include
                 ${UMF_CMAKE_SOURCE_DIR}/examples/common)
 
-    target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS})
+    target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS}
+                            ${ZE_LOADER_LIBRARY_DIRS})
 
     add_test(
         NAME ${EXAMPLE_NAME}
@@ -74,20 +73,17 @@ if(UMF_BUILD_GPU_EXAMPLES
     endif()
 else()
     message(STATUS "GPU Level Zero shared memory example requires "
-                   "UMF_BUILD_GPU_EXAMPLES, UMF_BUILD_LEVEL_ZERO_PROVIDER and "
-                   "UMF_BUILD_LIBUMF_POOL_DISJOINT to be turned ON - skipping")
+                   "UMF_BUILD_GPU_EXAMPLES and UMF_BUILD_LEVEL_ZERO_PROVIDER "
+                   "to be turned ON - skipping")
 endif()
 
-if(UMF_BUILD_GPU_EXAMPLES
-   AND UMF_BUILD_LIBUMF_POOL_DISJOINT
-   AND UMF_BUILD_CUDA_PROVIDER
-   AND UMF_CUDA_ENABLED)
+if(UMF_BUILD_GPU_EXAMPLES AND UMF_CUDA_ENABLED)
     set(EXAMPLE_NAME umf_example_cuda_shared_memory)
 
     add_umf_executable(
         NAME ${EXAMPLE_NAME}
         SRCS cuda_shared_memory/cuda_shared_memory.c
-        LIBS disjoint_pool cuda umf)
+        LIBS cuda umf)
 
     target_include_directories(
         ${EXAMPLE_NAME}
@@ -113,15 +109,14 @@ if(UMF_BUILD_GPU_EXAMPLES
 else()
     message(
         STATUS
-            "GPU CUDA shared memory example requires UMF_BUILD_GPU_EXAMPLES, UMF_BUILD_CUDA_PROVIDER, UMF_BUILD_LIBUMF_POOL_DISJOINT to be turned ON and installed CUDA libraries - skipping"
+            "GPU CUDA shared memory example requires UMF_BUILD_GPU_EXAMPLES and UMF_BUILD_CUDA_PROVIDER to be turned ON and installed CUDA libraries - skipping"
     )
 endif()
 
 # TODO: it looks like there is some problem with IPC implementation in Level
 # Zero on windows
 if(UMF_BUILD_GPU_EXAMPLES
-   AND UMF_BUILD_LIBUMF_POOL_DISJOINT
-   AND UMF_BUILD_LEVEL_ZERO_PROVIDER
+   AND UMF_LEVEL_ZERO_ENABLED
    AND LINUX)
     set(EXAMPLE_NAME umf_example_ipc_level_zero)
 
@@ -129,7 +124,7 @@ if(UMF_BUILD_GPU_EXAMPLES
         NAME ${EXAMPLE_NAME}
         SRCS ipc_level_zero/ipc_level_zero.c
              common/examples_level_zero_helpers.c
-        LIBS disjoint_pool ze_loader umf)
+        LIBS ze_loader umf)
 
     target_include_directories(
         ${EXAMPLE_NAME}
@@ -137,7 +132,8 @@ if(UMF_BUILD_GPU_EXAMPLES
                 ${UMF_CMAKE_SOURCE_DIR}/include
                 ${UMF_CMAKE_SOURCE_DIR}/examples/common)
 
-    target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS})
+    target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS}
+                            ${ZE_LOADER_LIBRARY_DIRS})
 
     add_test(
         NAME ${EXAMPLE_NAME}
@@ -154,7 +150,7 @@ if(UMF_BUILD_GPU_EXAMPLES
 else()
     message(
         STATUS
-            "IPC Level 0 example requires UMF_BUILD_GPU_EXAMPLES, UMF_BUILD_LEVEL_ZERO_PROVIDER and UMF_BUILD_LIBUMF_POOL_DISJOINT to be turned ON - skipping"
+            "IPC Level Zero example requires UMF_BUILD_GPU_EXAMPLES and UMF_BUILD_LEVEL_ZERO_PROVIDER to be turned ON - skipping"
     )
 endif()
 
@@ -190,6 +186,7 @@ function(add_umf_ipc_example script)
         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
     set_tests_properties(${EXAMPLE_NAME} PROPERTIES LABELS "example")
+    set_tests_properties(${EXAMPLE_NAME} PROPERTIES TIMEOUT 60)
     if(NOT UMF_TESTS_FAIL_ON_SKIP)
         set_tests_properties(${EXAMPLE_NAME} PROPERTIES SKIP_RETURN_CODE 125)
     endif()
@@ -214,7 +211,7 @@ if(LINUX)
     add_umf_executable(
         NAME ${EXAMPLE_NAME}
         SRCS memspace_numa/memspace_numa.c
-        LIBS umf ${LIBHWLOC_LIBRARIES} numa)
+        LIBS umf ${UMF_HWLOC_NAME} numa)
 
     target_include_directories(
         ${EXAMPLE_NAME}
@@ -237,7 +234,7 @@ if(LINUX)
     add_umf_executable(
         NAME ${EXAMPLE_NAME}
         SRCS memspace_hmat/memspace_hmat.c
-        LIBS umf ${LIBHWLOC_LIBRARIES} numa)
+        LIBS umf ${UMF_HWLOC_NAME} numa)
 
     target_include_directories(
         ${EXAMPLE_NAME}
@@ -261,7 +258,7 @@ if(LINUX)
         add_umf_executable(
             NAME ${EXAMPLE_NAME}
             SRCS custom_file_provider/custom_file_provider.c
-            LIBS umf ${LIBHWLOC_LIBRARIES})
+            LIBS umf ${UMF_HWLOC_NAME})
 
         target_include_directories(
             ${EXAMPLE_NAME} PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/utils
@@ -276,16 +273,55 @@ if(LINUX)
             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
     endif()
 
+    set(EXAMPLE_NAME umf_example_ctl)
+
+    add_umf_executable(
+        NAME ${EXAMPLE_NAME}
+        SRCS ctl/custom_ctl.c
+        LIBS umf ${UMF_HWLOC_NAME})
+
+    target_include_directories(
+        ${EXAMPLE_NAME} PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/utils
+                                ${UMF_CMAKE_SOURCE_DIR}/include)
+
+    target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS})
+
+    add_test(
+        NAME ${EXAMPLE_NAME}
+        COMMAND ${EXAMPLE_NAME}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+    set(EXAMPLE_NAME umf_example_ctl_statistics)
+
+    add_umf_executable(
+        NAME ${EXAMPLE_NAME}
+        SRCS ctl/ctl.c
+        LIBS umf ${UMF_HWLOC_NAME})
+
+    target_include_directories(
+        ${EXAMPLE_NAME} PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/utils
+                                ${UMF_CMAKE_SOURCE_DIR}/include)
+
+    target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS})
+
+    add_test(
+        NAME ${EXAMPLE_NAME}
+        COMMAND ${EXAMPLE_NAME}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
     if(UMF_POOL_JEMALLOC_ENABLED)
         set(EXAMPLE_NAME umf_example_dram_and_fsdax)
 
         add_umf_executable(
             NAME ${EXAMPLE_NAME}
             SRCS dram_and_fsdax/dram_and_fsdax.c
-            LIBS umf jemalloc_pool)
+            LIBS umf)
 
-        target_link_directories(${EXAMPLE_NAME} PRIVATE
-                                ${LIBHWLOC_LIBRARY_DIRS})
+        target_link_options(${EXAMPLE_NAME} PRIVATE "-Wl,--no-as-needed,-ldl")
+
+        target_link_directories(
+            ${EXAMPLE_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS}
+            ${JEMALLOC_LIBRARY_DIRS})
 
         add_test(
             NAME ${EXAMPLE_NAME}
diff --git a/examples/README.md b/examples/README.md
index e7823347ef..4f16e19067 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -24,7 +24,7 @@ cleans up and exits with an error status.
 ### Requirements
 * Level Zero headers and libraries
 * compatible GPU with installed driver
-* set UMF_BUILD_GPU_EXAMPLES, UMF_BUILD_LIBUMF_POOL_DISJOINT and UMF_BUILD_LEVEL_ZERO_PROVIDER CMake configuration flags to ON
+* set UMF_BUILD_GPU_EXAMPLES and UMF_BUILD_LEVEL_ZERO_PROVIDER CMake configuration flags to ON
 
 ## IPC example with Level Zero memory provider
 This example demonstrates how to use UMF IPC API. The example creates two
@@ -35,7 +35,7 @@ and build this example Level Zero development package should be installed.
 ### Requirements
 * Level Zero headers and libraries
 * compatible GPU with installed driver
-* set UMF_BUILD_GPU_EXAMPLES, UMF_BUILD_LIBUMF_POOL_DISJOINT and UMF_BUILD_LEVEL_ZERO_PROVIDER CMake configuration flags to ON
+* set UMF_BUILD_GPU_EXAMPLES and UMF_BUILD_LEVEL_ZERO_PROVIDER CMake configuration flags to ON
 
 ## IPC example with shared memory
 This example also demonstrates how to use UMF IPC API. The example creates two
@@ -66,3 +66,31 @@ processes: a producer and a consumer that communicate in the following way
 - Producer puts the IPC handle
 - Consumer shuts down
 - Producer shuts down
+
+## CTL example
+
+> **Note**: The CTL API is experimental and may change in future releases.
+
+This example configures an OS memory provider and disjoint pool, then queries
+statistics through CTL using both ``by_handle`` and ``by_name`` selectors. It
+demonstrates wildcard nodes to mix selectors, reset peak counters, and read
+disjoint-pool bucket telemetry. Run it with:
+
+  ./umf_example_ctl_statistics
+
+Tracing for detailed disjoint pool counters can be enabled through:
+
+  UMF_CONF="umf.pool.default.disjoint.params.pool_trace=2" ./umf_example_ctl_statistics
+
+## Custom CTL example
+
+> **Note**: The CTL API is experimental and may change in future releases.
+
+This example demonstrates how to add CTL support to a custom memory
+provider. It sets variables ``a`` and ``b`` through CTL, plus it allows
+for the modulus ``m`` to be loaded from the environment or a configuration file.
+Addition and subtraction operations return results modulo ``m`` and the
+result ``c`` can be retrieved using the CTL API. For example, to set the
+modulus through an environment variable run:
+
+  UMF_CONF="umf.provider.default.ctl.m=10" ./umf_example_ctl
diff --git a/examples/basic/basic.c b/examples/basic/basic.c
index 846e71edaa..e58be45389 100644
--- a/examples/basic/basic.c
+++ b/examples/basic/basic.c
@@ -1,18 +1,18 @@
 /*
  *
- * 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
  *
  */
 
-#include "umf/pools/pool_scalable.h"
-#include "umf/providers/provider_os_memory.h"
-
 #include <stdio.h>
 #include <string.h>
 
+#include <umf/pools/pool_scalable.h>
+#include <umf/providers/provider_os_memory.h>
+
 int main(void) {
     // A result object for storing UMF API result status
     umf_result_t res;
@@ -22,7 +22,7 @@ int main(void) {
     // Allocations are made with mmap. The default values of params result
     // in an mmap call like this:
     // mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)
-    umf_memory_provider_ops_t *provider_ops = umfOsMemoryProviderOps();
+    const umf_memory_provider_ops_t *provider_ops = umfOsMemoryProviderOps();
     umf_os_memory_provider_params_handle_t params = NULL;
     umf_memory_provider_handle_t provider;
 
@@ -69,7 +69,7 @@ int main(void) {
     printf("Freed memory at %p\n", ptr_provider);
 
     // Create a memory pool
-    umf_memory_pool_ops_t *pool_ops = umfScalablePoolOps();
+    const umf_memory_pool_ops_t *pool_ops = umfScalablePoolOps();
     void *pool_params = NULL;
     umf_pool_create_flags_t flags = 0;
     umf_memory_pool_handle_t pool;
@@ -96,7 +96,12 @@ int main(void) {
     printf("%s %p\n", ptr, (void *)ptr);
 
     // Retrieve a memory pool from a pointer, available with memory tracking
-    umf_memory_pool_handle_t check_pool = umfPoolByPtr(ptr);
+    umf_memory_pool_handle_t check_pool;
+    res = umfPoolByPtr(ptr, &check_pool);
+    if (res != UMF_RESULT_SUCCESS) {
+        printf("Failed to retrieve a memory pool for the pointer!\n");
+        goto memory_pool_destroy;
+    }
     printf("Memory at %p has been allocated from the pool at %p\n", (void *)ptr,
            (void *)check_pool);
 
diff --git a/examples/cmake/FindCUDA.cmake b/examples/cmake/FindCUDA.cmake
index 5e4e2eeada..d41ddaf77e 100644
--- a/examples/cmake/FindCUDA.cmake
+++ b/examples/cmake/FindCUDA.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
 
@@ -17,6 +17,7 @@ if(WINDOWS)
 endif()
 
 if(CUDA_LIBRARY)
+    set(CUDA_FOUND TRUE)
     message(STATUS "  Found cuda using find_library()")
     message(STATUS "    CUDA_LIBRARIES = ${CUDA_LIBRARIES}")
     message(STATUS "    CUDA_INCLUDE_DIRS = ${CUDA_INCLUDE_DIRS}")
diff --git a/examples/cmake/FindJEMALLOC.cmake b/examples/cmake/FindJEMALLOC.cmake
index 89d488ecc0..6cd1ffedea 100644
--- a/examples/cmake/FindJEMALLOC.cmake
+++ b/examples/cmake/FindJEMALLOC.cmake
@@ -1,10 +1,12 @@
-# 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
 
-message(STATUS "Checking for module 'jemalloc' using find_library()")
+message(
+    STATUS "Looking for the static 'libjemalloc.a' library using find_library()"
+)
 
-find_library(JEMALLOC_LIBRARY NAMES libjemalloc jemalloc)
+find_library(JEMALLOC_LIBRARY NAMES libjemalloc.a jemalloc.a)
 set(JEMALLOC_LIBRARIES ${JEMALLOC_LIBRARY})
 
 get_filename_component(JEMALLOC_LIB_DIR ${JEMALLOC_LIBRARIES} DIRECTORY)
@@ -34,6 +36,7 @@ if(WINDOWS)
 endif()
 
 if(JEMALLOC_LIBRARY)
+    set(JEMALLOC_FOUND TRUE)
     message(STATUS "  Found jemalloc using find_library()")
     message(STATUS "    JEMALLOC_LIBRARIES = ${JEMALLOC_LIBRARIES}")
     message(STATUS "    JEMALLOC_INCLUDE_DIRS = ${JEMALLOC_INCLUDE_DIRS}")
diff --git a/examples/cmake/FindLIBHWLOC.cmake b/examples/cmake/FindLIBHWLOC.cmake
index aa7620bc2d..0bef8be3e2 100644
--- a/examples/cmake/FindLIBHWLOC.cmake
+++ b/examples/cmake/FindLIBHWLOC.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
 
@@ -45,6 +45,7 @@ if(WINDOWS)
 endif()
 
 if(LIBHWLOC_LIBRARY)
+    set(LIBHWLOC_FOUND TRUE)
     message(STATUS "  Found libhwloc using find_library()")
     message(STATUS "    LIBHWLOC_LIBRARIES = ${LIBHWLOC_LIBRARIES}")
     message(STATUS "    LIBHWLOC_INCLUDE_DIRS = ${LIBHWLOC_INCLUDE_DIRS}")
diff --git a/examples/cmake/FindLIBNUMA.cmake b/examples/cmake/FindLIBNUMA.cmake
index 8c23f481c7..4cf40b60d9 100644
--- a/examples/cmake/FindLIBNUMA.cmake
+++ b/examples/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
 
@@ -8,6 +8,7 @@ find_library(LIBNUMA_LIBRARY NAMES libnuma numa)
 set(LIBNUMA_LIBRARIES ${LIBNUMA_LIBRARY})
 
 if(LIBNUMA_LIBRARY)
+    set(LIBNUMA_FOUND TRUE)
     message(STATUS "  Found libnuma using find_library()")
 else()
     set(MSG_NOT_FOUND
diff --git a/examples/cmake/FindLIBUMF.cmake b/examples/cmake/FindLIBUMF.cmake
index 12bdc18239..6012c07b93 100644
--- a/examples/cmake/FindLIBUMF.cmake
+++ b/examples/cmake/FindLIBUMF.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,7 @@ get_filename_component(LIBUMF_INCLUDE_DIR ${LIBUMF_HEADER} DIRECTORY)
 set(LIBUMF_INCLUDE_DIRS ${LIBUMF_INCLUDE_DIR})
 
 if(LIBUMF_LIBRARY)
+    set(LIBUMF_FOUND TRUE)
     message(STATUS "  Found libumf using find_library()")
     message(STATUS "    LIBUMF_LIBRARIES = ${LIBUMF_LIBRARIES}")
     message(STATUS "    LIBUMF_INCLUDE_DIRS = ${LIBUMF_INCLUDE_DIRS}")
diff --git a/examples/cmake/FindTBB.cmake b/examples/cmake/FindTBB.cmake
index 6536e8c4ae..fea1b7a8cf 100644
--- a/examples/cmake/FindTBB.cmake
+++ b/examples/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
 
@@ -32,6 +32,7 @@ if(WINDOWS)
 endif()
 
 if(TBB_LIBRARY)
+    set(TBB_FOUND TRUE)
     message(STATUS "  Found tbb using find_library()")
     message(STATUS "    TBB_LIBRARIES = ${TBB_LIBRARIES}")
     message(STATUS "    TBB_INCLUDE_DIRS = ${TBB_INCLUDE_DIRS}")
diff --git a/examples/cmake/FindZE_LOADER.cmake b/examples/cmake/FindZE_LOADER.cmake
new file mode 100644
index 0000000000..566345de0f
--- /dev/null
+++ b/examples/cmake/FindZE_LOADER.cmake
@@ -0,0 +1,40 @@
+# 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
+
+message(STATUS "Checking for module 'ze_loader' using find_library()")
+
+find_library(ZE_LOADER_LIBRARY NAMES libze_loader ze_loader)
+set(ZE_LOADER_LIBRARIES ${ZE_LOADER_LIBRARY})
+
+find_file(ZE_LOADER_HEADER NAMES "ze_api.h" "level_zero/ze_api.h")
+get_filename_component(ZE_LOADER_INCLUDE_DIR ${ZE_LOADER_HEADER} DIRECTORY)
+set(ZE_LOADER_INCLUDE_DIRS ${ZE_LOADER_INCLUDE_DIR})
+
+get_filename_component(ZE_LOADER_LIB_DIR ${ZE_LOADER_LIBRARIES} DIRECTORY)
+set(ZE_LOADER_LIBRARY_DIRS ${ZE_LOADER_LIB_DIR})
+
+if(WINDOWS)
+    find_file(ZE_LOADER_DLL NAMES "ze_loader.dll")
+    get_filename_component(ZE_LOADER_DLL_DIR ${ZE_LOADER_DLL} DIRECTORY)
+    set(ZE_LOADER_DLL_DIRS ${ZE_LOADER_DLL_DIR})
+endif()
+
+if(ZE_LOADER_LIBRARY)
+    set(ZE_LOADER_FOUND TRUE)
+    message(STATUS "  Found ZE_LOADER using find_library()")
+    message(STATUS "    ZE_LOADER_LIBRARIES = ${ZE_LOADER_LIBRARIES}")
+    message(STATUS "    ZE_LOADER_INCLUDE_DIRS = ${ZE_LOADER_INCLUDE_DIRS}")
+    message(STATUS "    ZE_LOADER_LIBRARY_DIRS = ${ZE_LOADER_LIBRARY_DIRS}")
+    if(WINDOWS)
+        message(STATUS "    ZE_LOADER_DLL_DIRS = ${ZE_LOADER_DLL_DIRS}")
+    endif()
+else()
+    set(MSG_NOT_FOUND "ZE_LOADER NOT found (set CMAKE_PREFIX_PATH to point the "
+                      "location)")
+    if(ZE_LOADER_FIND_REQUIRED)
+        message(FATAL_ERROR ${MSG_NOT_FOUND})
+    else()
+        message(WARNING ${MSG_NOT_FOUND})
+    endif()
+endif()
diff --git a/examples/ctl/CMakeLists.txt b/examples/ctl/CMakeLists.txt
new file mode 100644
index 0000000000..26fee9e83d
--- /dev/null
+++ b/examples/ctl/CMakeLists.txt
@@ -0,0 +1,81 @@
+# 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
+
+cmake_minimum_required(VERSION 3.14.0 FATAL_ERROR)
+project(umf_example_ctl LANGUAGES C)
+enable_testing()
+
+set(UMF_EXAMPLE_DIR "${CMAKE_SOURCE_DIR}/..")
+list(APPEND CMAKE_MODULE_PATH "${UMF_EXAMPLE_DIR}/cmake")
+message(STATUS "CMAKE_MODULE_PATH=${CMAKE_" "MODULE_PATH}")
+
+find_package(PkgConfig)
+pkg_check_modules(LIBUMF libumf)
+if(NOT LIBUMF_FOUND)
+    find_package(LIBUMF REQUIRED libumf)
+endif()
+
+pkg_check_modules(LIBHWLOC hwloc >= 2.3.0)
+if(NOT LIBHWLOC_FOUND)
+    find_package(LIBHWLOC 2.3.0 REQUIRED hwloc)
+endif()
+
+# build the example
+set(EXAMPLE_NAME umf_example_ctl)
+add_executable(${EXAMPLE_NAME} custom_ctl.c)
+target_include_directories(${EXAMPLE_NAME} PRIVATE ${LIBUMF_INCLUDE_DIRS})
+target_link_directories(
+    ${
+    EXAMPLE_NAME}
+    PRIVATE
+    ${
+    LIBHWLOC_LIBRARY_DIRS})
+target_link_libraries(${EXAMPLE_NAME} PRIVATE ${LIBUMF_LIBRARIES} hwloc)
+
+add_test(
+    NAME ${EXAMPLE_NAME}
+    COMMAND ${EXAMPLE_NAME}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+set_tests_properties(${EXAMPLE_NAME} PROPERTIES LABELS "example-standalone")
+
+if(LINUX)
+    # set LD_LIBRARY_PATH
+    set_property(
+        TEST ${EXAMPLE_NAME}
+        PROPERTY ENVIRONMENT_MODIFICATION
+                 "LD_LIBRARY_PATH=path_list_append:"
+                 "${LIBUMF_LIBRARY_DIRS};"
+                 "LD_LIBRARY_PATH=path_list_append:${"
+                 "LIBHWLOC_LIBRARY_DIRS}")
+endif()
+
+set(EXAMPLE_NAME umf_example_ctl_statistics)
+add_executable(${EXAMPLE_NAME} ctl.c)
+target_include_directories(${EXAMPLE_NAME} PRIVATE ${LIBUMF_INCLUDE_DIRS})
+target_link_directories(
+    ${
+    EXAMPLE_NAME}
+    PRIVATE
+    ${
+    LIBHWLOC_LIBRARY_DIRS})
+target_link_libraries(${EXAMPLE_NAME} PRIVATE ${LIBUMF_LIBRARIES} hwloc)
+
+add_test(
+    NAME ${EXAMPLE_NAME}
+    COMMAND ${EXAMPLE_NAME}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+set_tests_properties(${EXAMPLE_NAME} PROPERTIES LABELS "example-standalone")
+
+if(LINUX)
+    # set LD_LIBRARY_PATH
+    set_property(
+        TEST ${EXAMPLE_NAME}
+        PROPERTY ENVIRONMENT_MODIFICATION
+                 "LD_LIBRARY_PATH=path_list_append:"
+                 "${LIBUMF_LIBRARY_DIRS};"
+                 "LD_LIBRARY_PATH=path_list_append:${"
+                 "LIBHWLOC_LIBRARY_DIRS}")
+endif()
diff --git a/examples/ctl/ctl.c b/examples/ctl/ctl.c
new file mode 100644
index 0000000000..1edba4b5e4
--- /dev/null
+++ b/examples/ctl/ctl.c
@@ -0,0 +1,288 @@
+/*
+ *
+ * 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 <stdbool.h>
+#include <stdio.h>
+
+// This example relies on the experimental CTL API, which may change without
+// notice.
+#include <umf/experimental/ctl.h>
+
+#include <umf/base.h>
+#include <umf/memory_pool.h>
+#include <umf/memory_provider.h>
+#include <umf/pools/pool_disjoint.h>
+#include <umf/providers/provider_os_memory.h>
+
+static void print_provider_stats(const char *stage,
+                                 umf_memory_provider_handle_t provider,
+                                 const char *provider_name) {
+    size_t outstanding = 0;
+    size_t peak = 0;
+
+    umf_result_t res =
+        umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                  &outstanding, sizeof(outstanding), provider);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "%s: failed to read provider allocated memory (error %d)\n",
+                stage, (int)res);
+        return;
+    }
+
+    /* you can also pass any nodes through va args by using {} */
+    res = umfCtlGet("umf.provider.by_handle.{}.stats.{}", &peak, sizeof(peak),
+                    provider, "peak_memory");
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "%s: failed to read provider peak memory (error %d)\n",
+                stage, (int)res);
+        return;
+    }
+
+    printf("%s (%s): outstanding=%zu bytes, peak=%zu bytes\n", stage,
+           provider_name, outstanding, peak);
+}
+
+/* Provide tutorial guidance when disjoint pool counters require tracing. */
+static bool report_pool_stat_failure(const char *label,
+                                     int required_trace_level,
+                                     umf_result_t res) {
+    if (res == UMF_RESULT_SUCCESS) {
+        return false;
+    }
+
+    if (res == UMF_RESULT_ERROR_NOT_SUPPORTED) {
+        int hint_level = required_trace_level;
+        const char *reason = "verbose logging";
+
+        if (hint_level <= 1) {
+            hint_level = 1;
+            reason = "slab statistics";
+        } else if (hint_level == 2) {
+            reason = "allocation counters";
+        } else {
+            hint_level = 3;
+        }
+
+        fprintf(
+            stderr,
+            "Cannot read %s because disjoint pool tracing level %d is "
+            "required. "
+            "This example do not set pool_trace so you can enable it through "
+            "env variable.\n"
+            "Set UMF_CONF=\"umf.pool.default.disjoint.params.pool_trace=%d\" "
+            "before running to enable %s%s.\n",
+            label, hint_level, hint_level, reason,
+            hint_level < 3 ? " (level 3 also enables verbose logging)" : "");
+    } else {
+        fprintf(stderr, "Failed to read %s (error %d)\n", label, (int)res);
+    }
+
+    return true;
+}
+
+static void print_pool_stat_by_handle(const char *label,
+                                      umf_memory_pool_handle_t pool,
+                                      const char *stat_node,
+                                      int required_trace_level) {
+    size_t value = 0;
+    /* Surround the {} placeholder with literal segments so CTL resolves
+     * whichever pool handle the allocator hands back. */
+    umf_result_t res = umfCtlGet("umf.pool.by_handle.{}.stats.{}", &value,
+                                 sizeof(value), pool, stat_node);
+    if (report_pool_stat_failure(label, required_trace_level, res)) {
+        return;
+    }
+
+    printf("%s: %zu\n", label, value);
+}
+
+static void print_pool_bucket_stat_by_name(const char *label,
+                                           const char *pool_name,
+                                           size_t bucket_index,
+                                           const char *stat_node,
+                                           int required_trace_level) {
+    size_t value = 0;
+    /* Anchor the pool label with by_name while {} wildcards cover the ordinal
+     * and statistic nodes to highlight mixed selectors. */
+    umf_result_t res =
+        umfCtlGet("umf.pool.by_name.{}.buckets.{}.stats.{}", &value,
+                  sizeof(value), pool_name, bucket_index, stat_node);
+
+    if (report_pool_stat_failure(label, required_trace_level, res)) {
+        return;
+    }
+
+    printf("%s: %zu\n", label, value);
+}
+
+#define pool_name "ctl_stats_pool"
+int main(void) {
+    const size_t provider_allocation_size = 64 * 1024;
+    const size_t pool_allocation_size = 4096;
+    const char *provider_name = NULL;
+    void *pool_memory = NULL;
+    umf_result_t res = UMF_RESULT_SUCCESS;
+
+    const umf_memory_provider_ops_t *provider_ops = umfOsMemoryProviderOps();
+    umf_os_memory_provider_params_handle_t os_params = NULL;
+    umf_memory_provider_handle_t provider = NULL;
+    umf_disjoint_pool_params_handle_t disjoint_params = NULL;
+    umf_memory_pool_handle_t pool = NULL;
+
+    res = umfOsMemoryProviderParamsCreate(&os_params);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "Failed to create OS memory provider params (error %d)\n",
+                (int)res);
+        return -1;
+    }
+
+    res = umfMemoryProviderCreate(provider_ops, os_params, &provider);
+    umfOsMemoryProviderParamsDestroy(os_params);
+    os_params = NULL;
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create OS memory provider (error %d)\n",
+                (int)res);
+        return -1;
+    }
+
+    umfMemoryProviderGetName(provider, &provider_name);
+
+    print_provider_stats("Provider stats before allocation", provider,
+                         provider_name);
+
+    void *provider_memory = NULL;
+    res = umfMemoryProviderAlloc(provider, provider_allocation_size, 0,
+                                 &provider_memory);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Provider allocation failed (error %d)\n", (int)res);
+        goto cleanup;
+    }
+
+    print_provider_stats("Provider stats after allocation", provider,
+                         provider_name);
+
+    res = umfMemoryProviderFree(provider, provider_memory,
+                                provider_allocation_size);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Provider free failed (error %d)\n", (int)res);
+        goto cleanup;
+    }
+    provider_memory = NULL;
+
+    print_provider_stats("Provider stats after free", provider, provider_name);
+
+    res = umfCtlExec("umf.provider.by_handle.{}.stats.peak_memory.reset", NULL,
+                     0, provider);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to reset provider peak memory (error %d)\n",
+                (int)res);
+        goto cleanup;
+    }
+
+    print_provider_stats("Provider stats after peak reset", provider,
+                         provider_name);
+
+    const umf_memory_pool_ops_t *pool_ops = umfDisjointPoolOps();
+    res = umfDisjointPoolParamsCreate(&disjoint_params);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create disjoint pool params (error %d)\n",
+                (int)res);
+        goto cleanup;
+    }
+
+    /* set name of the pool so we can easily ref it by using name */
+    res = umfDisjointPoolParamsSetName(disjoint_params, pool_name);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to name disjoint pool (error %d)\n", (int)res);
+        goto cleanup;
+    }
+
+    res = umfPoolCreate(pool_ops, provider, disjoint_params, 0, &pool);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create disjoint pool (error %d)\n",
+                (int)res);
+        goto cleanup;
+    }
+
+    pool_memory = umfPoolMalloc(pool, pool_allocation_size);
+    if (pool_memory == NULL) {
+        fprintf(stderr, "Disjoint pool allocation failed\n");
+        goto cleanup;
+    }
+
+    print_pool_stat_by_handle("Disjoint pool used_memory", pool, "used_memory",
+                              0);
+    print_pool_stat_by_handle("Disjoint pool curr_slabs_in_use", pool,
+                              "curr_slabs_in_use", 1);
+    print_pool_stat_by_handle("Disjoint pool alloc_num", pool, "alloc_num", 2);
+
+    size_t pool_name_count = 0;
+
+    res = umfCtlGet("umf.pool.by_name.{}.count", &pool_name_count,
+                    sizeof(pool_name_count), pool_name);
+
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to read pool count (error %d)\n", (int)res);
+        goto cleanup;
+    }
+    printf("There is %zu pools with name %s\n", pool_name_count, pool_name);
+    size_t bucket_count = 0;
+
+    // you can put pool_name directly in ctl string without {} if you want
+    res = umfCtlGet("umf.pool.by_name." pool_name ".buckets.count",
+                    &bucket_count, sizeof(bucket_count));
+
+    for (size_t bucket = 0; bucket < bucket_count; bucket++) {
+        size_t bucket_size = 0;
+        // after pool name you can add pool index if there are multiple pools with
+        // the same name, if there is only one it is safe to omit it
+        // but still you can provide it
+        res = umfCtlGet("umf.pool.by_name.{}.0.buckets.{}.size", &bucket_size,
+                        sizeof(bucket_size), pool_name, bucket);
+        if (res != UMF_RESULT_SUCCESS) {
+            fprintf(stderr, "Failed to read bucket size (error %d)\n",
+                    (int)res);
+            goto cleanup;
+        }
+
+        if (bucket_size == pool_allocation_size) {
+            printf("Disjoint pool bucket[%zu] size: %zu bytes\n", bucket,
+                   bucket_size);
+            print_pool_bucket_stat_by_name("Disjoint pool bucket alloc_num",
+                                           pool_name, bucket, "alloc_num", 2);
+            print_pool_bucket_stat_by_name(
+                "Disjoint pool bucket curr_slabs_in_use", pool_name, bucket,
+                "curr_slabs_in_use", 1);
+            goto cleanup;
+        }
+    }
+
+cleanup:
+    if (pool_memory) {
+        umfFree(pool_memory);
+    }
+
+    if (pool) {
+        umfPoolDestroy(pool);
+    }
+    if (disjoint_params) {
+        umfDisjointPoolParamsDestroy(disjoint_params);
+    }
+    if (provider_memory) {
+        umfMemoryProviderFree(provider, provider_memory,
+                              provider_allocation_size);
+    }
+    if (provider) {
+        umfMemoryProviderDestroy(provider);
+    }
+
+    return 0;
+}
diff --git a/examples/ctl/custom_ctl.c b/examples/ctl/custom_ctl.c
new file mode 100644
index 0000000000..83f5509940
--- /dev/null
+++ b/examples/ctl/custom_ctl.c
@@ -0,0 +1,320 @@
+/*
+ *
+ * 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
+ *
+ */
+
+#define _GNU_SOURCE 1
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// This example relies on the experimental CTL API, which may change without
+// notice.
+#include <umf/experimental/ctl.h>
+
+#include <umf.h>
+#include <umf/base.h>
+
+#include <umf/memory_provider.h>
+#include <umf/memory_provider_ops.h>
+
+// Minimal memory provider demonstrating CTL integration
+
+// Provider state exposed via CTL
+typedef struct ctl_provider_t {
+    int a, b, c, m;
+} ctl_provider_t;
+
+static umf_result_t ctl_init(const void *params, void **provider) {
+    (void)params;
+    ctl_provider_t *p = calloc(1, sizeof(*p));
+    if (!p) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+    *provider = p;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t ctl_finalize(void *provider) {
+    free(provider);
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t ctl_alloc(void *provider, size_t size, size_t alignment,
+                              void **ptr) {
+    (void)provider;
+    (void)alignment;
+    *ptr = malloc(size);
+    if (*ptr == NULL) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t ctl_free(void *provider, void *ptr, size_t size) {
+    (void)provider;
+    (void)size;
+    free(ptr);
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t ctl_get_last_native_error(void *provider,
+                                              const char **ppMessage,
+                                              int32_t *pError) {
+    (void)provider;
+    if (ppMessage) {
+        *ppMessage = NULL;
+    }
+    if (pError) {
+        *pError = 0;
+    }
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t ctl_get_recommended_page_size(void *provider, size_t size,
+                                                  size_t *pageSize) {
+    (void)provider;
+    (void)size;
+    *pageSize = 4096;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t ctl_get_min_page_size(void *provider, const void *ptr,
+                                          size_t *pageSize) {
+    (void)provider;
+    (void)ptr;
+    *pageSize = 4096;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t ctl_get_name(void *provider, const char **name) {
+    (void)provider;
+    if (name) {
+        *name = "ctl";
+    }
+    return UMF_RESULT_SUCCESS;
+}
+
+// Wildcards (`{}`) become extra args; convert them to `%s` for `vsnprintf`.
+static void replace_braces_with_percent_s(const char *name, char *fmt,
+                                          size_t fmt_size) {
+    size_t i = 0, j = 0;
+    while (name[i] != '\0' && j < fmt_size - 1) {
+        if (name[i] == '{' && name[i + 1] == '}' && j < fmt_size - 2) {
+            fmt[j++] = '%';
+            fmt[j++] = 's';
+            i += 2;
+        } else {
+            fmt[j++] = name[i++];
+        }
+    }
+    fmt[j] = '\0';
+}
+
+// Parse an integer from programmatic (binary) or configuration (string) input.
+static umf_result_t parse_int(void *arg, size_t size,
+                              umf_ctl_query_source_t source, int *out) {
+    if (!arg || !out) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (source == CTL_QUERY_PROGRAMMATIC) {
+        if (size != sizeof(int)) {
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+        *out = *(int *)arg;
+        return UMF_RESULT_SUCCESS;
+    } else if (source == CTL_QUERY_CONFIG_INPUT) {
+        char *buf = malloc(size + 1);
+        if (!buf) {
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        }
+        memcpy(buf, arg, size);
+        buf[size] = '\0';
+        *out = (int)strtol(buf, NULL, 10);
+        free(buf);
+        return UMF_RESULT_SUCCESS;
+    }
+
+    return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+}
+
+// CTL callback interpreting provider-specific paths and actions
+static umf_result_t ctl_ctl(void *provider, umf_ctl_query_source_t source,
+                            const char *name, void *arg, size_t size,
+                            umf_ctl_query_type_t queryType, va_list args) {
+    ctl_provider_t *p = (ctl_provider_t *)provider;
+
+    char fmt[128];
+    char formatted[128];
+    replace_braces_with_percent_s(name, fmt, sizeof(fmt));
+    va_list args_copy;
+    va_copy(args_copy, args);
+    vsnprintf(formatted, sizeof(formatted), fmt, args_copy);
+    va_end(args_copy);
+
+    if (queryType == CTL_QUERY_RUNNABLE &&
+        strcmp(formatted, "post_initialize") == 0) {
+        // Called once defaults have been loaded
+        printf("post_initialize: a=%d b=%d c=%d m=%d\n", p->a, p->b, p->c,
+               p->m);
+        return UMF_RESULT_SUCCESS;
+    }
+
+    if (queryType == CTL_QUERY_WRITE && strcmp(formatted, "a") == 0) {
+        int val = 0;
+        umf_result_t ret = parse_int(arg, size, source, &val);
+        if (ret != UMF_RESULT_SUCCESS) {
+            return ret;
+        }
+        p->a = val;
+        return UMF_RESULT_SUCCESS;
+    }
+    if (queryType == CTL_QUERY_WRITE && strcmp(formatted, "b") == 0) {
+        int val = 0;
+        umf_result_t ret = parse_int(arg, size, source, &val);
+        if (ret != UMF_RESULT_SUCCESS) {
+            return ret;
+        }
+        p->b = val;
+        return UMF_RESULT_SUCCESS;
+    }
+    if (queryType == CTL_QUERY_WRITE && strcmp(formatted, "m") == 0) {
+        int val = 0;
+        umf_result_t ret = parse_int(arg, size, source, &val);
+        if (ret != UMF_RESULT_SUCCESS) {
+            return ret;
+        }
+        p->m = val;
+        return UMF_RESULT_SUCCESS;
+    }
+    if (queryType == CTL_QUERY_RUNNABLE && strcmp(formatted, "addition") == 0) {
+        if (p->m) {
+            p->c = (p->a + p->b) % p->m;
+        } else {
+            p->c = p->a + p->b;
+        }
+        if (arg && size == sizeof(int)) {
+            *(int *)arg = p->c;
+        }
+        return UMF_RESULT_SUCCESS;
+    }
+    if (queryType == CTL_QUERY_RUNNABLE &&
+        strcmp(formatted, "subtraction") == 0) {
+        if (p->m) {
+            p->c = (p->a - p->b) % p->m;
+        } else {
+            p->c = p->a - p->b;
+        }
+        if (arg && size == sizeof(int)) {
+            *(int *)arg = p->c;
+        }
+        return UMF_RESULT_SUCCESS;
+    }
+    if (queryType == CTL_QUERY_READ && strcmp(formatted, "c") == 0) {
+        if (arg == NULL || size != sizeof(int)) {
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+        *(int *)arg = p->c;
+        return UMF_RESULT_SUCCESS;
+    }
+    if (queryType == CTL_QUERY_READ && strcmp(formatted, "m") == 0) {
+        if (arg == NULL || size != sizeof(int)) {
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+        *(int *)arg = p->m;
+        return UMF_RESULT_SUCCESS;
+    }
+
+    return UMF_RESULT_ERROR_INVALID_CTL_PATH;
+}
+
+static umf_memory_provider_ops_t ctl_ops = {
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
+    .initialize = ctl_init,
+    .finalize = ctl_finalize,
+    .alloc = ctl_alloc,
+    .free = ctl_free,
+    .get_last_native_error = ctl_get_last_native_error,
+    .get_recommended_page_size = ctl_get_recommended_page_size,
+    .get_min_page_size = ctl_get_min_page_size,
+    .get_name = ctl_get_name,
+    .ext_ctl = ctl_ctl, // register CTL handler
+};
+
+int main(void) {
+    umf_result_t res;
+    umf_memory_provider_handle_t provider;
+
+    // Create provider instance and wire in CTL callbacks
+    res = umfMemoryProviderCreate(&ctl_ops, NULL, &provider);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create a memory provider!\n");
+        return -1;
+    }
+    printf("ctl provider created at %p\n", (void *)provider);
+    // Defaults are now applied and `post_initialize` has run
+
+    int a = 10;
+    int b = 7;
+    // Set variables via CTL; `{}` is replaced by the provider handle
+    res = umfCtlSet("umf.provider.by_handle.{}.a", &a, sizeof(a), provider);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set a!\n");
+        goto out;
+    }
+    res = umfCtlSet("umf.provider.by_handle.{}.b", &b, sizeof(b), provider);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set b!\n");
+        goto out;
+    }
+    int m = 0;
+    // Read optional modulus from config or environment you can use {} to replace any node
+    res =
+        umfCtlGet("umf.provider.by_handle.{}.{}", &m, sizeof(m), provider, "c");
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to get m!\n");
+        goto out;
+    }
+    printf("using modulus m=%d\n", m);
+
+    int result = 0;
+
+    // Execute addition and fetch the result
+    res = umfCtlExec("umf.provider.by_handle.{}.addition", NULL, 0, provider);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to execute addition!\n");
+        goto out;
+    }
+    res = umfCtlGet("umf.provider.by_handle.{}.c", &result, sizeof(result),
+                    provider);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to get c!\n");
+        goto out;
+    }
+    printf("addition result: %d\n", result);
+
+    // Execute subtraction and fetch the result
+    res =
+        umfCtlExec("umf.provider.by_handle.{}.subtraction", NULL, 0, provider);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to execute subtraction!\n");
+        goto out;
+    }
+    res = umfCtlGet("umf.provider.by_handle.{}.c", &result, sizeof(result),
+                    provider);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to get c!\n");
+        goto out;
+    }
+    printf("subtraction result: %d\n", result);
+
+out:
+    umfMemoryProviderDestroy(provider);
+    return 0;
+}
diff --git a/examples/cuda_shared_memory/CMakeLists.txt b/examples/cuda_shared_memory/CMakeLists.txt
index dd8567c141..d6aa60dad8 100644
--- a/examples/cuda_shared_memory/CMakeLists.txt
+++ b/examples/cuda_shared_memory/CMakeLists.txt
@@ -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,43 +21,51 @@ if(NOT LIBHWLOC_FOUND)
     find_package(LIBHWLOC 2.3.0 REQUIRED hwloc)
 endif()
 
-find_package(CUDA REQUIRED cuda)
-
+# the CUDA headers are fetched from the NVIDIA repository
 include(FetchContent)
 
 set(CUDA_REPO "https://gitlab.com/nvidia/headers/cuda-individual/cudart.git")
 set(CUDA_TAG cuda-12.5.1)
-
 message(STATUS "Fetching CUDA ${CUDA_TAG} from ${CUDA_REPO} ...")
 
-FetchContent_Declare(
-    cuda-headers
-    GIT_REPOSITORY ${CUDA_REPO}
-    GIT_TAG ${CUDA_TAG}
-    EXCLUDE_FROM_ALL)
-FetchContent_MakeAvailable(cuda-headers)
+# We don't want to build and include CUDA binaries to our install target. For
+# CMake >= 3.28 we use EXCLUDE_FROM_ALL flag to do that, but for older versions
+# we need to use FetchContent_Populate.
+if(CMAKE_VERSION VERSION_LESS 3.28)
+    FetchContent_Declare(
+        cuda-headers
+        GIT_REPOSITORY ${CUDA_REPO}
+        GIT_TAG ${CUDA_TAG})
+    FetchContent_Populate(cuda-headers)
+else()
+    FetchContent_Declare(
+        cuda-headers
+        GIT_REPOSITORY ${CUDA_REPO}
+        GIT_TAG ${CUDA_TAG}
+        EXCLUDE_FROM_ALL)
+    FetchContent_MakeAvailable(cuda-headers)
+endif()
 
 set(CUDA_INCLUDE_DIRS
     ${cuda-headers_SOURCE_DIR}
     CACHE PATH "Path to CUDA headers")
-message(STATUS "CUDA include directory: ${CUDA_INCLUDE_DIRS}")
+
+find_package(CUDA REQUIRED cuda)
+
+set(CUDA_SM_LIBRARY_DIRS ${LIBUMF_LIBRARY_DIRS} ${LIBHWLOC_LIBRARY_DIRS}
+                         ${CUDA_LIBRARY_DIRS})
+set(CUDA_SM_INCLUDE_DIRS ${CUDA_INCLUDE_DIRS} ${LIBUMF_INCLUDE_DIRS}
+                         ${UMF_EXAMPLE_DIR}/common)
+set(CUDA_SM_LIBS stdc++ ${CUDA_LIBRARIES} ${LIBUMF_LIBRARIES})
 
 # build the example
 set(EXAMPLE_NAME umf_example_cuda_shared_memory)
 add_executable(${EXAMPLE_NAME} cuda_shared_memory.c)
-target_include_directories(
-    ${EXAMPLE_NAME} PRIVATE ${CUDA_INCLUDE_DIRS} ${LIBUMF_INCLUDE_DIRS}
-                            ${UMF_EXAMPLE_DIR}/common)
-target_link_directories(
-    ${EXAMPLE_NAME}
-    PRIVATE
-    ${LIBUMF_LIBRARY_DIRS}
-    ${LIBHWLOC_LIBRARY_DIRS}
-    ${CUDA_LIBRARY_DIRS})
+target_include_directories(${EXAMPLE_NAME} PRIVATE ${CUDA_SM_INCLUDE_DIRS})
+target_link_directories(${EXAMPLE_NAME} PRIVATE ${CUDA_SM_LIBRARY_DIRS})
 target_link_options(${EXAMPLE_NAME} PRIVATE "-Wl,--start-group")
-target_link_libraries(
-    ${EXAMPLE_NAME} PRIVATE stdc++ libdisjoint_pool.a ${CUDA_LIBRARIES}
-                            ${LIBUMF_LIBRARIES})
+target_link_libraries(${EXAMPLE_NAME} PRIVATE ${CUDA_SM_LIBS})
+target_link_options(${EXAMPLE_NAME} PRIVATE "-Wl,--end-group")
 
 # an optional part - adds a test of this example
 add_test(
@@ -69,10 +77,10 @@ set_tests_properties(${EXAMPLE_NAME} PROPERTIES LABELS "example-standalone")
 
 if(LINUX)
     # set LD_LIBRARY_PATH
+    string(JOIN ":" CUDA_SM_LIBRARY_DIRS_JOINED ${CUDA_SM_LIBRARY_DIRS})
     set_property(
         TEST ${EXAMPLE_NAME}
         PROPERTY
             ENVIRONMENT_MODIFICATION
-            "LD_LIBRARY_PATH=path_list_append:${LIBUMF_LIBRARY_DIRS};LD_LIBRARY_PATH=path_list_append:${LIBHWLOC_LIBRARY_DIRS}"
-    )
+            "LD_LIBRARY_PATH=path_list_append:${CUDA_SM_LIBRARY_DIRS_JOINED}")
 endif()
diff --git a/examples/cuda_shared_memory/cuda_shared_memory.c b/examples/cuda_shared_memory/cuda_shared_memory.c
index 50c8f92400..883297edba 100644
--- a/examples/cuda_shared_memory/cuda_shared_memory.c
+++ b/examples/cuda_shared_memory/cuda_shared_memory.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -146,7 +146,7 @@ int main(void) {
 
     // Allocate some memory from the pool
     int *ptr = umfPoolMalloc(cu_disjoint_memory_pool, sizeof(int));
-    if (res != UMF_RESULT_SUCCESS) {
+    if (ptr == NULL) {
         fprintf(stderr, "Failed to allocate memory from the memory pool!\n");
         ret = -1;
         goto memory_pool_destroy;
diff --git a/examples/custom_file_provider/custom_file_provider.c b/examples/custom_file_provider/custom_file_provider.c
index ffa61d63f5..1ba934a589 100644
--- a/examples/custom_file_provider/custom_file_provider.c
+++ b/examples/custom_file_provider/custom_file_provider.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -8,9 +8,6 @@
  */
 #define _GNU_SOURCE 1
 
-#include <umf/base.h>
-#include <umf/pools/pool_scalable.h>
-
 #include <fcntl.h>
 #include <linux/falloc.h>
 #include <stdio.h>
@@ -19,6 +16,9 @@
 #include <sys/mman.h>
 #include <unistd.h>
 
+#include <umf/base.h>
+#include <umf/pools/pool_scalable.h>
+
 // Define the size for address reservation
 #define ADDRESS_RESERVATION ((size_t)16 * 1024 * 1024 * 1024)
 
@@ -40,7 +40,7 @@ typedef struct file_params_t {
 } file_params_t;
 
 // Function to initialize the file provider
-static umf_result_t file_init(void *params, void **provider) {
+static umf_result_t file_init(const void *params, void **provider) {
     file_provider_t *file_provider = NULL;
 
     if (params == NULL || provider == NULL) {
@@ -48,7 +48,7 @@ static umf_result_t file_init(void *params, void **provider) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    file_params_t *file_params = (file_params_t *)params;
+    const file_params_t *file_params = params;
     int page_size = 0;
     umf_result_t ret = UMF_RESULT_SUCCESS;
 
@@ -62,7 +62,8 @@ static umf_result_t file_init(void *params, void **provider) {
     // Open the file
     file_provider->fd = open(file_params->filename, O_RDWR | O_CREAT, 0666);
     if (file_provider->fd < 0) {
-        perror("Failed to open file");
+        perror("open()");
+        fprintf(stderr, "Failed to open the file: %s\n", file_params->filename);
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
         goto cleanup_malloc;
     }
@@ -103,11 +104,12 @@ static umf_result_t file_init(void *params, void **provider) {
 }
 
 // Function to deinitialize the file provider
-static void file_deinit(void *provider) {
+static umf_result_t file_deinit(void *provider) {
     file_provider_t *file_provider = (file_provider_t *)provider;
     munmap(file_provider->ptr, ADDRESS_RESERVATION);
     close(file_provider->fd);
     free(file_provider);
+    return UMF_RESULT_SUCCESS;
 }
 
 // Function to allocate memory from the file provider
@@ -199,18 +201,25 @@ static umf_result_t file_free(void *provider, void *ptr, size_t size) {
 }
 
 // Function to get the name of the file provider
-static const char *file_get_name(void *provider) {
+static umf_result_t file_get_name(void *provider, const char **name) {
     (void)provider; // Unused parameter
-    return "File Provider";
+    if (!name) {
+        fprintf(stderr, "Name is NULL\n");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    *name = "File Provider";
+    return UMF_RESULT_SUCCESS;
 }
 
 // Function to get the last native error of the file provider
 // This function is needed only if the provider returns UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC
-static void file_get_last_native_error(void *provider, const char **ppMessage,
-                                       int32_t *pError) {
+static umf_result_t file_get_last_native_error(void *provider,
+                                               const char **ppMessage,
+                                               int32_t *pError) {
     (void)provider; // Unused parameter
     *ppMessage = "";
     *pError = 0;
+    return UMF_RESULT_SUCCESS;
 }
 
 // Function to get the recommended page size of the file provider
@@ -223,7 +232,7 @@ static umf_result_t file_get_recommended_page_size(void *provider, size_t size,
 }
 
 // Function to get the minimum page size of the file provider
-static umf_result_t file_get_min_page_size(void *provider, void *ptr,
+static umf_result_t file_get_min_page_size(void *provider, const void *ptr,
                                            size_t *pageSize) {
     (void)ptr; // Unused parameter
     file_provider_t *file_provider = (file_provider_t *)provider;
@@ -233,15 +242,15 @@ static umf_result_t file_get_min_page_size(void *provider, void *ptr,
 
 // File provider operations
 static umf_memory_provider_ops_t file_ops = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = file_init,
     .finalize = file_deinit,
     .alloc = file_alloc,
+    .free = file_free,
     .get_name = file_get_name,
     .get_last_native_error = file_get_last_native_error,
     .get_recommended_page_size = file_get_recommended_page_size,
     .get_min_page_size = file_get_min_page_size,
-    .ext.free = file_free,
 };
 
 // Main function
@@ -290,7 +299,7 @@ int main(void) {
     printf("Freed memory at %p\n", ptr_provider);
 
     // Create a memory pool
-    umf_memory_pool_ops_t *pool_ops = umfScalablePoolOps();
+    const umf_memory_pool_ops_t *pool_ops = umfScalablePoolOps();
     void *pool_params = NULL;
     umf_pool_create_flags_t flags = 0;
     umf_memory_pool_handle_t pool;
@@ -317,7 +326,12 @@ int main(void) {
     printf("%s %p\n", ptr, (void *)ptr);
 
     // Retrieve a memory pool from a pointer, available with memory tracking
-    umf_memory_pool_handle_t check_pool = umfPoolByPtr(ptr);
+    umf_memory_pool_handle_t check_pool;
+    res = umfPoolByPtr(ptr, &check_pool);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to retrieve a memory pool for the pointer!\n");
+        goto memory_pool_destroy;
+    }
     printf("Memory at %p has been allocated from the pool at %p\n", (void *)ptr,
            (void *)check_pool);
 
diff --git a/examples/dram_and_fsdax/CMakeLists.txt b/examples/dram_and_fsdax/CMakeLists.txt
index 0d0bf25935..dcb538085e 100644
--- a/examples/dram_and_fsdax/CMakeLists.txt
+++ b/examples/dram_and_fsdax/CMakeLists.txt
@@ -21,26 +21,15 @@ if(NOT LIBHWLOC_FOUND)
     find_package(LIBHWLOC 2.3.0 REQUIRED hwloc)
 endif()
 
-pkg_check_modules(JEMALLOC jemalloc)
-if(NOT JEMALLOC_FOUND)
-    find_package(JEMALLOC REQUIRED jemalloc)
-endif()
-
 # build the example
 set(EXAMPLE_NAME umf_example_dram_and_fsdax)
 add_executable(${EXAMPLE_NAME} dram_and_fsdax.c)
 target_include_directories(${EXAMPLE_NAME} PRIVATE ${LIBUMF_INCLUDE_DIRS})
 
-target_link_directories(
-    ${EXAMPLE_NAME}
-    PRIVATE
-    ${LIBUMF_LIBRARY_DIRS}
-    ${LIBHWLOC_LIBRARY_DIRS}
-    ${JEMALLOC_LIBRARY_DIRS})
+target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBUMF_LIBRARY_DIRS}
+                        ${LIBHWLOC_LIBRARY_DIRS})
 
-target_link_libraries(
-    ${EXAMPLE_NAME} PRIVATE hwloc jemalloc_pool ${JEMALLOC_LIBRARIES}
-                            ${LIBUMF_LIBRARIES})
+target_link_libraries(${EXAMPLE_NAME} PRIVATE hwloc ${LIBUMF_LIBRARIES})
 
 # an optional part - adds a test of this example
 add_test(
@@ -56,6 +45,6 @@ if(LINUX)
         TEST ${EXAMPLE_NAME}
         PROPERTY
             ENVIRONMENT_MODIFICATION
-            "LD_LIBRARY_PATH=path_list_append:${LIBUMF_LIBRARY_DIRS};LD_LIBRARY_PATH=path_list_append:${LIBHWLOC_LIBRARY_DIRS};LD_LIBRARY_PATH=path_list_append:${JEMALLOC_LIBRARY_DIRS}"
+            "LD_LIBRARY_PATH=path_list_append:${LIBUMF_LIBRARY_DIRS};LD_LIBRARY_PATH=path_list_append:${LIBHWLOC_LIBRARY_DIRS}"
     )
 endif()
diff --git a/examples/dram_and_fsdax/dram_and_fsdax.c b/examples/dram_and_fsdax/dram_and_fsdax.c
index 26f4517281..4486934d98 100644
--- a/examples/dram_and_fsdax/dram_and_fsdax.c
+++ b/examples/dram_and_fsdax/dram_and_fsdax.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -9,13 +9,12 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <umf/memory_pool.h>
 #include <umf/memory_provider.h>
+#include <umf/pools/pool_jemalloc.h>
 #include <umf/providers/provider_file_memory.h>
 #include <umf/providers/provider_os_memory.h>
 
-#include <umf/memory_pool.h>
-#include <umf/pools/pool_jemalloc.h>
-
 static umf_memory_pool_handle_t create_dram_pool(void) {
     umf_memory_provider_handle_t provider_dram = NULL;
     umf_memory_pool_handle_t pool_dram;
@@ -54,7 +53,7 @@ static umf_memory_pool_handle_t create_fsdax_pool(const char *path) {
     umf_result_t umf_result;
 
     umf_file_memory_provider_params_handle_t params_fsdax = NULL;
-    umf_result = umfFileMemoryProviderParamsCreate(&params_fsdax, path);
+    umf_result = umfFileMemoryProviderParamsCreate(path, &params_fsdax);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "Failed to create the File Memory Provider params");
         return NULL;
@@ -78,41 +77,14 @@ static umf_memory_pool_handle_t create_fsdax_pool(const char *path) {
     }
 
     // Create an FSDAX memory pool
-    //
-    // The file memory provider does not support the free operation
-    // (`umfMemoryProviderFree()` always returns `UMF_RESULT_ERROR_NOT_SUPPORTED`),
-    // so it should be used with a pool manager that will take over
-    // the managing of the provided memory - for example the jemalloc pool
-    // with the `disable_provider_free` parameter set to true.
-    umf_jemalloc_pool_params_handle_t pool_params;
-    umf_result = umfJemallocPoolParamsCreate(&pool_params);
-    if (umf_result != UMF_RESULT_SUCCESS) {
-        fprintf(stderr, "Failed to create jemalloc params!\n");
-        umfMemoryProviderDestroy(provider_fsdax);
-        return NULL;
-    }
-    umf_result = umfJemallocPoolParamsSetKeepAllMemory(pool_params, true);
-    if (umf_result != UMF_RESULT_SUCCESS) {
-        fprintf(stderr, "Failed to set KeepAllMemory!\n");
-        umfMemoryProviderDestroy(provider_fsdax);
-        return NULL;
-    }
-
-    // Create an FSDAX memory pool
-    umf_result =
-        umfPoolCreate(umfJemallocPoolOps(), provider_fsdax, pool_params,
-                      UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &pool_fsdax);
+    umf_result = umfPoolCreate(umfJemallocPoolOps(), provider_fsdax, NULL,
+                               UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &pool_fsdax);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "Failed to create an FSDAX memory pool!\n");
         umfMemoryProviderDestroy(provider_fsdax);
         return NULL;
     }
 
-    umf_result = umfJemallocPoolParamsDestroy(pool_params);
-    if (umf_result != UMF_RESULT_SUCCESS) {
-        fprintf(stderr, "Failed to destroy jemalloc params!\n");
-    }
-
     return pool_fsdax;
 }
 
@@ -124,7 +96,7 @@ int main(void) {
     // - the UMF_TESTS_FSDAX_PATH environment variable to contain
     //   a path to a file on this FSDAX device.
     char *path = getenv("UMF_TESTS_FSDAX_PATH");
-    if (path == NULL || path[0] == 0) {
+    if (path == NULL || path[0] == '\0') {
         fprintf(
             stderr,
             "Warning: UMF_TESTS_FSDAX_PATH is not set, skipping testing ...\n");
diff --git a/examples/fetch_content/CMakeLists.txt b/examples/fetch_content/CMakeLists.txt
new file mode 100644
index 0000000000..635f81622b
--- /dev/null
+++ b/examples/fetch_content/CMakeLists.txt
@@ -0,0 +1,82 @@
+# 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
+
+# This example shows and tests usage of FetchContent module. It downloads and
+# builds the UMF library defined in UMF_REPO CMake variable (or UMF from
+# upstream repo URL, by default).
+
+cmake_minimum_required(VERSION 3.14.0 FATAL_ERROR)
+project(umf_example_fetch_content LANGUAGES C)
+enable_testing()
+
+if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+    set(LINUX TRUE)
+elseif(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+    set(WINDOWS TRUE)
+elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+    set(MACOSX TRUE)
+else()
+    message(FATAL_ERROR "Unknown OS type")
+endif()
+
+set(UMF_EXAMPLE_DIR "${CMAKE_SOURCE_DIR}/..")
+list(APPEND CMAKE_MODULE_PATH "${UMF_EXAMPLE_DIR}/cmake")
+message(STATUS "CMAKE_MODULE_PATH=${CMAKE_MODULE_PATH}")
+
+include("fetch_umf.cmake")
+
+find_package(PkgConfig)
+pkg_check_modules(LIBHWLOC hwloc>=2.3.0)
+if(NOT LIBHWLOC_FOUND)
+    find_package(LIBHWLOC 2.3.0 REQUIRED hwloc)
+endif()
+
+pkg_check_modules(TBB tbb)
+if(NOT TBB_FOUND)
+    find_package(TBB REQUIRED tbb)
+endif()
+
+# build the example
+set(EXAMPLE_NAME umf_example_fetch_content)
+# reusing the basic.c source file from the basic example
+add_executable(${EXAMPLE_NAME} ${CMAKE_SOURCE_DIR}/../basic/basic.c)
+target_include_directories(${EXAMPLE_NAME} PRIVATE ${LIBUMF_INCLUDE_DIRS})
+target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS})
+target_link_libraries(${EXAMPLE_NAME} PRIVATE ${LIBUMF_LIBRARIES} hwloc)
+
+message(STATUS "LIBUMF_INCLUDE_DIRS=${LIBUMF_INCLUDE_DIRS}")
+message(STATUS "LIBUMF_LIBRARIES=${LIBUMF_LIBRARIES}")
+message(STATUS "LIBUMF_LIBRARY_DIRS=${LIBUMF_LIBRARY_DIRS}")
+message(STATUS "LIBHWLOC_LIBRARY_DIRS=${LIBHWLOC_LIBRARY_DIRS}")
+
+# an optional part - adds a test of this example
+add_test(
+    NAME ${EXAMPLE_NAME}
+    COMMAND ${EXAMPLE_NAME}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+set_tests_properties(${EXAMPLE_NAME} PROPERTIES LABELS "example-standalone")
+
+if(LINUX)
+    # set LD_LIBRARY_PATH
+    set_property(
+        TEST ${EXAMPLE_NAME}
+        PROPERTY
+            ENVIRONMENT_MODIFICATION
+            "LD_LIBRARY_PATH=path_list_append:${LIBUMF_LIBRARY_DIRS};LD_LIBRARY_PATH=path_list_append:${LIBHWLOC_LIBRARY_DIRS}"
+    )
+elseif(WINDOWS)
+    # add PATH to DLL on Windows
+    set(DLL_PATH_LIST
+        "${DLL_PATH_LIST};PATH=path_list_append:${LIBHWLOC_DLL_DIRS};PATH=path_list_append:${TBB_DLL_DIRS}"
+    )
+
+    message(STATUS "DLL_PATH_LIST=${DLL_PATH_LIST}")
+
+    # append PATH to DLLs NOTE: this would work only for the CMake ver >= #
+    # 3.22. For the older versions, the PATH variable should be set in the test
+    # script)
+    set_property(TEST ${EXAMPLE_NAME} PROPERTY ENVIRONMENT_MODIFICATION
+                                               "${DLL_PATH_LIST}")
+endif()
diff --git a/examples/fetch_content/fetch_umf.cmake b/examples/fetch_content/fetch_umf.cmake
new file mode 100644
index 0000000000..208a48d8f2
--- /dev/null
+++ b/examples/fetch_content/fetch_umf.cmake
@@ -0,0 +1,63 @@
+# 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
+
+message(STATUS "Downloading Unified Memory Framework ...")
+
+include(FetchContent)
+
+if(NOT DEFINED UMF_REPO)
+    set(UMF_REPO "https://github.com/oneapi-src/unified-memory-framework.git")
+elseif(WINDOWS)
+    string(REPLACE "\\" "/" OUT_UMF_REPO "${UMF_REPO}")
+    message(
+        STATUS
+            "Replaced \"${UMF_REPO}\" with \"${OUT_UMF_REPO}\" for Windows compatibility"
+    )
+    set(UMF_REPO "${OUT_UMF_REPO}")
+endif()
+
+if(NOT DEFINED UMF_TAG)
+    set(UMF_TAG HEAD)
+endif()
+
+message(
+    STATUS
+        "Will fetch Unified Memory Framework from ${UMF_REPO} at ${UMF_TAG} ..."
+)
+message(STATUS "CMAKE_GENERATOR: ${CMAKE_GENERATOR}")
+
+FetchContent_Declare(
+    unified-memory-framework
+    GIT_REPOSITORY ${UMF_REPO}
+    GIT_TAG ${UMF_TAG})
+
+set(UMF_BUILD_TESTS
+    OFF
+    CACHE INTERNAL "Do not build UMF tests")
+set(UMF_BUILD_EXAMPLES
+    OFF
+    CACHE INTERNAL "Do not build UMF examples")
+set(UMF_BUILD_SHARED_LIBRARY
+    OFF
+    CACHE INTERNAL "Build UMF shared library")
+set(UMF_BUILD_LIBUMF_POOL_DISJOINT
+    ON
+    CACHE INTERNAL "Build Disjoint Pool")
+set(UMF_BUILD_CUDA_PROVIDER
+    OFF
+    CACHE INTERNAL "Do not build CUDA provider")
+set(UMF_BUILD_LEVEL_ZERO_PROVIDER
+    OFF
+    CACHE INTERNAL "Do not build L0 provider")
+set(UMF_DISABLE_HWLOC
+    OFF
+    CACHE INTERNAL "Enable HWLOC support")
+set(UMF_LINK_HWLOC_STATICALLY
+    OFF
+    CACHE INTERNAL "UMF_LINK_HWLOC_STATICALLY=OFF")
+
+FetchContent_MakeAvailable(unified-memory-framework)
+
+set(LIBUMF_INCLUDE_DIRS ${unified-memory-framework_SOURCE_DIR}/include)
+set(LIBUMF_LIBRARIES umf::umf umf::headers)
diff --git a/examples/ipc_ipcapi/ipc_ipcapi_anon_fd.sh b/examples/ipc_ipcapi/ipc_ipcapi_anon_fd.sh
index 615271eebb..2eb9409daf 100755
--- a/examples/ipc_ipcapi/ipc_ipcapi_anon_fd.sh
+++ b/examples/ipc_ipcapi/ipc_ipcapi_anon_fd.sh
@@ -1,5 +1,5 @@
 #
-# 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
@@ -16,16 +16,8 @@ PORT=$(( 1024 + ( $$ % ( 65535 - 1024 ))))
 # to obtain a duplicate of another process's file descriptor.
 # Permission to duplicate another process's file descriptor
 # is governed by a ptrace access mode PTRACE_MODE_ATTACH_REALCREDS check (see ptrace(2))
-# that can be changed using the /proc/sys/kernel/yama/ptrace_scope interface.
-PTRACE_SCOPE_FILE="/proc/sys/kernel/yama/ptrace_scope"
-VAL=0
-if [ -f $PTRACE_SCOPE_FILE ]; then
-	PTRACE_SCOPE_VAL=$(cat $PTRACE_SCOPE_FILE)
-	if [ $PTRACE_SCOPE_VAL -ne $VAL ]; then
-		echo "SKIP: ptrace_scope is not set to 0 (classic ptrace permissions) - skipping the test"
-		exit 125 # skip code defined in CMakeLists.txt
-	fi
-fi
+# In the producer binary used in this example prctl(PR_SET_PTRACER, getppid()) is used
+# to allow consumer to duplicate file descriptor of producer.
 
 UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
 
diff --git a/examples/ipc_ipcapi/ipc_ipcapi_consumer.c b/examples/ipc_ipcapi/ipc_ipcapi_consumer.c
index 2f55c473f2..d2c98fbbd5 100644
--- a/examples/ipc_ipcapi/ipc_ipcapi_consumer.c
+++ b/examples/ipc_ipcapi/ipc_ipcapi_consumer.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -138,7 +138,7 @@ int main(int argc, char *argv[]) {
                                0, &scalable_pool);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr,
-                "[producer] ERROR: creating jemalloc UMF pool failed\n");
+                "[producer] ERROR: creating UMF scalable pool failed\n");
         goto err_destroy_OS_memory_provider;
     }
 
diff --git a/examples/ipc_ipcapi/ipc_ipcapi_producer.c b/examples/ipc_ipcapi/ipc_ipcapi_producer.c
index 4157e8284f..a5c7918512 100644
--- a/examples/ipc_ipcapi/ipc_ipcapi_producer.c
+++ b/examples/ipc_ipcapi/ipc_ipcapi_producer.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -9,6 +9,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/prctl.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
@@ -69,6 +70,21 @@ int main(int argc, char *argv[]) {
 
     int port = atoi(argv[1]);
 
+    // The prctl() function with PR_SET_PTRACER is used here to allow parent process and its children
+    // to ptrace the current process. This is necessary because UMF's memory providers on Linux (except CUDA)
+    // use the pidfd_getfd(2) system call to duplicate another process's file descriptor, which is
+    // governed by ptrace permissions. By default on Ubuntu /proc/sys/kernel/yama/ptrace_scope is
+    // set to 1 ("restricted ptrace"), which prevents pidfd_getfd from working unless ptrace_scope
+    // is set to 0.
+    // To overcome this limitation without requiring users to change the ptrace_scope
+    // setting (which requires root privileges), we use prctl() to allow the consumer process
+    // to copy producer's file descriptor, even when ptrace_scope is set to 1.
+    ret = prctl(PR_SET_PTRACER, getppid());
+    if (ret == -1) {
+        perror("PR_SET_PTRACER may be not supported. prctl() call failed");
+        goto err_end;
+    }
+
     umf_memory_provider_handle_t OS_memory_provider = NULL;
     umf_os_memory_provider_params_handle_t os_params = NULL;
     enum umf_result_t umf_result;
@@ -109,7 +125,7 @@ int main(int argc, char *argv[]) {
                                0, &scalable_pool);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr,
-                "[producer] ERROR: creating the UMF jemalloc pool failed\n");
+                "[producer] ERROR: creating UMF scalable pool failed\n");
         goto err_destroy_OS_memory_provider;
     }
 
@@ -259,6 +275,7 @@ int main(int argc, char *argv[]) {
 err_destroy_OS_params:
     umfOsMemoryProviderParamsDestroy(os_params);
 
+err_end:
     if (ret == 0) {
         fprintf(stderr, "[producer] Shutting down (status OK) ...\n");
     } else if (ret == 1) {
diff --git a/examples/ipc_level_zero/CMakeLists.txt b/examples/ipc_level_zero/CMakeLists.txt
index 5c17d4c9cb..726ced3f12 100644
--- a/examples/ipc_level_zero/CMakeLists.txt
+++ b/examples/ipc_level_zero/CMakeLists.txt
@@ -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,40 +21,29 @@ if(NOT LIBHWLOC_FOUND)
     find_package(LIBHWLOC 2.3.0 REQUIRED hwloc)
 endif()
 
-include(FetchContent)
-
-set(LEVEL_ZERO_LOADER_REPO "https://github.com/oneapi-src/level-zero.git")
-set(LEVEL_ZERO_LOADER_TAG v1.19.2)
-
-message(
-    STATUS
-        "Fetching L0 loader (${LEVEL_ZERO_LOADER_TAG}) from ${LEVEL_ZERO_LOADER_REPO} ..."
-)
-
-FetchContent_Declare(
-    level-zero-loader
-    GIT_REPOSITORY ${LEVEL_ZERO_LOADER_REPO}
-    GIT_TAG ${LEVEL_ZERO_LOADER_TAG}
-    EXCLUDE_FROM_ALL)
-FetchContent_MakeAvailable(level-zero-loader)
+pkg_check_modules(ZE_LOADER ze_loader)
+if(NOT ZE_LOADER_FOUND)
+    find_package(ZE_LOADER REQUIRED ze_loader)
+endif()
 
-set(LEVEL_ZERO_INCLUDE_DIRS
-    ${level-zero-loader_SOURCE_DIR}/include
-    CACHE PATH "Path to Level Zero Headers")
-message(STATUS "Level Zero include directory: ${LEVEL_ZERO_INCLUDE_DIRS}")
+set(EXAMPLE_NAME umf_example_ipc_level_zero)
+set(IPC_LEVEL_ZERO_SM_LIBRARY_DIRS
+    ${LIBUMF_LIBRARY_DIRS} ${LIBHWLOC_LIBRARY_DIRS} ${ZE_LOADER_LIBRARY_DIRS})
+set(IPC_LEVEL_ZERO_SM_INCLUDE_DIRS
+    ${LIBUMF_INCLUDE_DIRS} ${ZE_LOADER_INCLUDE_DIRS} ${UMF_EXAMPLE_DIR}/common)
 
 # build the example
-set(EXAMPLE_NAME umf_example_ipc_level_zero)
 add_executable(
     ${EXAMPLE_NAME} ipc_level_zero.c
                     ${UMF_EXAMPLE_DIR}/common/examples_level_zero_helpers.c)
-target_include_directories(${EXAMPLE_NAME} PRIVATE ${LIBUMF_INCLUDE_DIRS}
-                                                   ${UMF_EXAMPLE_DIR}/common)
-target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBUMF_LIBRARY_DIRS}
-                        ${LIBHWLOC_LIBRARY_DIRS})
+target_include_directories(${EXAMPLE_NAME}
+                           PRIVATE ${IPC_LEVEL_ZERO_SM_INCLUDE_DIRS})
+target_link_directories(${EXAMPLE_NAME} PRIVATE
+                        ${IPC_LEVEL_ZERO_SM_LIBRARY_DIRS})
 target_link_options(${EXAMPLE_NAME} PRIVATE "-Wl,--start-group")
-target_link_libraries(${EXAMPLE_NAME} PRIVATE stdc++ libdisjoint_pool.a
-                                              ze_loader ${LIBUMF_LIBRARIES})
+target_link_libraries(${EXAMPLE_NAME} PRIVATE stdc++ ze_loader
+                                              ${LIBUMF_LIBRARIES})
+target_link_options(${EXAMPLE_NAME} PRIVATE "-Wl,--end-group")
 
 # an optional part - adds a test of this example
 add_test(
@@ -65,10 +54,13 @@ add_test(
 set_tests_properties(${EXAMPLE_NAME} PROPERTIES LABELS "example-standalone")
 
 if(LINUX)
+    # set LD_LIBRARY_PATH
+    string(JOIN ":" IPC_LEVEL_ZERO_SM_LIBRARY_DIRS_JOINED
+           ${IPC_LEVEL_ZERO_SM_LIBRARY_DIRS})
     set_property(
         TEST ${EXAMPLE_NAME}
         PROPERTY
             ENVIRONMENT_MODIFICATION
-            "LD_LIBRARY_PATH=path_list_append:${LIBUMF_LIBRARY_DIRS};LD_LIBRARY_PATH=path_list_append:${LIBHWLOC_LIBRARY_DIRS}"
+            "LD_LIBRARY_PATH=path_list_prepend:${IPC_LEVEL_ZERO_SM_LIBRARY_DIRS_JOINED}"
     )
 endif()
diff --git a/examples/ipc_level_zero/ipc_level_zero.c b/examples/ipc_level_zero/ipc_level_zero.c
index 9579244abf..df0f26c45d 100644
--- a/examples/ipc_level_zero/ipc_level_zero.c
+++ b/examples/ipc_level_zero/ipc_level_zero.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -10,10 +10,10 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "umf/ipc.h"
-#include "umf/memory_pool.h"
-#include "umf/pools/pool_disjoint.h"
-#include "umf/providers/provider_level_zero.h"
+#include <umf/ipc.h>
+#include <umf/memory_pool.h>
+#include <umf/pools/pool_disjoint.h>
+#include <umf/providers/provider_level_zero.h>
 
 #include "examples_level_zero_helpers.h"
 
@@ -76,6 +76,13 @@ int create_level_zero_pool(ze_context_handle_t context,
         goto provider_destroy;
     }
 
+    // Set max poolable size to 0
+    umf_result = umfDisjointPoolParamsSetMaxPoolableSize(disjoint_params, 0);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "ERROR: Failed to set max poolable size!\n");
+        goto provider_destroy;
+    }
+
     // create pool
     umf_pool_create_flags_t flags = UMF_POOL_CREATE_FLAG_OWN_PROVIDER;
     umf_result = umfPoolCreate(umfDisjointPoolOps(), provider, disjoint_params,
@@ -104,7 +111,7 @@ int main(void) {
     const size_t BUFFER_PATTERN = 0x42;
     int ret = init_level_zero();
     if (ret != 0) {
-        fprintf(stderr, "ERROR: Failed to init Level 0!\n");
+        fprintf(stderr, "ERROR: Failed to init Level Zero!\n");
         return ret;
     }
 
diff --git a/examples/level_zero_shared_memory/CMakeLists.txt b/examples/level_zero_shared_memory/CMakeLists.txt
index 3711b40941..3fd8da5ab6 100644
--- a/examples/level_zero_shared_memory/CMakeLists.txt
+++ b/examples/level_zero_shared_memory/CMakeLists.txt
@@ -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,40 +21,28 @@ if(NOT LIBHWLOC_FOUND)
     find_package(LIBHWLOC 2.3.0 REQUIRED hwloc)
 endif()
 
-include(FetchContent)
-
-set(LEVEL_ZERO_LOADER_REPO "https://github.com/oneapi-src/level-zero.git")
-set(LEVEL_ZERO_LOADER_TAG v1.19.2)
-
-message(
-    STATUS
-        "Fetching L0 loader (${LEVEL_ZERO_LOADER_TAG}) from ${LEVEL_ZERO_LOADER_REPO} ..."
-)
-
-FetchContent_Declare(
-    level-zero-loader
-    GIT_REPOSITORY ${LEVEL_ZERO_LOADER_REPO}
-    GIT_TAG ${LEVEL_ZERO_LOADER_TAG}
-    EXCLUDE_FROM_ALL)
-FetchContent_MakeAvailable(level-zero-loader)
+pkg_check_modules(ZE_LOADER ze_loader)
+if(NOT ZE_LOADER_FOUND)
+    find_package(ZE_LOADER REQUIRED ze_loader)
+endif()
 
-set(LEVEL_ZERO_INCLUDE_DIRS
-    ${level-zero-loader_SOURCE_DIR}/include
-    CACHE PATH "Path to Level Zero Headers")
-message(STATUS "Level Zero include directory: ${LEVEL_ZERO_INCLUDE_DIRS}")
+set(EXAMPLE_NAME umf_example_level_zero_shared_memory)
+set(LEVEL_ZERO_SM_LIBRARY_DIRS ${LIBUMF_LIBRARY_DIRS} ${LIBHWLOC_LIBRARY_DIRS}
+                               ${ZE_LOADER_LIBRARY_DIRS})
 
 # build the example
-set(EXAMPLE_NAME umf_example_level_zero_shared_memory)
 add_executable(
     ${EXAMPLE_NAME} level_zero_shared_memory.c
                     ${UMF_EXAMPLE_DIR}/common/examples_level_zero_helpers.c)
-target_include_directories(${EXAMPLE_NAME} PRIVATE ${LIBUMF_INCLUDE_DIRS}
-                                                   ${UMF_EXAMPLE_DIR}/common)
-target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBUMF_LIBRARY_DIRS}
-                        ${LIBHWLOC_LIBRARY_DIRS})
+
+target_include_directories(
+    ${EXAMPLE_NAME} PRIVATE ${LIBUMF_INCLUDE_DIRS} ${ZE_LOADER_INCLUDE_DIRS}
+                            ${UMF_EXAMPLE_DIR}/common)
+target_link_directories(${EXAMPLE_NAME} PRIVATE ${LEVEL_ZERO_SM_LIBRARY_DIRS})
 target_link_options(${EXAMPLE_NAME} PRIVATE "-Wl,--start-group")
-target_link_libraries(${EXAMPLE_NAME} PRIVATE stdc++ libdisjoint_pool.a
-                                              ze_loader ${LIBUMF_LIBRARIES})
+target_link_libraries(${EXAMPLE_NAME} PRIVATE stdc++ ze_loader
+                                              ${LIBUMF_LIBRARIES})
+target_link_options(${EXAMPLE_NAME} PRIVATE "-Wl,--end-group")
 
 # an optional part - adds a test of this example
 add_test(
@@ -66,10 +54,12 @@ set_tests_properties(${EXAMPLE_NAME} PROPERTIES LABELS "example-standalone")
 
 if(LINUX)
     # set LD_LIBRARY_PATH
+    string(JOIN ":" LEVEL_ZERO_SM_LIBRARY_DIRS_JOINED
+           ${LEVEL_ZERO_SM_LIBRARY_DIRS})
     set_property(
         TEST ${EXAMPLE_NAME}
         PROPERTY
             ENVIRONMENT_MODIFICATION
-            "LD_LIBRARY_PATH=path_list_append:${LIBUMF_LIBRARY_DIRS};LD_LIBRARY_PATH=path_list_append:${LIBHWLOC_LIBRARY_DIRS}"
+            "LD_LIBRARY_PATH=path_list_append:${LEVEL_ZERO_SM_LIBRARY_DIRS_JOINED}"
     )
 endif()
diff --git a/examples/level_zero_shared_memory/level_zero_shared_memory.c b/examples/level_zero_shared_memory/level_zero_shared_memory.c
index b0f646861d..605f239f85 100644
--- a/examples/level_zero_shared_memory/level_zero_shared_memory.c
+++ b/examples/level_zero_shared_memory/level_zero_shared_memory.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -27,7 +27,7 @@ int main(void) {
     // Initialize Level Zero
     int ret = init_level_zero();
     if (ret != 0) {
-        fprintf(stderr, "Failed to init Level 0!\n");
+        fprintf(stderr, "Failed to init Level Zero!\n");
         return ret;
     }
 
@@ -157,7 +157,7 @@ int main(void) {
 
     // Allocate some memory from the pool
     int *ptr = umfPoolMalloc(ze_disjoint_memory_pool, sizeof(int));
-    if (res != UMF_RESULT_SUCCESS) {
+    if (ptr == NULL) {
         fprintf(stderr, "Failed to allocate memory from the memory pool!\n");
         ret = -1;
         goto memory_pool_destroy;
@@ -189,6 +189,6 @@ int main(void) {
     umfLevelZeroMemoryProviderParamsDestroy(ze_memory_provider_params);
 
 level_zero_destroy:
-    ret = destroy_context(hContext);
+    destroy_context(hContext);
     return ret;
 }
diff --git a/examples/memspace_hmat/memspace_hmat.c b/examples/memspace_hmat/memspace_hmat.c
index 9f3f8d17e9..c86efa4d23 100644
--- a/examples/memspace_hmat/memspace_hmat.c
+++ b/examples/memspace_hmat/memspace_hmat.c
@@ -1,14 +1,14 @@
 /*
  *
- * 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
  *
  */
 
-#include <umf/mempolicy.h>
-#include <umf/memspace.h>
+#include <umf/experimental/mempolicy.h>
+#include <umf/experimental/memspace.h>
 
 #include <numa.h>
 #include <numaif.h>
diff --git a/examples/memspace_numa/memspace_numa.c b/examples/memspace_numa/memspace_numa.c
index 4f225cd694..729e74ca28 100644
--- a/examples/memspace_numa/memspace_numa.c
+++ b/examples/memspace_numa/memspace_numa.c
@@ -1,20 +1,20 @@
 /*
  *
- * 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
  *
  */
 
-#include <umf/mempolicy.h>
-#include <umf/memspace.h>
-
 #include <numa.h>
 #include <numaif.h>
 #include <stdio.h>
 #include <string.h>
 
+#include <umf/experimental/mempolicy.h>
+#include <umf/experimental/memspace.h>
+
 #include "examples_utils.h"
 
 // Function to create a memory provider which allocates memory from the specified NUMA node
diff --git a/include/umf.h b/include/umf.h
index 3e2d827991..5fe18b8d9a 100644
--- a/include/umf.h
+++ b/include/umf.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 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
@@ -10,10 +10,9 @@
 #ifndef UMF_UNIFIED_MEMORY_FRAMEWORK_H
 #define UMF_UNIFIED_MEMORY_FRAMEWORK_H 1
 
+#include <umf/base.h>
 #include <umf/memory_pool.h>
 #include <umf/memory_provider.h>
-#include <umf/mempolicy.h>
-#include <umf/memspace.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -23,17 +22,19 @@ extern "C" {
 /// @brief  Increment the usage reference counter and initialize the global state of libumf
 ///         if the usage reference counter was equal to 0.
 ///         It must be called just after dlopen() and it is not required in other scenarios.
-/// @return 0 on success or -1 on failure.
-int umfInit(void);
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfInit(void);
 
 ///
 /// @brief Decrement the usage reference counter and destroy the global state of libumf
 ///        if the usage reference counter is equal to 0.
 ///        It must be called just before dlclose() and it is not required in other scenarios.
-void umfTearDown(void);
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfTearDown(void);
 
 ///
 /// @brief Get the current version of the UMF headers defined by UMF_VERSION_CURRENT.
+/// @return The current version of the UMF headers.
 int umfGetCurrentVersion(void);
 
 #ifdef __cplusplus
diff --git a/include/umf/base.h b/include/umf/base.h
index 53378195d2..11d7b723b4 100644
--- a/include/umf/base.h
+++ b/include/umf/base.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -28,7 +28,7 @@ extern "C" {
 #define UMF_MINOR_VERSION(_ver) (_ver & 0x0000ffff)
 
 /// @brief Current version of the UMF headers
-#define UMF_VERSION_CURRENT UMF_MAKE_VERSION(0, 10)
+#define UMF_VERSION_CURRENT UMF_MAKE_VERSION(1, 0)
 
 /// @brief Operation results
 typedef enum umf_result_t {
@@ -45,9 +45,56 @@ typedef enum umf_result_t {
     UMF_RESULT_ERROR_NOT_SUPPORTED = 5, ///< Operation not supported
     UMF_RESULT_ERROR_USER_SPECIFIC =
         6, ///< Failure in user provider code (i.e in user provided callback)
-    UMF_RESULT_ERROR_UNKNOWN = 0x7ffffffe ///< Unknown or internal error
+    UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE =
+        7, ///< External required dependency is unavailable or missing
+    UMF_RESULT_ERROR_OUT_OF_RESOURCES = 8, ///< Out of internal resources
+    UMF_RESULT_ERROR_INVALID_CTL_PATH =
+        9, ///< CTL path is not supported or not found
+    UMF_RESULT_ERROR_UNKNOWN = 0x7ffffffe ///< Unknown error
 } umf_result_t;
 
+/// @brief Handle to the memory properties structure
+typedef struct umf_memory_properties_t *umf_memory_properties_handle_t;
+
+/// @brief ID of the memory property
+typedef enum umf_memory_property_id_t {
+    UMF_MEMORY_PROPERTY_INVALID = -1, ///< Invalid property
+
+    // UMF specific
+    UMF_MEMORY_PROPERTY_PROVIDER_HANDLE = 0, ///< Handle to the memory provider
+    UMF_MEMORY_PROPERTY_POOL_HANDLE = 1,     ///< Handle to the memory pool
+
+    // generic pointer properties
+    UMF_MEMORY_PROPERTY_BASE_ADDRESS = 10, ///< Base address of the allocation
+    UMF_MEMORY_PROPERTY_BASE_SIZE = 11,    ///< Base size of the allocation
+    UMF_MEMORY_PROPERTY_BUFFER_ID = 12,    ///< Unique identifier for the buffer
+
+    // GPU specific
+    UMF_MEMORY_PROPERTY_POINTER_TYPE = 20, ///< Type of the pointer
+    UMF_MEMORY_PROPERTY_CONTEXT = 21,      ///< GPU context of the allocation
+    UMF_MEMORY_PROPERTY_DEVICE =
+        22, ///< GPU device where the allocation resides
+
+    /// @cond
+    UMF_MEMORY_PROPERTY_MAX_RESERVED = 0x1000, ///< Maximum reserved value
+    /// @endcond
+} umf_memory_property_id_t;
+
+/// @brief Type of the CTL query
+typedef enum umf_ctl_query_type {
+    CTL_QUERY_READ,
+    CTL_QUERY_WRITE,
+    CTL_QUERY_RUNNABLE,
+} umf_ctl_query_type_t;
+
+typedef enum ctl_query_source {
+    CTL_UNKNOWN_QUERY_SOURCE,
+    /* query executed directly from the program */
+    CTL_QUERY_PROGRAMMATIC,
+    /* query executed from the config file */
+    CTL_QUERY_CONFIG_INPUT
+} umf_ctl_query_source_t;
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/umf/experimental/ctl.h b/include/umf/experimental/ctl.h
new file mode 100644
index 0000000000..0f7ab860ae
--- /dev/null
+++ b/include/umf/experimental/ctl.h
@@ -0,0 +1,53 @@
+/*
+ *
+ * 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
+ *
+ */
+
+#ifndef UMF_CTL_H
+#define UMF_CTL_H 1
+
+#include <umf/base.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///
+/// @brief Get value of a specified attribute at the given path.
+/// @param path path of an attribute to be retrieved
+/// @param arg [out] pointer to the variable where the value will be stored
+/// @param size size of the value, depends on the context
+/// @param ... additional arguments that can be passed to the callback
+/// @return UMF_RESULT_SUCCESS on success or UMF_RESULT_ERROR_UNKNOWN on failure.
+///
+umf_result_t umfCtlGet(const char *path, void *arg, size_t size, ...);
+
+///
+/// @brief Set value of a specified attribute at the given path.
+/// @param path path of an attribute to be set
+/// @param arg [in] pointer to the value that will be set
+/// @param size [in] size of the value, depends on the context
+/// @param ... additional arguments that can be passed to the callback
+/// @return UMF_RESULT_SUCCESS on success or UMF_RESULT_ERROR_UNKNOWN on failure.
+///
+umf_result_t umfCtlSet(const char *path, void *arg, size_t size, ...);
+
+///
+/// @brief Execute callback related with the specified attribute.
+/// @param path path of an attribute to be executed
+/// @param arg [in/out] pointer to the value, can be used as an input or output
+/// @param size [in] size of the value, depends on the context
+/// @param ... additional arguments that can be passed to the callback
+/// @return UMF_RESULT_SUCCESS on success or UMF_RESULT_ERROR_UNKNOWN on failure.
+///
+umf_result_t umfCtlExec(const char *path, void *arg, size_t size, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_CTL_H */
diff --git a/include/umf/experimental/memory_properties.h b/include/umf/experimental/memory_properties.h
new file mode 100644
index 0000000000..fe44ef592d
--- /dev/null
+++ b/include/umf/experimental/memory_properties.h
@@ -0,0 +1,64 @@
+/*
+ *
+ * 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
+ *
+ */
+
+#ifndef UMF_MEMORY_PROPERTIES_H
+#define UMF_MEMORY_PROPERTIES_H 1
+
+#include <umf/base.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// @brief Get the memory properties handle for a given pointer
+/// \details
+///     The handle returned by this function is valid until the memory pointed
+///     to by the pointer is freed.
+/// @param ptr pointer to the allocated memory
+/// @param props_handle [out] pointer to the memory properties handle
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure
+umf_result_t
+umfGetMemoryPropertiesHandle(const void *ptr,
+                             umf_memory_properties_handle_t *props_handle);
+
+/// @brief Get the size of a specific memory property
+/// \details
+///     The size of the property should be used to allocate a buffer to hold the
+///     value of the property.
+/// @param props_handle handle to the memory properties
+/// @param memory_property_id ID of the memory property to get the size of
+/// @param size [out] pointer to the size of the property
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure
+umf_result_t
+umfGetMemoryPropertySize(umf_memory_properties_handle_t props_handle,
+                         umf_memory_property_id_t memory_property_id,
+                         size_t *size);
+
+/// @brief Get a specific memory property from the properties handle
+/// \details
+///    The type of the property value depends on the property ID. The size of
+///    the property value buffer must be large enough to hold the
+///    value of the property. The size of the property can be obtained by
+///    calling umfGetMemoryPropertySize() with the same property ID.
+/// @param props_handle handle to the memory properties
+/// @param memory_property_id ID of the memory property to get
+/// @param property_value [out] pointer to the value of the memory property
+///         which will be filled
+/// @param max_property_size size of the property value buffer
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure
+umf_result_t umfGetMemoryProperty(umf_memory_properties_handle_t props_handle,
+                                  umf_memory_property_id_t memory_property_id,
+                                  void *property_value,
+                                  size_t max_property_size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_MEMORY_PROPERTIES_H */
diff --git a/include/umf/mempolicy.h b/include/umf/experimental/mempolicy.h
similarity index 98%
rename from include/umf/mempolicy.h
rename to include/umf/experimental/mempolicy.h
index 59ca5bdd77..350baad5cc 100644
--- a/include/umf/mempolicy.h
+++ b/include/umf/experimental/mempolicy.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
diff --git a/include/umf/memspace.h b/include/umf/experimental/memspace.h
similarity index 94%
rename from include/umf/memspace.h
rename to include/umf/experimental/memspace.h
index 85b6b36815..8447c50266 100644
--- a/include/umf/memspace.h
+++ b/include/umf/experimental/memspace.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -11,10 +11,10 @@
 #define UMF_MEMSPACE_H 1
 
 #include <umf/base.h>
+#include <umf/experimental/mempolicy.h>
+#include <umf/experimental/memtarget.h>
 #include <umf/memory_pool.h>
 #include <umf/memory_provider.h>
-#include <umf/mempolicy.h>
-#include <umf/memtarget.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -46,9 +46,9 @@ umfMemoryProviderCreateFromMemspace(umf_const_memspace_handle_t hMemspace,
                                     umf_const_mempolicy_handle_t hPolicy,
                                     umf_memory_provider_handle_t *hProvider);
 ///
-/// \brief Creates new memspace from array of NUMA node ids.
+/// \brief Creates new memspace from an array of NUMA node ids.
 /// \param nodeIds array of NUMA node ids
-/// \param numIds size of the array
+/// \param numIds size of the array; it has to be greater than 0
 /// \param hMemspace [out] handle to the newly created memspace
 /// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
@@ -58,8 +58,9 @@ umf_result_t umfMemspaceCreateFromNumaArray(unsigned *nodeIds, size_t numIds,
 ///
 /// \brief Destroys memspace
 /// \param hMemspace handle to memspace
+/// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
-void umfMemspaceDestroy(umf_memspace_handle_t hMemspace);
+umf_result_t umfMemspaceDestroy(umf_memspace_handle_t hMemspace);
 
 ///
 /// \brief Retrieves predefined host all memspace.
diff --git a/include/umf/memtarget.h b/include/umf/experimental/memtarget.h
similarity index 97%
rename from include/umf/memtarget.h
rename to include/umf/experimental/memtarget.h
index d74947f14e..55ca30919a 100644
--- a/include/umf/memtarget.h
+++ b/include/umf/experimental/memtarget.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 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
diff --git a/include/umf/ipc.h b/include/umf/ipc.h
index ab47b09713..9484a827dc 100644
--- a/include/umf/ipc.h
+++ b/include/umf/ipc.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
diff --git a/include/umf/memory_pool.h b/include/umf/memory_pool.h
index a93d400f92..5662684fa7 100644
--- a/include/umf/memory_pool.h
+++ b/include/umf/memory_pool.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -10,7 +10,10 @@
 #ifndef UMF_MEMORY_POOL_H
 #define UMF_MEMORY_POOL_H 1
 
+#include <stddef.h>
+
 #include <umf/base.h>
+#include <umf/memory_pool_ops.h>
 #include <umf/memory_provider.h>
 
 #ifdef __cplusplus
@@ -22,12 +25,6 @@ extern "C" {
 ///        functions
 typedef struct umf_memory_pool_t *umf_memory_pool_handle_t;
 
-/// @brief This structure comprises function pointers used by corresponding umfPool*
-///        calls. Each memory pool implementation should initialize all function
-///        pointers.
-///
-typedef struct umf_memory_pool_ops_t umf_memory_pool_ops_t;
-
 /// @brief Supported pool creation flags
 typedef enum umf_pool_create_flag_t {
     UMF_POOL_CREATE_FLAG_NONE =
@@ -46,25 +43,25 @@ typedef enum umf_pool_create_flag_t {
 /// @brief Type for combinations of pool creation flags
 typedef uint32_t umf_pool_create_flags_t;
 
-///
 /// @brief Creates new memory pool.
 /// @param ops instance of umf_memory_pool_ops_t
 /// @param provider memory provider that will be used for coarse-grain allocations.
-/// @param params pointer to pool-specific parameters
+/// @param params pointer to pool-specific parameters, or NULL for defaults
 /// @param flags a combination of umf_pool_create_flag_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_pool_create_flags_t flags,
+                           umf_memory_provider_handle_t provider,
+                           const void *params, umf_pool_create_flags_t flags,
                            umf_memory_pool_handle_t *hPool);
 
 ///
 /// @brief Destroys memory pool.
 /// @param hPool handle to the pool
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
-void umfPoolDestroy(umf_memory_pool_handle_t hPool);
+umf_result_t umfPoolDestroy(umf_memory_pool_handle_t hPool);
 
 ///
 /// @brief Allocates \p size bytes of uninitialized storage from \p hPool
@@ -109,9 +106,11 @@ 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
+/// @param size [out] pointer to a variable that will receive the size of the memory block
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
-size_t umfPoolMallocUsableSize(umf_memory_pool_handle_t hPool, void *ptr);
+umf_result_t umfPoolMallocUsableSize(umf_memory_pool_handle_t hPool,
+                                     const void *ptr, size_t *size);
 
 ///
 /// @brief Frees the memory space of the specified \p hPool pointed by \p ptr
@@ -140,7 +139,7 @@ umf_result_t umfFree(void *ptr);
 /// * Implementations *must* store the error code in thread-local
 ///   storage prior to returning NULL from the allocation functions.
 ///
-/// * If the last allocation/de-allocation operation succeeded, the value returned by
+/// * If the last allocation/deallocation operation succeeded, the value returned by
 ///   this function is unspecified.
 ///
 /// * The application *may* call this function from simultaneous threads.
@@ -156,20 +155,64 @@ 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.
+/// @param pool [out] handle to the memory pool that contains ptr
+/// @return UMF_RESULT_SUCCESS on success
+///         UMF_RESULT_ERROR_INVALID_ARGUMENT if pool is NULL, or ptr do not belongs to any pool.
 ///
-umf_memory_pool_handle_t umfPoolByPtr(const void *ptr);
+umf_result_t umfPoolByPtr(const void *ptr, umf_memory_pool_handle_t *pool);
 
 ///
 /// @brief Retrieve memory provider associated with a given pool.
 /// @param hPool specified memory pool
-/// @param hProvider [out] memory providers handle.
+/// @param hProvider [out] memory providers handle
 /// @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);
 
+///
+/// @brief Retrieve name of a given memory \p pool.
+/// @param pool handle to the memory pool
+/// @param name [out] pointer to a string containing the name of the \p pool
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+///
+umf_result_t umfPoolGetName(umf_memory_pool_handle_t pool, const char **name);
+
+///
+/// @brief Set a custom tag on the memory pool that can be later retrieved using umfPoolGetTag.
+/// @param hPool specified memory pool
+/// @param tag tag to be set
+/// @param oldTag [out][optional] previous tag set on the memory pool
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfPoolSetTag(umf_memory_pool_handle_t hPool, void *tag,
+                           void **oldTag);
+
+///
+/// @brief Retrieve the tag associated with the memory pool or NULL if no tag is set.
+/// @param hPool specified memory pool
+/// @param tag [out] tag associated with the memory pool
+/// @return UMF_RESULT_SUCCESS on success.
+umf_result_t umfPoolGetTag(umf_memory_pool_handle_t hPool, void **tag);
+
+///
+/// @brief Trims memory of the pool, removing resources that are not needed
+///        to keep the pool operational.
+/// \details
+///        The minBytesToKeep parameter is a hint to the pool implementation
+///        that it should try to keep at least this number of bytes of
+///        memory in the pool. The pool implementation may also ignore this
+///        parameter and try to trim the whole memory, in which case it
+///        should return UMF_RESULT_SUCCESS. The pool implementation may
+///        also return UMF_RESULT_ERROR_NOT_SUPPORTED if it does not support
+///        trimming memory.
+/// @param hPool pointer to the memory pool
+/// @param minBytesToKeep minimum number of bytes to keep in the pool (if
+///        possible - see details)
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfPoolTrimMemory(umf_memory_pool_handle_t hPool,
+                               size_t minBytesToKeep);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/umf/memory_pool_ops.h b/include/umf/memory_pool_ops.h
index 67afdd1669..8a16e8fc69 100644
--- a/include/umf/memory_pool_ops.h
+++ b/include/umf/memory_pool_ops.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 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
@@ -10,6 +10,8 @@
 #ifndef UMF_MEMORY_POOL_OPS_H
 #define UMF_MEMORY_POOL_OPS_H 1
 
+#include <stdarg.h>
+
 #include <umf/base.h>
 #include <umf/memory_provider.h>
 
@@ -17,6 +19,11 @@
 extern "C" {
 #endif
 
+/// @brief Version of the Memory Pool ops structure.
+/// NOTE: This is equal to the latest UMF version, in which the ops structure
+/// has been modified.
+#define UMF_POOL_OPS_VERSION_CURRENT UMF_MAKE_VERSION(1, 1)
+
 ///
 /// @brief This structure comprises function pointers used by corresponding umfPool*
 /// calls. Each memory pool implementation should initialize all function
@@ -24,26 +31,25 @@ extern "C" {
 ///
 typedef struct umf_memory_pool_ops_t {
     /// Version of the ops structure.
-    /// Should be initialized using UMF_VERSION_CURRENT.
+    /// Should be initialized using UMF_POOL_OPS_VERSION_CURRENT.
     uint32_t version;
 
     ///
     /// @brief Initializes memory pool.
-    /// @param providers array of memory providers that will be used for coarse-grain allocations.
-    ///        Should contain at least one memory provider.
-    /// @param numProvider number of elements in the providers array
-    /// @param params pool-specific params
+    /// @param provider memory provider that will be used for coarse-grain allocations.
+    /// @param params pool-specific params, or NULL for defaults
     /// @param pool [out] returns pointer to the pool
     /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
     ///
     umf_result_t (*initialize)(umf_memory_provider_handle_t provider,
-                               void *params, void **pool);
+                               const void *params, void **pool);
 
     ///
     /// @brief Finalizes memory pool
     /// @param pool pool to finalize
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
     ///
-    void (*finalize)(void *pool);
+    umf_result_t (*finalize)(void *pool);
 
     ///
     /// @brief Allocates \p size bytes of uninitialized storage from \p pool
@@ -87,9 +93,11 @@ typedef struct umf_memory_pool_ops_t {
     /// @brief Obtains size of block of memory allocated from the \p pool for a given \p ptr
     /// @param pool pointer to the memory pool
     /// @param ptr pointer to the allocated memory
-    /// @return size of the memory block allocated from the \p pool
+    /// @param size [out] size of the memory block allocated from the \p pool
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
     ///
-    size_t (*malloc_usable_size)(void *pool, void *ptr);
+    umf_result_t (*malloc_usable_size)(void *pool, const void *ptr,
+                                       size_t *size);
 
     ///
     /// @brief Frees the memory space of the specified \p pool pointed by \p ptr
@@ -99,7 +107,7 @@ typedef struct umf_memory_pool_ops_t {
     ///         Whether any status other than UMF_RESULT_SUCCESS can be returned
     ///         depends on the memory provider used by the \p pool.
     ///
-    umf_result_t (*free)(void *pool, void *);
+    umf_result_t (*free)(void *pool, void *ptr);
 
     ///
     /// @brief Retrieve \p umf_result_t representing the error of the last failed allocation
@@ -120,6 +128,73 @@ typedef struct umf_memory_pool_ops_t {
     ///         The value is undefined if the previous allocation was successful.
     ///
     umf_result_t (*get_last_allocation_error)(void *pool);
+
+    ///
+    /// @brief Retrieves the name of the memory pool
+    /// @param pool valid pointer to the memory pool or NULL value
+    /// @param name [out] pointer to a constant character string that will be set to the pool's name
+    /// \details
+    /// * Implementations *must* return a literal null-terminated string.
+    ///
+    /// * Implementations *must* return default pool name when NULL is provided,
+    ///   otherwise the pool's name is returned.
+    ///
+    /// * The returned name should not exceed 64 characters including null character and may contain
+    ///   only [a-zA-Z0-9_-] characters. Names violating these rules are deprecated
+    ///   and will not be supported in the next major API release.
+    ///   CTL functionality may be limited if other characters are returned.
+    ///
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+    umf_result_t (*get_name)(void *pool, const char **name);
+
+    ///
+    /// The following functions are optional and memory pool implementation
+    /// can keep it NULL.
+    ///
+
+    ///
+    /// @brief Control operation for the memory pool.
+    ///        The function is used to perform various control operations
+    ///        on the memory pool.
+    ///
+    /// @param pool handle to the memory pool.
+    /// @param source source of the ctl operation.
+    /// @param name name associated with the operation.
+    /// @param arg argument for the operation.
+    /// @param size size of the argument [optional - check name requirements]
+    /// @param queryType type of the query to be performed.
+    /// @param args variable arguments for the operation.
+    ///
+    /// @return umf_result_t result of the control operation.
+    ///         Implementations must return
+    ///         UMF_RESULT_ERROR_INVALID_CTL_PATH if the given path is not
+    ///         supported.
+    ///
+    umf_result_t (*ext_ctl)(void *pool, umf_ctl_query_source_t source,
+                            const char *name, void *arg, size_t size,
+                            umf_ctl_query_type_t queryType, va_list args);
+
+    // The following operations were added in ops version 1.1
+
+    ///
+    /// @brief Trims memory of the pool, removing resources that are not needed
+    ///        to keep the pool operational.
+    /// \details
+    ///        The minBytesToKeep parameter is a hint to the pool implementation
+    ///        that it should try to keep at least this number of bytes of
+    ///        memory in the pool. The pool implementation may also ignore this
+    ///        parameter and try to trim the whole memory, in which case it
+    ///        should return UMF_RESULT_SUCCESS. The pool implementation may
+    ///        also return UMF_RESULT_ERROR_NOT_SUPPORTED if it does not support
+    ///        trimming memory.
+    /// @param pool pointer to the memory pool
+    /// @param minBytesToKeep minimum number of bytes to keep in the pool (if
+    ///        possible - see details)
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on
+    ///         failure.
+    ///
+    umf_result_t (*ext_trim_memory)(void *pool, size_t minBytesToKeep);
+
 } umf_memory_pool_ops_t;
 
 #ifdef __cplusplus
diff --git a/include/umf/memory_provider.h b/include/umf/memory_provider.h
index cff6f9eecb..b98b893468 100644
--- a/include/umf/memory_provider.h
+++ b/include/umf/memory_provider.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -24,7 +24,7 @@ typedef enum umf_memory_visibility_t {
 } umf_memory_visibility_t;
 
 /// @brief Protection of the memory allocations
-typedef enum umf_mem_protection_flags_t {
+typedef enum umf_mem_protection_flag_t {
     UMF_PROTECTION_NONE = (1 << 0),  ///< Memory allocations can not be accessed
     UMF_PROTECTION_READ = (1 << 1),  ///< Memory allocations can be read.
     UMF_PROTECTION_WRITE = (1 << 2), ///< Memory allocations can be written.
@@ -32,7 +32,7 @@ typedef enum umf_mem_protection_flags_t {
     /// @cond
     UMF_PROTECTION_MAX // must be the last one
     /// @endcond
-} umf_mem_protection_flags_t;
+} umf_mem_protection_flag_t;
 
 /// @brief A struct containing memory provider specific set of functions
 typedef struct umf_memory_provider_t *umf_memory_provider_handle_t;
@@ -45,14 +45,15 @@ typedef struct umf_memory_provider_t *umf_memory_provider_handle_t;
 /// @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,
+                                     const void *params,
                                      umf_memory_provider_handle_t *hProvider);
 
 ///
 /// @brief Destroys memory provider.
 /// @param hProvider handle to the memory provider
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
-void umfMemoryProviderDestroy(umf_memory_provider_handle_t hProvider);
+umf_result_t umfMemoryProviderDestroy(umf_memory_provider_handle_t hProvider);
 
 ///
 /// @brief Allocates \p size bytes of uninitialized storage from memory \p hProvider
@@ -99,10 +100,11 @@ umf_result_t umfMemoryProviderFree(umf_memory_provider_handle_t hProvider,
 /// @param ppMessage [out] pointer to a string containing provider specific
 ///        result in string representation
 /// @param pError [out] pointer to an integer where the adapter specific error code will be stored
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
-void umfMemoryProviderGetLastNativeError(umf_memory_provider_handle_t hProvider,
-                                         const char **ppMessage,
-                                         int32_t *pError);
+umf_result_t
+umfMemoryProviderGetLastNativeError(umf_memory_provider_handle_t hProvider,
+                                    const char **ppMessage, int32_t *pError);
 
 ///
 /// @brief Retrieve recommended page size for a given allocation size.
@@ -125,7 +127,7 @@ umfMemoryProviderGetRecommendedPageSize(umf_memory_provider_handle_t hProvider,
 ///
 umf_result_t
 umfMemoryProviderGetMinPageSize(umf_memory_provider_handle_t hProvider,
-                                void *ptr, size_t *pageSize);
+                                const void *ptr, size_t *pageSize);
 
 ///
 /// @brief Discard physical pages within the virtual memory mapping associated at the given addr
@@ -216,21 +218,24 @@ umfMemoryProviderCloseIPCHandle(umf_memory_provider_handle_t hProvider,
 ///
 /// @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);
+/// @param name [out] pointer to the provider name string
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure
+umf_result_t umfMemoryProviderGetName(umf_memory_provider_handle_t hProvider,
+                                      const char **name);
 
 ///
 /// @brief Retrieve handle to the last memory provider that returned status other
 ///        than UMF_RESULT_SUCCESS on the calling thread.
+/// @param provider [out] pointer to the handle to the last failed memory provider
 ///
 /// \details Handle to the memory provider is stored in  the thread local
 ///          storage. The handle is updated every time a memory provider
 ///          returns status other than UMF_RESULT_SUCCESS.
 ///
-/// @return Handle to the memory provider
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
-umf_memory_provider_handle_t umfGetLastFailedMemoryProvider(void);
+umf_result_t
+umfGetLastFailedMemoryProvider(umf_memory_provider_handle_t *provider);
 
 ///
 /// @brief Splits a coarse grain allocation into 2 adjacent allocations that
diff --git a/include/umf/memory_provider_ops.h b/include/umf/memory_provider_ops.h
index 0b9c7cfce3..80fb28860d 100644
--- a/include/umf/memory_provider_ops.h
+++ b/include/umf/memory_provider_ops.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -10,18 +10,56 @@
 #ifndef UMF_MEMORY_PROVIDER_OPS_H
 #define UMF_MEMORY_PROVIDER_OPS_H 1
 
+#include <stdarg.h>
+
 #include <umf/base.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+/// @brief Version of the Memory Provider ops structure.
+/// NOTE: This is equal to the latest UMF version, in which the ops structure
+/// has been modified.
+#define UMF_PROVIDER_OPS_VERSION_CURRENT UMF_MAKE_VERSION(1, 1)
+
 ///
-/// @brief This structure comprises optional function pointers used
-/// by corresponding umfMemoryProvider* calls. A memory provider implementation
-/// can keep them NULL.
+/// @brief This structure comprises function pointers used by corresponding
+/// umfMemoryProvider* calls. Each memory provider implementation should
+/// initialize all function pointers.
 ///
-typedef struct umf_memory_provider_ext_ops_t {
+typedef struct umf_memory_provider_ops_t {
+    /// Version of the ops structure.
+    /// Should be initialized using UMF_PROVIDER_OPS_VERSION_CURRENT.
+    uint32_t version;
+
+    ///
+    /// @brief Initializes memory provider.
+    /// @param params provider-specific params
+    /// @param provider returns pointer to the provider
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+    ///
+    umf_result_t (*initialize)(const void *params, void **provider);
+
+    ///
+    /// @brief Finalizes memory provider.
+    /// @param provider provider to finalize
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+    ///
+    umf_result_t (*finalize)(void *provider);
+
+    ///
+    /// @brief Allocates \p size bytes of uninitialized storage from memory \p provider
+    ///        with the specified \p alignment
+    /// @param provider pointer to the memory provider
+    /// @param size number of bytes to allocate
+    /// @param alignment alignment of the allocation in bytes, it has to be a multiple or a divider of the minimum page size
+    /// @param ptr [out] pointer to the allocated memory
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure
+    ///
+    umf_result_t (*alloc)(void *provider, size_t size, size_t alignment,
+                          void **ptr);
+
     ///
     /// @brief Frees the memory space pointed by \p ptr from the memory \p provider
     /// @param provider pointer to the memory provider
@@ -31,6 +69,79 @@ typedef struct umf_memory_provider_ext_ops_t {
     ///
     umf_result_t (*free)(void *provider, void *ptr, size_t size);
 
+    ///
+    /// @brief Retrieve string representation of the underlying provider specific
+    ///        result reported by the last API that returned
+    ///        UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC. Allows for a provider
+    ///        independent way to return a provider specific result.
+    ///
+    /// \details
+    /// * Implementations *must* store the message and error code in thread-local
+    ///   storage prior to returning UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC.
+    ///
+    /// * The message and error code will only be valid if a previously
+    ///   called entry-point returned UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC.
+    ///
+    /// * The memory pointed to by the C string returned in \p ppMessage is owned by
+    ///   the adapter and *must* be null terminated.
+    ///
+    /// * The application *may* call this function from simultaneous threads.
+    ///
+    /// * The implementation of this function *should* be lock-free.
+    /// @param provider pointer to the memory provider
+    /// @param ppMessage [out] pointer to a string containing provider specific
+    ///        result in string representation
+    /// @param pError [out] pointer to an integer where the adapter specific error code will be stored
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+    ///
+    umf_result_t (*get_last_native_error)(void *provider,
+                                          const char **ppMessage,
+                                          int32_t *pError);
+
+    ///
+    /// @brief Retrieve recommended page size for a given allocation size.
+    /// @param provider pointer to the memory provider
+    /// @param size allocation size
+    /// @param pageSize [out] pointer to the recommended page size
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+    ///
+    umf_result_t (*get_recommended_page_size)(void *provider, size_t size,
+                                              size_t *pageSize);
+
+    ///
+    /// @brief Retrieve minimum possible page size used by memory region referenced by a given \p ptr
+    ///        or minimum possible page size that can be used by the \p provider if \p ptr is NULL.
+    /// @param provider pointer to the memory provider
+    /// @param ptr [optional] pointer to memory allocated by the memory \p provider
+    /// @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 (*get_min_page_size)(void *provider, const void *ptr,
+                                      size_t *pageSize);
+
+    ///
+    /// @brief Retrieve name of a given memory \p provider.
+    /// @param provider pointer to the memory provider
+    /// @param name [out] pointer to a string containing the name of the \p provider
+    /// \details
+    /// * Implementations *must* return a literal null-terminated string.
+    ///
+    /// * Implementations *must* return default provider name when NULL is provided,
+    ///   otherwise the pool's name is returned.
+    ///
+    /// * The returned name should not exceed 64 characters and may contain
+    ///   only [a-zA-Z0-9_-] characters. Names violating these rules are deprecated
+    ///   and will not be supported in the next major API release.
+    ///   CTL functionality may be limited if other characters are returned.
+    ///
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+    umf_result_t (*get_name)(void *provider, const char **name);
+
+    ///
+    /// Following functions, with ext prefix, are optional and memory provider implementation
+    /// can keep them NULL.
+    ///
+
     ///
     /// @brief Discard physical pages within the virtual memory mapping associated at the given addr
     ///        and \p size. This call is asynchronous and may delay purging the pages indefinitely.
@@ -41,7 +152,7 @@ typedef struct umf_memory_provider_ext_ops_t {
     ///         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 (*purge_lazy)(void *provider, void *ptr, size_t size);
+    umf_result_t (*ext_purge_lazy)(void *provider, void *ptr, size_t size);
 
     ///
     /// @brief Discard physical pages within the virtual memory mapping associated at the given addr and \p size.
@@ -53,7 +164,7 @@ typedef struct umf_memory_provider_ext_ops_t {
     ///         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 (*purge_force)(void *provider, void *ptr, size_t size);
+    umf_result_t (*ext_purge_force)(void *provider, void *ptr, size_t size);
 
     ///
     /// @brief Merges two coarse grain allocations into a single allocation that
@@ -68,8 +179,8 @@ typedef struct umf_memory_provider_ext_ops_t {
     ///        to the sum of sizes of allocations beginning at lowPtr and highPtr
     /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure
     ///
-    umf_result_t (*allocation_merge)(void *hProvider, void *lowPtr,
-                                     void *highPtr, size_t totalSize);
+    umf_result_t (*ext_allocation_merge)(void *hProvider, void *lowPtr,
+                                         void *highPtr, size_t totalSize);
 
     ///
     /// @brief Splits a coarse grain allocation into 2 adjacent allocations that
@@ -84,26 +195,25 @@ typedef struct umf_memory_provider_ext_ops_t {
     //         has a size equal to totalSize - firstSize
     /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure
     ///
-    umf_result_t (*allocation_split)(void *hProvider, void *ptr,
-                                     size_t totalSize, size_t firstSize);
-
-} umf_memory_provider_ext_ops_t;
-
-///
-/// @brief This structure comprises optional IPC API. The API allows sharing of
-/// memory objects across different processes. A memory provider implementation can keep them NULL.
-///
-typedef struct umf_memory_provider_ipc_ops_t {
-    ///
+    umf_result_t (*ext_allocation_split)(void *hProvider, void *ptr,
+                                         size_t totalSize, size_t firstSize);
     /// @brief Retrieve the size of opaque data structure required to store IPC data.
+    /// \details
+    /// * If provider supports IPC, all following functions pointers:
+    ///   ext_get_ipc_handle_size, ext_get_ipc_handle, ext_put_ipc_handle, ext_open_ipc_handle, ext_close_ipc_handle,
+    ///   must either be all set or all NULL.
     /// @param provider pointer to the memory provider.
     /// @param size [out] pointer to the size.
     /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
     ///         UMF_RESULT_ERROR_NOT_SUPPORTED if IPC functionality is not supported by this provider.
-    umf_result_t (*get_ipc_handle_size)(void *provider, size_t *size);
+    umf_result_t (*ext_get_ipc_handle_size)(void *provider, size_t *size);
 
     ///
     /// @brief Retrieve an IPC memory handle for the specified allocation.
+    /// \details
+    /// * If provider supports IPC, all following functions pointers:
+    ///   ext_get_ipc_handle_size, ext_get_ipc_handle, ext_put_ipc_handle, ext_open_ipc_handle, ext_close_ipc_handle,
+    ///   must either be all set or all NULL.
     /// @param provider pointer to the memory provider.
     /// @param ptr beginning of the virtual memory range.
     /// @param size size of the memory address range.
@@ -111,140 +221,111 @@ typedef struct umf_memory_provider_ipc_ops_t {
     /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
     ///         UMF_RESULT_ERROR_INVALID_ARGUMENT if ptr was not allocated by this provider.
     ///         UMF_RESULT_ERROR_NOT_SUPPORTED if IPC functionality is not supported by this provider.
-    umf_result_t (*get_ipc_handle)(void *provider, const void *ptr, size_t size,
-                                   void *providerIpcData);
+    umf_result_t (*ext_get_ipc_handle)(void *provider, const void *ptr,
+                                       size_t size, void *providerIpcData);
 
     ///
     /// @brief Release IPC handle retrieved with get_ipc_handle function.
+    /// \details
+    /// * If provider supports IPC, all following functions pointers:
+    ///   ext_get_ipc_handle_size, ext_get_ipc_handle, ext_put_ipc_handle, ext_open_ipc_handle, ext_close_ipc_handle,
+    ///   must either be all set or all NULL.
     /// @param provider pointer to the memory provider.
     /// @param providerIpcData pointer to the IPC opaque data structure.
     /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
     ///         UMF_RESULT_ERROR_INVALID_ARGUMENT if providerIpcData was not created by this provider.
     ///         UMF_RESULT_ERROR_NOT_SUPPORTED if IPC functionality is not supported by this provider.
-    umf_result_t (*put_ipc_handle)(void *provider, void *providerIpcData);
+    umf_result_t (*ext_put_ipc_handle)(void *provider, void *providerIpcData);
 
     ///
     /// @brief Open IPC handle.
+    /// \details
+    /// * If provider supports IPC, all following functions pointers:
+    ///   ext_get_ipc_handle_size, ext_get_ipc_handle, ext_put_ipc_handle, ext_open_ipc_handle, ext_close_ipc_handle,
+    ///   must either be all set or all NULL.
     /// @param provider pointer to the memory provider.
     /// @param providerIpcData pointer to the IPC opaque data structure.
     /// @param ptr [out] pointer to the memory to be used in the current process.
     /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
     ///         UMF_RESULT_ERROR_INVALID_ARGUMENT if providerIpcData cannot be handled by the provider.
     ///         UMF_RESULT_ERROR_NOT_SUPPORTED if IPC functionality is not supported by this provider.
-    umf_result_t (*open_ipc_handle)(void *provider, void *providerIpcData,
-                                    void **ptr);
-
+    umf_result_t (*ext_open_ipc_handle)(void *provider, void *providerIpcData,
+                                        void **ptr);
     ///
     /// @brief Closes an IPC memory handle.
+    /// \details
+    /// * If provider supports IPC, all following functions pointers:
+    ///   ext_get_ipc_handle_size, ext_get_ipc_handle, ext_put_ipc_handle, ext_open_ipc_handle, ext_close_ipc_handle,
+    ///   must either be all set or all NULL.
     /// @param provider pointer to the memory provider.
     /// @param ptr pointer to the memory retrieved with open_ipc_handle function.
     /// @param size size of the memory address range.
     /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
     ///         UMF_RESULT_ERROR_INVALID_ARGUMENT if invalid \p ptr is passed.
     ///         UMF_RESULT_ERROR_NOT_SUPPORTED if IPC functionality is not supported by this provider.
-    umf_result_t (*close_ipc_handle)(void *provider, void *ptr, size_t size);
-} umf_memory_provider_ipc_ops_t;
-
-///
-/// @brief This structure comprises function pointers used by corresponding
-/// umfMemoryProvider* calls. Each memory provider implementation should
-/// initialize all function pointers.
-///
-typedef struct umf_memory_provider_ops_t {
-    /// Version of the ops structure.
-    /// Should be initialized using UMF_VERSION_CURRENT.
-    uint32_t version;
+    umf_result_t (*ext_close_ipc_handle)(void *provider, void *ptr,
+                                         size_t size);
 
     ///
-    /// @brief Initializes memory provider.
-    /// @param params provider-specific params
-    /// @param provider returns pointer to the provider
-    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
-    ///
-    umf_result_t (*initialize)(void *params, void **provider);
+    /// @brief Control operation for the memory provider.
+    ///        The function is used to perform various control operations
+    ///        on the memory provider.
+    /// \details
+    /// * This API is experimental and may change in future releases.
+    ///   Backward compatibility is not guaranteed.
+    ///
+    /// @param provider handle to the memory provider.
+    /// @param source source of the ctl operation.
+    /// @param name name associated with the operation.
+    /// @param arg argument for the operation.
+    /// @param size size of the argument [optional - check name requirements]
+    /// @param queryType type of the query to be performed.
+    /// @param args variable arguments for the operation.
+    ///
+    /// @return umf_result_t result of the control operation.
+    ///         Implementations must return
+    ///         UMF_RESULT_ERROR_INVALID_CTL_PATH if the given path is not
+    ///         supported.
+    ///
+    umf_result_t (*ext_ctl)(void *provider, umf_ctl_query_source_t source,
+                            const char *name, void *arg, size_t size,
+                            umf_ctl_query_type_t queryType, va_list args);
 
-    ///
-    /// @brief Finalizes memory provider.
-    /// @param provider provider to finalize
-    ///
-    void (*finalize)(void *provider);
+    // The following operations were added in ops version 1.1
 
     ///
-    /// @brief Allocates \p size bytes of uninitialized storage from memory \p provider
-    ///        with the specified \p alignment
+    /// @brief Retrieve provider-specific properties of the memory allocation.
+    /// \details
+    ///     If provider supports allocation properties,
+    ///     ext_get_allocation_properties and ext_get_allocation_properties_size,
+    ///     must either be all set or all NULL.
     /// @param provider pointer to the memory provider
-    /// @param size number of bytes to allocate
-    /// @param alignment alignment of the allocation in bytes, it has to be a multiple or a divider of the minimum page size
-    /// @param ptr [out] pointer to the allocated memory
+    /// @param ptr pointer to the allocated memory
+    /// @param memory_property_id ID of the memory property
+    /// @param property_value [out] pointer to the value of the memory property
+    ///         which will be filled
     /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure
     ///
-    umf_result_t (*alloc)(void *provider, size_t size, size_t alignment,
-                          void **ptr);
+    umf_result_t (*ext_get_allocation_properties)(
+        void *provider, const void *ptr,
+        umf_memory_property_id_t memory_property_id, void *property_value);
 
     ///
-    /// @brief Retrieve string representation of the underlying provider specific
-    ///        result reported by the last API that returned
-    ///        UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC. Allows for a provider
-    ///        independent way to return a provider specific result.
-    ///
+    /// @brief Retrieve size of the provider-specific properties of the memory
+    ///        allocation.
     /// \details
-    /// * Implementations *must* store the message and error code in thread-local
-    ///   storage prior to returning UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC.
-    ///
-    /// * The message and error code will only be valid if a previously
-    ///   called entry-point returned UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC.
-    ///
-    /// * The memory pointed to by the C string returned in \p ppMessage is owned by
-    ///   the adapter and *must* be null terminated.
-    ///
-    /// * The application *may* call this function from simultaneous threads.
-    ///
-    /// * The implementation of this function *should* be lock-free.
+    ///     If provider supports allocation properties,
+    ///     ext_get_allocation_properties and ext_get_allocation_properties_size,
+    ///     must either be all set or all NULL.
     /// @param provider pointer to the memory provider
-    /// @param ppMessage [out] pointer to a string containing provider specific
-    ///        result in string representation
-    /// @param pError [out] pointer to an integer where the adapter specific error code will be stored
-    ///
-    void (*get_last_native_error)(void *provider, const char **ppMessage,
-                                  int32_t *pError);
-
-    ///
-    /// @brief Retrieve recommended page size for a given allocation size.
-    /// @param provider pointer to the memory provider
-    /// @param size allocation size
-    /// @param pageSize [out] pointer to the recommended page size
-    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
-    ///
-    umf_result_t (*get_recommended_page_size)(void *provider, size_t size,
-                                              size_t *pageSize);
-
-    ///
-    /// @brief Retrieve minimum possible page size used by memory region referenced by a given \p ptr
-    ///        or minimum possible page size that can be used by the \p provider if \p ptr is NULL.
-    /// @param provider pointer to the memory provider
-    /// @param ptr [optional] pointer to memory allocated by the memory \p provider
-    /// @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 (*get_min_page_size)(void *provider, void *ptr,
-                                      size_t *pageSize);
-
-    ///
-    /// @brief Retrieve name of a given memory \p provider.
-    /// @param provider pointer to the memory provider
-    /// @return pointer to a string containing the name of the \p provider
-    ///
-    const char *(*get_name)(void *provider);
-
-    ///
-    /// @brief Optional ops
+    /// @param memory_property_id ID of the memory property to get the size of
+    /// @param size [out] pointer to the size of the property
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure
     ///
-    umf_memory_provider_ext_ops_t ext;
+    umf_result_t (*ext_get_allocation_properties_size)(
+        void *provider, umf_memory_property_id_t memory_property_id,
+        size_t *size);
 
-    ///
-    /// @brief Optional IPC ops. The API allows sharing of memory objects across different processes.
-    ///
-    umf_memory_provider_ipc_ops_t ipc;
 } umf_memory_provider_ops_t;
 
 #ifdef __cplusplus
diff --git a/include/umf/pools/pool_disjoint.h b/include/umf/pools/pool_disjoint.h
index fdf682ae5b..1758fee894 100644
--- a/include/umf/pools/pool_disjoint.h
+++ b/include/umf/pools/pool_disjoint.h
@@ -1,8 +1,15 @@
-// Copyright (C) 2023-2024 Intel Corporation
-// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+/*
+ *
+ * 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
+ *
+ */
+
+#ifndef UMF_DISJOINT_MEMORY_POOL_H
+#define UMF_DISJOINT_MEMORY_POOL_H 1
 
-#pragma once
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -24,13 +31,15 @@ typedef struct umf_disjoint_pool_params_t *umf_disjoint_pool_params_handle_t;
 
 /// @brief Create a pool limits struct.
 /// @param MaxSize specifies hard limit for memory allocated from a provider.
-/// @return handle to the created shared limits struct.
-umf_disjoint_pool_shared_limits_handle_t
-umfDisjointPoolSharedLimitsCreate(size_t MaxSize);
+/// @param hSharedLimits [out] handle to the newly created shared limits struct.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfDisjointPoolSharedLimitsCreate(
+    size_t MaxSize, umf_disjoint_pool_shared_limits_handle_t *hSharedLimits);
 
 /// @brief Destroy previously created pool limits struct.
 /// @param hSharedLimits handle to the shared limits struct.
-void umfDisjointPoolSharedLimitsDestroy(
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfDisjointPoolSharedLimitsDestroy(
     umf_disjoint_pool_shared_limits_handle_t hSharedLimits);
 
 /// @brief  Create a struct to store parameters of disjoint pool.
@@ -46,6 +55,7 @@ umf_result_t
 umfDisjointPoolParamsDestroy(umf_disjoint_pool_params_handle_t hParams);
 
 /// @brief Set minimum allocation size that will be requested from the memory provider.
+/// @details Default value for minimum size of slab's is 64KB.
 /// @param hParams handle to the parameters of the disjoint pool.
 /// @param slabMinSize minimum allocation size.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
@@ -54,6 +64,7 @@ umfDisjointPoolParamsSetSlabMinSize(umf_disjoint_pool_params_handle_t hParams,
                                     size_t slabMinSize);
 
 /// @brief Set size limit for allocations that are subject to pooling.
+/// @details Default value for maximum poolable size is 2MB.
 /// @param hParams handle to the parameters of the disjoint pool.
 /// @param maxPoolableSize maximum poolable size.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
@@ -62,6 +73,7 @@ umf_result_t umfDisjointPoolParamsSetMaxPoolableSize(
 
 /// @brief Set maximum capacity of each bucket. Each bucket will hold a
 ///        max of \p maxCapacity unfreed slabs.
+/// @details Default value for capacity is 4.
 /// @param hParams handle to the parameters of the disjoint pool.
 /// @param maxCapacity maximum capacity of each bucket.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
@@ -70,6 +82,7 @@ umfDisjointPoolParamsSetCapacity(umf_disjoint_pool_params_handle_t hParams,
                                  size_t maxCapacity);
 
 /// @brief Set minimum bucket allocation size.
+/// @details Default value for minimum bucket size is 8.
 /// @param hParams handle to the parameters of the disjoint pool.
 /// @param minBucketSize minimum bucket size. Must be power of 2.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
@@ -78,6 +91,7 @@ umfDisjointPoolParamsSetMinBucketSize(umf_disjoint_pool_params_handle_t hParams,
                                       size_t minBucketSize);
 
 /// @brief Set trace level for pool usage statistics.
+/// @details Default value for pool trace is 0 (no traces).
 /// @param hParams handle to the parameters of the disjoint pool.
 /// @param poolTrace trace level.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
@@ -87,7 +101,7 @@ umfDisjointPoolParamsSetTrace(umf_disjoint_pool_params_handle_t hParams,
 
 /// @brief Set shared limits for disjoint pool.
 /// @param hParams handle to the parameters of the disjoint pool.
-/// @param hSharedLimits handle tp the shared limits.
+/// @param hSharedLimits handle to the shared limits.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t umfDisjointPoolParamsSetSharedLimits(
     umf_disjoint_pool_params_handle_t hParams,
@@ -95,14 +109,19 @@ umf_result_t umfDisjointPoolParamsSetSharedLimits(
 
 /// @brief Set custom name of the disjoint pool to be used in the traces.
 /// @param hParams handle to the parameters of the disjoint pool.
-/// @param name custom name of the pool.
+/// @param name custom name of the pool. Must not be NULL. Name longer than 63
+///        characters will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t
 umfDisjointPoolParamsSetName(umf_disjoint_pool_params_handle_t hParams,
                              const char *name);
 
-umf_memory_pool_ops_t *umfDisjointPoolOps(void);
+const umf_memory_pool_ops_t *umfDisjointPoolOps(void);
 
 #ifdef __cplusplus
 }
 #endif
+
+#endif /* UMF_DISJOINT_MEMORY_POOL_H */
diff --git a/include/umf/pools/pool_jemalloc.h b/include/umf/pools/pool_jemalloc.h
index 0cbecd38f7..f7c881b6cb 100644
--- a/include/umf/pools/pool_jemalloc.h
+++ b/include/umf/pools/pool_jemalloc.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 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
@@ -14,36 +14,47 @@
 extern "C" {
 #endif
 
-#include <stdbool.h>
 #include <umf/memory_pool_ops.h>
 
 struct umf_jemalloc_pool_params_t;
 
-/// @brief handle to the parameters of the jemalloc pool.
+/// @brief handle to the optional parameters of the jemalloc pool.
 typedef struct umf_jemalloc_pool_params_t *umf_jemalloc_pool_params_handle_t;
 
-/// @brief  Create a struct to store parameters of jemalloc pool.
-/// @param  hParams [out] handle to the newly created parameters struct.
+/// @brief Create an optional struct to store parameters of jemalloc pool.
+/// @param hParams [out] handle to the newly created parameters struct.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t
 umfJemallocPoolParamsCreate(umf_jemalloc_pool_params_handle_t *hParams);
 
-/// @brief  Destroy parameters struct.
-/// @param  hParams handle to the parameters of the jemalloc pool.
+/// @brief Destroy parameters struct.
+/// @param hParams handle to the parameters of the jemalloc pool.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t
 umfJemallocPoolParamsDestroy(umf_jemalloc_pool_params_handle_t hParams);
 
-/// @brief  Set if \p umfMemoryProviderFree() should never be called.
-/// @param  hParams handle to the parameters of the jemalloc pool.
-/// @param  keepAllMemory \p true if the jemalloc pool should not call
-/// \p umfMemoryProviderFree, \p false otherwise.
+/// @brief Customize number of arenas created for this pool. Default is the number of CPU cores * 4.
+/// \details
+/// The number of arenas is limited by jemalloc; setting this value too high may reduce the number of pools available for creation.
+/// @param hParams handle to the parameters of the jemalloc pool.
+/// @param numArenas number of arenas.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t
-umfJemallocPoolParamsSetKeepAllMemory(umf_jemalloc_pool_params_handle_t hParams,
-                                      bool keepAllMemory);
+umfJemallocPoolParamsSetNumArenas(umf_jemalloc_pool_params_handle_t hParams,
+                                  size_t numArenas);
+
+/// @brief Set custom name of the jemalloc pool used in traces.
+/// @param hParams handle to the parameters of the jemalloc pool.
+/// @param name custom name. Must not be NULL. Name longer than 63 characters
+///        will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfJemallocPoolParamsSetName(umf_jemalloc_pool_params_handle_t hParams,
+                             const char *name);
 
-umf_memory_pool_ops_t *umfJemallocPoolOps(void);
+const umf_memory_pool_ops_t *umfJemallocPoolOps(void);
 
 #ifdef __cplusplus
 }
diff --git a/include/umf/pools/pool_proxy.h b/include/umf/pools/pool_proxy.h
index c13cb3b228..df405e8d98 100644
--- a/include/umf/pools/pool_proxy.h
+++ b/include/umf/pools/pool_proxy.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -18,7 +18,7 @@
 extern "C" {
 #endif
 
-umf_memory_pool_ops_t *umfProxyPoolOps(void);
+const umf_memory_pool_ops_t *umfProxyPoolOps(void);
 
 #ifdef __cplusplus
 }
diff --git a/include/umf/pools/pool_scalable.h b/include/umf/pools/pool_scalable.h
index 072169b68c..749cd8a398 100644
--- a/include/umf/pools/pool_scalable.h
+++ b/include/umf/pools/pool_scalable.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 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
@@ -53,9 +53,20 @@ umf_result_t
 umfScalablePoolParamsSetKeepAllMemory(umf_scalable_pool_params_handle_t hParams,
                                       bool keepAllMemory);
 
+/// @brief  Set custom name of the scalable pool used in traces.
+/// @param  hParams handle to the parameters of the scalable pool.
+/// @param  name custom name. Must not be NULL. Name longer than 63 characters
+///         will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfScalablePoolParamsSetName(umf_scalable_pool_params_handle_t hParams,
+                             const char *name);
+
 /// @brief  Return \p ops structure containing pointers to the scalable pool implementation.
 /// @return pointer to the \p umf_memory_pool_ops_t struct.
-umf_memory_pool_ops_t *umfScalablePoolOps(void);
+const umf_memory_pool_ops_t *umfScalablePoolOps(void);
 
 #ifdef __cplusplus
 }
diff --git a/include/umf/providers/provider_coarse.h b/include/umf/providers/provider_coarse.h
deleted file mode 100644
index 6ed6e0fbc9..0000000000
--- a/include/umf/providers/provider_coarse.h
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * Copyright (C) 2023-2024 Intel Corporation
- *
- * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-*/
-
-#ifndef UMF_COARSE_PROVIDER_H
-#define UMF_COARSE_PROVIDER_H
-
-#include <stdbool.h>
-#include <string.h>
-
-#include <umf/memory_provider.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/// @brief Coarse Memory Provider allocation strategy
-typedef enum coarse_memory_provider_strategy_t {
-    /// Always allocate a free block of the (size + alignment) size
-    /// and cut out the properly aligned part leaving two remaining parts.
-    /// It is the fastest strategy but causes memory fragmentation
-    /// when alignment is greater than 0.
-    /// It is the best strategy when alignment always equals 0.
-    UMF_COARSE_MEMORY_STRATEGY_FASTEST = 0,
-
-    /// Check if the first free block of the 'size' size has the correct alignment.
-    /// If not, use the `UMF_COARSE_MEMORY_STRATEGY_FASTEST` strategy.
-    UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE,
-
-    /// Look through all free blocks of the 'size' size
-    /// and choose the first one with the correct alignment.
-    /// If none of them had the correct alignment,
-    /// use the `UMF_COARSE_MEMORY_STRATEGY_FASTEST` strategy.
-    UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE,
-
-    /// The maximum value (it has to be the last one).
-    UMF_COARSE_MEMORY_STRATEGY_MAX
-} coarse_memory_provider_strategy_t;
-
-/// @brief Coarse Memory Provider settings struct.
-typedef struct coarse_memory_provider_params_t {
-    /// Handle to the upstream memory provider.
-    /// It has to be NULL if init_buffer is set
-    /// (exactly one of them has to be non-NULL).
-    umf_memory_provider_handle_t upstream_memory_provider;
-
-    /// Memory allocation strategy.
-    /// See coarse_memory_provider_strategy_t for details.
-    coarse_memory_provider_strategy_t allocation_strategy;
-
-    /// A pre-allocated buffer that will be the only memory that
-    /// the coarse provider can provide (the fixed-size memory provider option).
-    /// If it is non-NULL, `init_buffer_size ` has to contain its size.
-    /// It has to be NULL if upstream_memory_provider is set
-    /// (exactly one of them has to be non-NULL).
-    void *init_buffer;
-
-    /// Size of the initial buffer:
-    /// 1) `init_buffer` if it is non-NULL xor
-    /// 2) that will be allocated from the upstream_memory_provider
-    ///    (if it is non-NULL) in the `.initialize` operation.
-    size_t init_buffer_size;
-
-    /// When it is true and the upstream_memory_provider is given,
-    /// the init buffer (of `init_buffer_size` bytes) would be pre-allocated
-    /// during creation time using the `upstream_memory_provider`.
-    /// If upstream_memory_provider is not given,
-    /// the init_buffer is always used instead
-    /// (regardless of the value of this parameter).
-    bool immediate_init_from_upstream;
-
-    /// Destroy upstream_memory_provider in finalize().
-    bool destroy_upstream_memory_provider;
-} coarse_memory_provider_params_t;
-
-/// @brief Coarse Memory Provider stats (TODO move to CTL)
-typedef struct coarse_memory_provider_stats_t {
-    /// Total allocation size.
-    size_t alloc_size;
-
-    /// Size of used memory.
-    size_t used_size;
-
-    /// Number of memory blocks allocated from the upstream provider.
-    size_t num_upstream_blocks;
-
-    /// Total number of allocated memory blocks.
-    size_t num_all_blocks;
-
-    /// Number of free memory blocks.
-    size_t num_free_blocks;
-} coarse_memory_provider_stats_t;
-
-umf_memory_provider_ops_t *umfCoarseMemoryProviderOps(void);
-
-// TODO use CTL
-coarse_memory_provider_stats_t
-umfCoarseMemoryProviderGetStats(umf_memory_provider_handle_t provider);
-
-/// @brief Create default params for the coarse memory provider
-static inline coarse_memory_provider_params_t
-umfCoarseMemoryProviderParamsDefault(void) {
-    coarse_memory_provider_params_t coarse_memory_provider_params;
-    memset(&coarse_memory_provider_params, 0,
-           sizeof(coarse_memory_provider_params));
-    return coarse_memory_provider_params;
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // UMF_COARSE_PROVIDER_H
diff --git a/include/umf/providers/provider_cuda.h b/include/umf/providers/provider_cuda.h
index 5f1d5a6e2a..dbed42219d 100644
--- a/include/umf/providers/provider_cuda.h
+++ b/include/umf/providers/provider_cuda.h
@@ -1,12 +1,12 @@
 /*
- * 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
 */
 
-#ifndef UMF_PROVIDER_CUDA_H
-#define UMF_PROVIDER_CUDA_H
+#ifndef UMF_CUDA_PROVIDER_H
+#define UMF_CUDA_PROVIDER_H
 
 #include <umf/memory_provider_gpu.h>
 
@@ -20,7 +20,8 @@ typedef struct umf_cuda_memory_provider_params_t
     *umf_cuda_memory_provider_params_handle_t;
 
 /// @brief  Create a struct to store parameters of the CUDA Memory Provider.
-/// @param  hParams [out] handle to the newly created parameters struct.
+/// @param  hParams [out] handle to the newly created parameters structure,
+///         initialized with the default (current) context and device ID.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t umfCUDAMemoryProviderParamsCreate(
     umf_cuda_memory_provider_params_handle_t *hParams);
@@ -53,10 +54,27 @@ umf_result_t umfCUDAMemoryProviderParamsSetMemoryType(
     umf_cuda_memory_provider_params_handle_t hParams,
     umf_usm_memory_type_t memoryType);
 
-umf_memory_provider_ops_t *umfCUDAMemoryProviderOps(void);
+/// @brief  Set the allocation flags in the parameters struct.
+/// @param  hParams handle to the parameters of the CUDA Memory Provider.
+/// @param  flags valid combination of CUDA allocation flags.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfCUDAMemoryProviderParamsSetAllocFlags(
+    umf_cuda_memory_provider_params_handle_t hParams, unsigned int flags);
+
+/// @brief  Set custom name of the CUDA Memory Provider.
+/// @param  hParams handle to the parameters of the CUDA Memory Provider.
+/// @param  name custom name. Must not be NULL. Name longer than 63 characters
+///         will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfCUDAMemoryProviderParamsSetName(
+    umf_cuda_memory_provider_params_handle_t hParams, const char *name);
+
+const umf_memory_provider_ops_t *umfCUDAMemoryProviderOps(void);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* UMF_PROVIDER_CUDA_H */
+#endif /* UMF_CUDA_PROVIDER_H */
diff --git a/include/umf/providers/provider_devdax_memory.h b/include/umf/providers/provider_devdax_memory.h
index 0fb5218bcf..d57b1c5de2 100644
--- a/include/umf/providers/provider_devdax_memory.h
+++ b/include/umf/providers/provider_devdax_memory.h
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -8,7 +8,7 @@
 #ifndef UMF_DEVDAX_MEMORY_PROVIDER_H
 #define UMF_DEVDAX_MEMORY_PROVIDER_H
 
-#include <umf/providers/provider_os_memory.h>
+#include <umf/memory_provider.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -24,13 +24,13 @@ typedef struct umf_devdax_memory_provider_params_t
     *umf_devdax_memory_provider_params_handle_t;
 
 /// @brief  Create a struct to store parameters of the Devdax Memory Provider.
-/// @param  hParams [out] handle to the newly created parameters struct.
 /// @param  path [in] path of the device DAX.
 /// @param  size [in] size of the device DAX in bytes.
+/// @param  hParams [out] handle to the newly created parameters struct.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t umfDevDaxMemoryProviderParamsCreate(
-    umf_devdax_memory_provider_params_handle_t *hParams, const char *path,
-    size_t size);
+    const char *path, size_t size,
+    umf_devdax_memory_provider_params_handle_t *hParams);
 
 /// @brief  Destroy parameters struct.
 /// @param  hParams [in] handle to the parameters of the Devdax Memory Provider.
@@ -56,6 +56,16 @@ umf_result_t umfDevDaxMemoryProviderParamsSetDeviceDax(
 umf_result_t umfDevDaxMemoryProviderParamsSetProtection(
     umf_devdax_memory_provider_params_handle_t hParams, unsigned protection);
 
+/// @brief  Set custom name of the Devdax Memory Provider.
+/// @param  hParams [in]  handle to the parameters of the Devdax Memory Provider.
+/// @param  name [in] custom name. Must not be NULL. Name longer than 63 characters
+///         will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfDevDaxMemoryProviderParamsSetName(
+    umf_devdax_memory_provider_params_handle_t hParams, const char *name);
+
 /// @brief Devdax Memory Provider operation results
 typedef enum umf_devdax_memory_provider_native_error {
     UMF_DEVDAX_RESULT_SUCCESS = UMF_DEVDAX_RESULTS_START_FROM, ///< Success
@@ -65,7 +75,7 @@ typedef enum umf_devdax_memory_provider_native_error {
     UMF_DEVDAX_RESULT_ERROR_PURGE_FORCE_FAILED, ///< Force purging failed
 } umf_devdax_memory_provider_native_error_t;
 
-umf_memory_provider_ops_t *umfDevDaxMemoryProviderOps(void);
+const umf_memory_provider_ops_t *umfDevDaxMemoryProviderOps(void);
 
 #ifdef __cplusplus
 }
diff --git a/include/umf/providers/provider_file_memory.h b/include/umf/providers/provider_file_memory.h
index f652e2cb8a..5586cfe7c4 100644
--- a/include/umf/providers/provider_file_memory.h
+++ b/include/umf/providers/provider_file_memory.h
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -8,7 +8,7 @@
 #ifndef UMF_FILE_MEMORY_PROVIDER_H
 #define UMF_FILE_MEMORY_PROVIDER_H
 
-#include <umf/providers/provider_os_memory.h>
+#include <umf/memory_provider.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -24,11 +24,11 @@ typedef struct umf_file_memory_provider_params_t
     *umf_file_memory_provider_params_handle_t;
 
 /// @brief  Create a struct to store parameters of the File Memory Provider.
-/// @param  hParams [out] handle to the newly created parameters struct.
 /// @param  path path to the file.
+/// @param  hParams [out] handle to the newly created parameters struct.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t umfFileMemoryProviderParamsCreate(
-    umf_file_memory_provider_params_handle_t *hParams, const char *path);
+    const char *path, umf_file_memory_provider_params_handle_t *hParams);
 
 /// @brief  Destroy parameters struct.
 /// @param  hParams handle to the parameters of the File Memory Provider.
@@ -66,7 +66,17 @@ typedef enum umf_file_memory_provider_native_error {
     UMF_FILE_RESULT_ERROR_PURGE_FORCE_FAILED, ///< Force purging failed
 } umf_file_memory_provider_native_error_t;
 
-umf_memory_provider_ops_t *umfFileMemoryProviderOps(void);
+const umf_memory_provider_ops_t *umfFileMemoryProviderOps(void);
+
+/// @brief  Set custom name of the File Memory Provider.
+/// @param  hParams handle to the parameters of the File Memory Provider.
+/// @param  name custom name. Must not be NULL. Name longer than 63 characters
+///         will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfFileMemoryProviderParamsSetName(
+    umf_file_memory_provider_params_handle_t hParams, const char *name);
 
 #ifdef __cplusplus
 }
diff --git a/include/umf/providers/provider_fixed_memory.h b/include/umf/providers/provider_fixed_memory.h
new file mode 100644
index 0000000000..fcedd5c005
--- /dev/null
+++ b/include/umf/providers/provider_fixed_memory.h
@@ -0,0 +1,74 @@
+/*
+ * 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
+*/
+
+#ifndef UMF_FIXED_MEMORY_PROVIDER_H
+#define UMF_FIXED_MEMORY_PROVIDER_H
+
+#include <umf/memory_provider.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// @cond
+#define UMF_FIXED_RESULTS_START_FROM 4000
+/// @endcond
+
+struct umf_fixed_memory_provider_params_t;
+
+typedef struct umf_fixed_memory_provider_params_t
+    *umf_fixed_memory_provider_params_handle_t;
+
+/// @brief  Create a struct to store parameters of the Fixed Memory Provider.
+/// @param  ptr [in] pointer to the memory region.
+/// @param  size [in] size of the memory region in bytes.
+/// @param  hParams [out] handle to the newly created parameters struct.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfFixedMemoryProviderParamsCreate(
+    void *ptr, size_t size, umf_fixed_memory_provider_params_handle_t *hParams);
+
+/// @brief  Set the memory region in params struct. Overwrites the previous value.
+///         It provides an ability to use the same instance of params to create multiple
+///         instances of the provider for different memory regions.
+/// @param  hParams [in] handle to the parameters of the Fixed Memory Provider.
+/// @param  ptr [in] pointer to the memory region.
+/// @param  size [in] size of the memory region in bytes.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfFixedMemoryProviderParamsSetMemory(
+    umf_fixed_memory_provider_params_handle_t hParams, void *ptr, size_t size);
+
+/// @brief  Destroy parameters struct.
+/// @param  hParams [in] handle to the parameters of the Fixed Memory Provider.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfFixedMemoryProviderParamsDestroy(
+    umf_fixed_memory_provider_params_handle_t hParams);
+
+/// @brief Retrieve the operations structure for the Fixed Memory Provider.
+/// @return Pointer to the umf_memory_provider_ops_t structure.
+const umf_memory_provider_ops_t *umfFixedMemoryProviderOps(void);
+
+/// @brief  Set custom name of the Fixed Memory Provider.
+/// @param  hParams [in] handle to the parameters of the Fixed Memory Provider.
+/// @param  name [in] custom name. Must not be NULL. Name longer than 63 characters
+///         will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfFixedMemoryProviderParamsSetName(
+    umf_fixed_memory_provider_params_handle_t hParams, const char *name);
+
+/// @brief Fixed Memory Provider operation results
+typedef enum umf_fixed_memory_provider_native_error {
+    UMF_FIXED_RESULT_SUCCESS = UMF_FIXED_RESULTS_START_FROM, ///< Success
+    UMF_FIXED_RESULT_ERROR_PURGE_FORCE_FAILED, ///< Force purging failed
+} umf_fixed_memory_provider_native_error_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_FIXED_MEMORY_PROVIDER_H */
diff --git a/include/umf/providers/provider_level_zero.h b/include/umf/providers/provider_level_zero.h
index f760c57244..22c3513351 100644
--- a/include/umf/providers/provider_level_zero.h
+++ b/include/umf/providers/provider_level_zero.h
@@ -1,12 +1,14 @@
 /*
- * 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
 */
 
-#ifndef UMF_PROVIDER_LEVEL_ZERO_H
-#define UMF_PROVIDER_LEVEL_ZERO_H
+#ifndef UMF_LEVEL_ZERO_PROVIDER_H
+#define UMF_LEVEL_ZERO_PROVIDER_H
+
+#include <stdbool.h>
 
 #include <umf/memory_provider_gpu.h>
 
@@ -68,10 +70,54 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetResidentDevices(
     umf_level_zero_memory_provider_params_handle_t hParams,
     ze_device_handle_t *hDevices, uint32_t deviceCount);
 
-umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void);
+typedef enum umf_level_zero_memory_provider_free_policy_t {
+    UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFAULT =
+        0, ///< Free memory immediately. Default.
+    UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_BLOCKING_FREE, ///< Blocks until all commands using the memory are complete before freeing.
+    UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFER_FREE, ///< Schedules the memory to be freed but does not free immediately.
+} umf_level_zero_memory_provider_free_policy_t;
+
+/// @brief  Set the memory free policy.
+/// @param  hParams handle to the parameters of the Level Zero Memory Provider.
+/// @param  policy memory free policy.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfLevelZeroMemoryProviderParamsSetFreePolicy(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    umf_level_zero_memory_provider_free_policy_t policy);
+
+/// @brief  Set the device ordinal in the parameters struct.
+/// @param  hParams handle to the parameters of the Level Zero Memory Provider.
+/// @param  deviceOrdinal device ordinal.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    uint32_t deviceOrdinal);
+
+/// @brief  Set custom name of the Level Zero Memory Provider.
+/// @param  hParams handle to the parameters of the Level Zero Memory Provider.
+/// @param  name custom name. Must not be NULL. Name longer than 63 characters
+///         will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfLevelZeroMemoryProviderParamsSetName(
+    umf_level_zero_memory_provider_params_handle_t hParams, const char *name);
+
+/// @brief Adds or removes devices on which allocations should be made
+///        resident.
+/// @param provider handle to the memory provider
+/// @param device device handle
+/// @param is_adding Boolean indicating if peer is to be removed or added
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on
+///         failure.
+umf_result_t umfLevelZeroMemoryProviderResidentDeviceChange(
+    umf_memory_provider_handle_t provider, ze_device_handle_t device,
+    bool is_adding);
+
+const umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* UMF_PROVIDER_LEVEL_ZERO_H */
+#endif /* UMF_LEVEL_ZERO_PROVIDER_H */
diff --git a/include/umf/providers/provider_os_memory.h b/include/umf/providers/provider_os_memory.h
index a6bf43a7d9..93a20173cf 100644
--- a/include/umf/providers/provider_os_memory.h
+++ b/include/umf/providers/provider_os_memory.h
@@ -1,14 +1,16 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ *
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-*/
+ *
+ */
 
 #ifndef UMF_OS_MEMORY_PROVIDER_H
 #define UMF_OS_MEMORY_PROVIDER_H
 
-#include "umf/memory_provider.h"
+#include <umf/memory_provider.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -23,7 +25,7 @@ extern "C" {
 /// Not every mode is supported on every system.
 typedef enum umf_numa_mode_t {
     /// Default binding mode. Actual binding policy is system-specific. On
-    /// linux this corresponds to MPOL_DEFAULT. If this mode is specified,
+    /// Linux this corresponds to MPOL_DEFAULT. If this mode is specified,
     /// nodemask must be NULL and maxnode must be 0.
     UMF_NUMA_MODE_DEFAULT,
 
@@ -132,6 +134,17 @@ umf_result_t umfOsMemoryProviderParamsSetPartitions(
     umf_os_memory_provider_params_handle_t hParams,
     umf_numa_split_partition_t *partitions, unsigned partitions_len);
 
+/// @brief  Set custom name of the OS memory provider.
+/// @param  hParams handle to the parameters of the OS memory provider.
+/// @param  name custom name. Must not be NULL. Name longer than 63 characters
+///         will be truncated.
+/// \details Name should contain only [a-zA-Z0-9_-] characters.
+/// Other names are deprecated and may limit CTL functionality.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfOsMemoryProviderParamsSetName(umf_os_memory_provider_params_handle_t hParams,
+                                 const char *name);
+
 /// @brief OS Memory Provider operation results
 typedef enum umf_os_memory_provider_native_error {
     UMF_OS_RESULT_SUCCESS = UMF_OS_RESULTS_START_FROM, ///< Success
@@ -144,7 +157,7 @@ typedef enum umf_os_memory_provider_native_error {
     UMF_OS_RESULT_ERROR_TOPO_DISCOVERY_FAILED, ///< HWLOC topology discovery failed
 } umf_os_memory_provider_native_error_t;
 
-umf_memory_provider_ops_t *umfOsMemoryProviderOps(void);
+const umf_memory_provider_ops_t *umfOsMemoryProviderOps(void);
 
 #ifdef __cplusplus
 }
diff --git a/scripts/README.md b/scripts/README.md
deleted file mode 100644
index e3a9ed533f..0000000000
--- a/scripts/README.md
+++ /dev/null
@@ -1,5 +0,0 @@
-The documentation HTML files are generated using the following dependencies:
- * [Python](https://www.python.org/downloads/) at least v3.8
- * [Doxygen](http://www.doxygen.nl/) at least v1.9.1
-
- To generate files run the `generate_docs.py` script from the `scripts` directory. Files will be generated to the `docs/html` directory relative to the main directory of this repository.
diff --git a/scripts/check_license/check_headers.sh b/scripts/check_license/check_headers.sh
new file mode 100755
index 0000000000..aeb90e7a28
--- /dev/null
+++ b/scripts/check_license/check_headers.sh
@@ -0,0 +1,197 @@
+#!/usr/bin/env bash
+# Copyright (C) 2016-2025 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+# check-headers.sh - check copyright and license in source files
+
+SELF=$0
+
+function usage() {
+	echo "Usage: $SELF <source_root_path> <license_tag> [-h|-v|-a|-d]"
+	echo "   -h, --help          this help message"
+	echo "   -v, --verbose       verbose mode"
+	echo "   -a, --all           check all files (only modified files are checked by default)"
+	echo "   -d, --update_dates  change Copyright dates in all analyzed files (rather not use with -a)"
+}
+
+if [ "$#" -lt 2 ]; then
+	usage >&2
+	exit 2
+fi
+
+SOURCE_ROOT=$1
+shift
+LICENSE=$1
+shift
+
+PATTERN=`mktemp`
+TMP=`mktemp`
+TMP2=`mktemp`
+TEMPFILE=`mktemp`
+rm -f $PATTERN $TMP $TMP2
+
+if [ "$1" == "-h" -o "$1" == "--help" ]; then
+	usage
+	exit 0
+fi
+
+export GIT="git -C ${SOURCE_ROOT}"
+$GIT rev-parse || exit 1
+
+if [ -f $SOURCE_ROOT/.git/shallow ]; then
+	SHALLOW_CLONE=1
+	echo
+	echo "Warning: This is a shallow clone. Checking dates in copyright headers"
+	echo "         will be skipped in case of files that have no history."
+	echo
+else
+	SHALLOW_CLONE=0
+fi
+
+VERBOSE=0
+CHECK_ALL=0
+UPDATE_DATES=0
+while [ "$1" != "" ]; do
+	case $1 in
+	-v|--verbose)
+		VERBOSE=1
+		;;
+	-a|--all)
+		CHECK_ALL=1
+		;;
+	-d|--update_dates)
+		UPDATE_DATES=1
+		;;
+	esac
+	shift
+done
+
+if [ $CHECK_ALL -eq 0 ]; then
+	CURRENT_COMMIT=$($GIT --no-pager log --pretty=%H -1)
+	MERGE_BASE=$($GIT merge-base HEAD origin/main 2>/dev/null)
+	[ -z $MERGE_BASE ] && \
+		MERGE_BASE=$($GIT --no-pager log --pretty="%cN:%H" | grep GitHub 2>/dev/null | head -n1 | cut -d: -f2)
+	[ -z $MERGE_BASE -o "$CURRENT_COMMIT" = "$MERGE_BASE" ] && \
+		CHECK_ALL=1
+fi
+
+if [ $CHECK_ALL -eq 1 ]; then
+	echo "INFO: Checking copyright headers of all files..."
+	GIT_COMMAND="ls-tree -r --name-only HEAD"
+else
+	echo "INFO: Checking copyright headers of modified files only..."
+	GIT_COMMAND="diff --name-only $MERGE_BASE $CURRENT_COMMIT"
+fi
+
+FILES=$($GIT $GIT_COMMAND | ${SOURCE_ROOT}/scripts/check_license/file-exceptions.sh)
+
+RV=0
+for file in $FILES ; do
+	if [ $VERBOSE -eq 1 ]; then
+		echo "Checking file: $file"
+	fi
+	# The src_path is a path which should be used in every command except git.
+	# git is called with -C flag so filepaths should be relative to SOURCE_ROOT
+	src_path="${SOURCE_ROOT}/$file"
+	[ ! -f $src_path ] && continue
+	# ensure that file is UTF-8 encoded
+	ENCODING=`file -b --mime-encoding $src_path`
+	iconv -f $ENCODING -t "UTF-8" $src_path > $TEMPFILE
+
+	if ! grep -q "SPDX-License-Identifier: $LICENSE" $src_path; then
+		echo >&2 "error: no $LICENSE SPDX tag in file: $src_path"
+		RV=1
+	fi
+
+	if [ $SHALLOW_CLONE -eq 0 ]; then
+		$GIT log --no-merges --format="%ai %aE" -- $file | sort > $TMP
+	else
+		# mark the grafted commits (commits with no parents)
+		$GIT log --no-merges --format="%ai %aE grafted-%p-commit" -- $file | sort > $TMP
+	fi
+
+	# skip checking dates for non-Intel commits
+	[[ ! $(tail -n1 $TMP) =~ "@intel.com" ]] && continue
+
+	# skip checking dates for new files
+	[ $(cat $TMP | wc -l) -le 1 ] && continue
+
+	# grep out the grafted commits (commits with no parents)
+	# and skip checking dates for non-Intel commits
+	grep -v -e "grafted--commit" $TMP | grep -e "@intel.com" > $TMP2
+
+	[ $(cat $TMP2 | wc -l) -eq 0 ] && continue
+
+	FIRST=`head -n1 $TMP2`
+	LAST=` tail -n1 $TMP2`
+
+	YEARS=$(sed '
+/.*Copyright (C) [0-9-]\+ Intel Corporation/!d
+s/.*Copyright (C) \([0-9]\+\)-\([0-9]\+\).*/\1-\2/
+s/.*Copyright (C) \([0-9]\+\).*/\1/' "$src_path")
+	if [ -z "$YEARS" ]; then
+		echo >&2 "No copyright years in $src_path"
+		RV=1
+		continue
+	fi
+
+	HEADER_FIRST=`echo $YEARS | cut -d"-" -f1`
+	HEADER_LAST=` echo $YEARS | cut -d"-" -f2`
+
+	COMMIT_FIRST=`echo $FIRST | cut -d"-" -f1`
+	COMMIT_LAST=` echo $LAST  | cut -d"-" -f1`
+
+	if [ "$COMMIT_FIRST" != "" -a "$COMMIT_LAST" != "" ]; then
+    	if [ "$COMMIT_FIRST" -lt "$HEADER_FIRST" ]; then
+    	    RV=1
+    	fi
+
+    	if [[ -n "$COMMIT_FIRST" && -n "$COMMIT_LAST" ]]; then
+    	    if [[ $HEADER_FIRST -le $COMMIT_FIRST ]]; then
+    	        if [[ $HEADER_LAST -eq $COMMIT_LAST ]]; then
+    	            continue
+    	        else
+    	            NEW="$HEADER_FIRST-$COMMIT_LAST"
+    	            if [[ ${UPDATE_DATES} -eq 1 ]]; then
+    	                echo "Updating copyright date in $src_path: $YEARS -> $NEW"
+    	                sed -i "s/Copyright (C) ${YEARS}/Copyright (C) ${NEW}/g" "${src_path}"
+    	            else
+    	                echo "$file:1: error: wrong copyright date: (is: $YEARS, should be: $NEW)" >&2
+    	                RV=1
+    	            fi
+    	        fi
+    	    else
+    	        if [[ $COMMIT_FIRST -eq $COMMIT_LAST ]]; then
+    	            NEW=$COMMIT_LAST
+    	        else
+    	            NEW=$COMMIT_FIRST-$COMMIT_LAST
+    	        fi
+
+    	        if [[ "$YEARS" == "$NEW" ]]; then
+    	            continue
+    	        else
+    	            if [[ ${UPDATE_DATES} -eq 1 ]]; then
+    	                echo "Updating copyright date in $src_path: $YEARS -> $NEW"
+    	                sed -i "s/Copyright (C) ${YEARS}/Copyright (C) ${NEW}/g" "${src_path}"
+    	            else
+    	                echo "$file:1: error: wrong copyright date: (is: $YEARS, should be: $NEW)" >&2
+    	                RV=1
+    	            fi
+    	        fi
+    	    fi
+    	fi
+	else
+	    echo "error: unknown commit dates in file: $file" >&2
+	    RV=1
+	fi
+done
+rm -f $TMP $TMP2 $TEMPFILE
+
+# check if error found
+if [ $RV -eq 0 ]; then
+	echo "Copyright headers are OK."
+else
+	echo "Error(s) in copyright headers found!" >&2
+fi
+exit $RV
diff --git a/scripts/check_license/file-exceptions.sh b/scripts/check_license/file-exceptions.sh
new file mode 100755
index 0000000000..10c5560614
--- /dev/null
+++ b/scripts/check_license/file-exceptions.sh
@@ -0,0 +1,38 @@
+#!/bin/sh -e
+# 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
+
+# You can add an exception file
+# list for license and copyright check
+grep -v -E -e 'benchmark/ubench.h' \
+           -e 'ChangeLog' \
+           -e 'CODEOWNERS$' \
+           -e 'docs/assets/.*' \
+           -e 'docs/config/spelling_exceptions.txt' \
+           -e 'docs/config/conf.py' \
+           -e 'docs/config/Doxyfile' \
+           -e 'include/umf/proxy_lib_new_delete.h' \
+           -e 'LICENSE.TXT' \
+           -e 'licensing/third-party-programs.txt' \
+           -e 'scripts/assets/images/.*' \
+           -e 'scripts/qemu/requirements.txt' \
+           -e 'src/uthash/.*' \
+           -e 'src/uthash/utlist.h' \
+           -e 'src/uthash/uthash.h' \
+           -e 'test/ctl/config.txt' \
+           -e 'test/supp/.*' \
+           -e 'third_party/requirements.txt' \
+           -e '.clang-format$' \
+           -e '.cmake-format$' \
+           -e '.cmake.in$' \
+           -e '.gitignore' \
+           -e '.json$' \
+           -e '.mailmap' \
+           -e '.md$' \
+           -e '.patch$' \
+           -e '.rst$' \
+           -e '.spellcheck-conf.toml' \
+           -e '.trivyignore' \
+           -e '.xml$' \
+           -e '.yml$'
diff --git a/scripts/qemu/configs/default.xml b/scripts/qemu/configs/default.xml
index 5654687949..5d3198f60a 100644
--- a/scripts/qemu/configs/default.xml
+++ b/scripts/qemu/configs/default.xml
@@ -50,16 +50,12 @@ Cell 2 |   0   |   1200MiB    | 17, 28, 10          |
       <interconnects>
         <latency initiator='0' target='0' type='access' value='10'/>
         <bandwidth initiator='0' target='0' type='access' value='10485760' unit='B'/>
-        
         <latency initiator='0' target='1' type='access' value='20'/>
         <bandwidth initiator='0' target='1' type='access' value='5242880' unit='B'/>
-        
         <latency initiator='0' target='2' type='access' value='16'/>
         <bandwidth initiator='0' target='2' type='access' value='1048576' unit='B'/>
-       
         <latency initiator='1' target='1' type='access' value='10'/>
         <bandwidth initiator='1' target='1' type='access' value='10485760' unit='B'/>
-        
         <latency initiator='1' target='2' type='access' value='27'/>
         <bandwidth initiator='1' target='2' type='access' value='1048576' unit='B'/>
       </interconnects>
diff --git a/scripts/qemu/configs/sock_8_var1_hmat.xml b/scripts/qemu/configs/sock_8_var1_hmat.xml
new file mode 100644
index 0000000000..1deb417bdf
--- /dev/null
+++ b/scripts/qemu/configs/sock_8_var1_hmat.xml
@@ -0,0 +1,393 @@
+<!-- SPDX-License-Identifier: BSD-2-Clause
+# Copyright (C) 2025 Intel Corporation.
+-->
+
+<!-- Based on https://github.com/oneapi-src/unified-memory-framework/issues/1289 -->
+
+<!--
+Total Sockets: 8
+Total CPUs:    8
+Threads / CPU: 1
+Total Memory:  8000 MiB
+HMAT:          Enabled
+
+_______| CPUs | Memory |___________________________ Distances __________________________|
+Cell 0  |  1  | 500 MiB| 10, 12, 12, 12, 21, 21, 21, 21, 13, 14, 14, 14, 23, 23, 23, 23 |
+Cell 1  |  1  | 500 MiB| 12, 10, 12, 12, 21, 21, 21, 21, 14, 13, 14, 14, 23, 23, 23, 23 |
+Cell 2  |  1  | 500 MiB| 12, 12, 10, 12, 21, 21, 21, 21, 14, 14, 13, 14, 23, 23, 23, 23 |
+Cell 3  |  1  | 500 MiB| 12, 12, 12, 10, 21, 21, 21, 21, 14, 14, 14, 13, 23, 23, 23, 23 |
+Cell 4  |  1  | 500 MiB| 21, 21, 21, 21, 10, 12, 12, 12, 23, 23, 23, 23, 13, 14, 14, 14 |
+Cell 5  |  1  | 500 MiB| 21, 21, 21, 21, 12, 10, 12, 12, 23, 23, 23, 23, 14, 13, 14, 14 |
+Cell 6  |  1  | 500 MiB| 21, 21, 21, 21, 12, 12, 10, 12, 23, 23, 23, 23, 14, 14, 13, 14 |
+Cell 7  |  1  | 500 MiB| 21, 21, 21, 21, 12, 12, 12, 10, 23, 23, 23, 23, 14, 14, 14, 13 |
+Cell 8  |  0  | 500 MiB| 13, 14, 14, 14, 23, 23, 23, 23, 10, 14, 14, 14, 23, 23, 23, 23 |
+Cell 9  |  0  | 500 MiB| 14, 13, 14, 14, 23, 23, 23, 23, 14, 10, 14, 14, 23, 23, 23, 23 |
+Cell 10 |  0  | 500 MiB| 14, 14, 13, 14, 23, 23, 23, 23, 14, 14, 10, 14, 23, 23, 23, 23 |
+Cell 11 |  0  | 500 MiB| 14, 14, 14, 13, 23, 23, 23, 23, 14, 14, 14, 10, 23, 23, 23, 23 |
+Cell 12 |  0  | 500 MiB| 23, 23, 23, 23, 13, 14, 14, 14, 23, 23, 23, 23, 10, 14, 14, 14 |
+Cell 13 |  0  | 500 MiB| 23, 23, 23, 23, 14, 13, 14, 14, 23, 23, 23, 23, 14, 10, 14, 14 |
+Cell 14 |  0  | 500 MiB| 23, 23, 23, 23, 14, 14, 13, 14, 23, 23, 23, 23, 14, 14, 10, 14 |
+Cell 15 |  0  | 500 MiB| 23, 23, 23, 23, 14, 14, 14, 13, 23, 23, 23, 23, 14, 14, 14, 10 |
+-->
+
+<domain type='qemu'>
+  <name>Sockets8_16N_500MB_HMAT</name>
+  <os>
+    <type arch='x86_64' machine='pc'>hvm</type>
+  </os>
+
+  <vcpu placement='static'>8</vcpu>
+  <cpu>
+    <topology sockets='8' dies='1' cores='1' threads='1'/>
+
+    <numa>
+      <cell id='0' cpus='0'  memory='500' unit='MiB'>
+        <distances>
+          <sibling id='0'  value='10'/><sibling id='1'  value='12'/><sibling id='2'  value='12'/><sibling id='3'  value='12'/>
+          <sibling id='4'  value='21'/><sibling id='5'  value='21'/><sibling id='6'  value='21'/><sibling id='7'  value='21'/>
+          <sibling id='8'  value='13'/><sibling id='9'  value='14'/><sibling id='10' value='14'/><sibling id='11' value='14'/>
+          <sibling id='12' value='23'/><sibling id='13' value='23'/><sibling id='14' value='23'/><sibling id='15' value='23'/>
+        </distances>
+      </cell>
+
+      <cell id='1' cpus='1'  memory='500' unit='MiB'>
+        <distances>
+          <sibling id='0'  value='12'/><sibling id='1'  value='10'/><sibling id='2'  value='12'/><sibling id='3'  value='12'/>
+          <sibling id='4'  value='21'/><sibling id='5'  value='21'/><sibling id='6'  value='21'/><sibling id='7'  value='21'/>
+          <sibling id='8'  value='14'/><sibling id='9'  value='13'/><sibling id='10' value='14'/><sibling id='11' value='14'/>
+          <sibling id='12' value='23'/><sibling id='13' value='23'/><sibling id='14' value='23'/><sibling id='15' value='23'/>
+        </distances>
+      </cell>
+
+      <cell id='2' cpus='2'  memory='500' unit='MiB'>
+        <distances>
+          <sibling id='0'  value='12'/><sibling id='1'  value='12'/><sibling id='2'  value='10'/><sibling id='3'  value='12'/>
+          <sibling id='4'  value='21'/><sibling id='5'  value='21'/><sibling id='6'  value='21'/><sibling id='7'  value='21'/>
+          <sibling id='8'  value='14'/><sibling id='9'  value='14'/><sibling id='10' value='13'/><sibling id='11' value='14'/>
+          <sibling id='12' value='23'/><sibling id='13' value='23'/><sibling id='14' value='23'/><sibling id='15' value='23'/>
+        </distances>
+      </cell>
+
+      <cell id='3' cpus='3'  memory='500' unit='MiB'>
+        <distances>
+          <sibling id='0'  value='12'/><sibling id='1'  value='12'/><sibling id='2'  value='12'/><sibling id='3'  value='10'/>
+          <sibling id='4'  value='21'/><sibling id='5'  value='21'/><sibling id='6'  value='21'/><sibling id='7'  value='21'/>
+          <sibling id='8'  value='14'/><sibling id='9'  value='14'/><sibling id='10' value='14'/><sibling id='11' value='13'/>
+          <sibling id='12' value='23'/><sibling id='13' value='23'/><sibling id='14' value='23'/><sibling id='15' value='23'/>
+        </distances>
+      </cell>
+
+      <cell id='4' cpus='4'  memory='500' unit='MiB'>
+        <distances>
+          <sibling id='0'  value='21'/><sibling id='1'  value='21'/><sibling id='2'  value='21'/><sibling id='3'  value='21'/>
+          <sibling id='4'  value='10'/><sibling id='5'  value='12'/><sibling id='6'  value='12'/><sibling id='7'  value='12'/>
+          <sibling id='8'  value='23'/><sibling id='9'  value='23'/><sibling id='10' value='23'/><sibling id='11' value='23'/>
+          <sibling id='12' value='13'/><sibling id='13' value='14'/><sibling id='14' value='14'/><sibling id='15' value='14'/>
+        </distances>
+      </cell>
+
+      <cell id='5' cpus='5' memory='500' unit='MiB'>
+        <distances>
+          <sibling id='0'  value='21'/><sibling id='1'  value='21'/><sibling id='2'  value='21'/><sibling id='3'  value='21'/>
+          <sibling id='4'  value='12'/><sibling id='5'  value='10'/><sibling id='6'  value='12'/><sibling id='7'  value='12'/>
+          <sibling id='8'  value='23'/><sibling id='9'  value='23'/><sibling id='10' value='23'/><sibling id='11' value='23'/>
+          <sibling id='12' value='14'/><sibling id='13' value='13'/><sibling id='14' value='14'/><sibling id='15' value='14'/>
+        </distances>
+      </cell>
+
+      <cell id='6' cpus='6' memory='500' unit='MiB'>
+        <distances>
+          <sibling id='0'  value='21'/><sibling id='1'  value='21'/><sibling id='2'  value='21'/><sibling id='3'  value='21'/>
+          <sibling id='4'  value='12'/><sibling id='5'  value='12'/><sibling id='6'  value='10'/><sibling id='7'  value='12'/>
+          <sibling id='8'  value='23'/><sibling id='9'  value='23'/><sibling id='10' value='23'/><sibling id='11' value='23'/>
+          <sibling id='12' value='14'/><sibling id='13' value='14'/><sibling id='14' value='13'/><sibling id='15' value='14'/>
+        </distances>
+      </cell>
+
+      <cell id='7' cpus='7' memory='500' unit='MiB'>
+        <distances>
+          <sibling id='0'  value='21'/><sibling id='1'  value='21'/><sibling id='2'  value='21'/><sibling id='3'  value='21'/>
+          <sibling id='4'  value='12'/><sibling id='5'  value='12'/><sibling id='6'  value='12'/><sibling id='7'  value='10'/>
+          <sibling id='8'  value='23'/><sibling id='9'  value='23'/><sibling id='10' value='23'/><sibling id='11' value='23'/>
+          <sibling id='12' value='14'/><sibling id='13' value='14'/><sibling id='14' value='14'/><sibling id='15' value='13'/>
+        </distances>
+      </cell>
+
+<cell id='8' memory='500' unit='MiB'>
+        <distances>
+          <sibling id='0'  value='13'/><sibling id='1'  value='14'/><sibling id='2'  value='14'/><sibling id='3'  value='14'/>
+          <sibling id='4'  value='23'/><sibling id='5'  value='23'/><sibling id='6'  value='23'/><sibling id='7'  value='23'/>
+          <sibling id='8'  value='10'/><sibling id='9'  value='14'/><sibling id='10' value='14'/><sibling id='11' value='14'/>
+          <sibling id='12' value='23'/><sibling id='13' value='23'/><sibling id='14' value='23'/><sibling id='15' value='23'/>
+        </distances>
+      </cell>
+
+      <cell id='9' memory='500' unit='MiB'>
+        <distances>
+          <sibling id='0'  value='14'/><sibling id='1'  value='13'/><sibling id='2'  value='14'/><sibling id='3'  value='14'/>
+          <sibling id='4'  value='23'/><sibling id='5'  value='23'/><sibling id='6'  value='23'/><sibling id='7'  value='23'/>
+          <sibling id='8'  value='14'/><sibling id='9'  value='10'/><sibling id='10' value='14'/><sibling id='11' value='14'/>
+          <sibling id='12' value='23'/><sibling id='13' value='23'/><sibling id='14' value='23'/><sibling id='15' value='23'/>
+        </distances>
+      </cell>
+
+      <cell id='10' memory='500' unit='MiB'>
+        <distances>
+          <sibling id='0'  value='14'/><sibling id='1'  value='14'/><sibling id='2'  value='13'/><sibling id='3'  value='14'/>
+          <sibling id='4'  value='23'/><sibling id='5'  value='23'/><sibling id='6'  value='23'/><sibling id='7'  value='23'/>
+          <sibling id='8'  value='14'/><sibling id='9'  value='14'/><sibling id='10' value='10'/><sibling id='11' value='14'/>
+          <sibling id='12' value='23'/><sibling id='13' value='23'/><sibling id='14' value='23'/><sibling id='15' value='23'/>
+        </distances>
+      </cell>
+
+      <cell id='11' memory='500' unit='MiB'>
+        <distances>
+          <sibling id='0'  value='14'/><sibling id='1'  value='14'/><sibling id='2'  value='14'/><sibling id='3'  value='13'/>
+          <sibling id='4'  value='23'/><sibling id='5'  value='23'/><sibling id='6'  value='23'/><sibling id='7'  value='23'/>
+          <sibling id='8'  value='14'/><sibling id='9'  value='14'/><sibling id='10' value='14'/><sibling id='11' value='10'/>
+          <sibling id='12' value='23'/><sibling id='13' value='23'/><sibling id='14' value='23'/><sibling id='15' value='23'/>
+        </distances>
+      </cell>
+
+      <cell id='12' memory='500' unit='MiB'>
+        <distances>
+          <sibling id='0'  value='23'/><sibling id='1'  value='23'/><sibling id='2'  value='23'/><sibling id='3'  value='23'/>
+          <sibling id='4'  value='13'/><sibling id='5'  value='14'/><sibling id='6'  value='14'/><sibling id='7'  value='14'/>
+          <sibling id='8'  value='23'/><sibling id='9'  value='23'/><sibling id='10' value='23'/><sibling id='11' value='23'/>
+          <sibling id='12' value='10'/><sibling id='13' value='14'/><sibling id='14' value='14'/><sibling id='15' value='14'/>
+        </distances>
+      </cell>
+
+      <cell id='13' memory='500' unit='MiB'>
+        <distances>
+          <sibling id='0'  value='23'/><sibling id='1'  value='23'/><sibling id='2'  value='23'/><sibling id='3'  value='23'/>
+          <sibling id='4'  value='14'/><sibling id='5'  value='13'/><sibling id='6'  value='14'/><sibling id='7'  value='14'/>
+          <sibling id='8'  value='23'/><sibling id='9'  value='23'/><sibling id='10' value='23'/><sibling id='11' value='23'/>
+          <sibling id='12' value='14'/><sibling id='13' value='10'/><sibling id='14' value='14'/><sibling id='15' value='14'/>
+        </distances>
+      </cell>
+
+      <cell id='14' memory='500' unit='MiB'>
+        <distances>
+          <sibling id='0'  value='23'/><sibling id='1'  value='23'/><sibling id='2'  value='23'/><sibling id='3'  value='23'/>
+          <sibling id='4'  value='14'/><sibling id='5'  value='14'/><sibling id='6'  value='13'/><sibling id='7'  value='14'/>
+          <sibling id='8'  value='23'/><sibling id='9'  value='23'/><sibling id='10' value='23'/><sibling id='11' value='23'/>
+          <sibling id='12' value='14'/><sibling id='13' value='14'/><sibling id='14' value='10'/><sibling id='15' value='14'/>
+        </distances>
+      </cell>
+
+      <cell id='15' memory='500' unit='MiB'>
+        <distances>
+          <sibling id='0'  value='23'/><sibling id='1'  value='23'/><sibling id='2'  value='23'/><sibling id='3'  value='23'/>
+          <sibling id='4'  value='14'/><sibling id='5'  value='14'/><sibling id='6'  value='14'/><sibling id='7'  value='13'/>
+          <sibling id='8'  value='23'/><sibling id='9'  value='23'/><sibling id='10' value='23'/><sibling id='11' value='23'/>
+          <sibling id='12' value='14'/><sibling id='13' value='14'/><sibling id='14' value='14'/><sibling id='15' value='10'/>
+        </distances>
+      </cell>
+
+      <interconnects>
+        <bandwidth initiator='0' target='0' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='0' target='1' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='0' target='2' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='0' target='3' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='0' target='4' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='0' target='5' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='0' target='6' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='0' target='7' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='0' target='8' type='access' value='726' unit='GiB'/>
+        <bandwidth initiator='0' target='9' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='0' target='10' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='0' target='11' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='0' target='12' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='0' target='13' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='0' target='14' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='0' target='15' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='1' target='1' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='1' target='2' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='1' target='3' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='1' target='4' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='1' target='5' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='1' target='6' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='1' target='7' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='1' target='8' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='1' target='9' type='access' value='726' unit='GiB'/>
+        <bandwidth initiator='1' target='10' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='1' target='11' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='1' target='12' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='1' target='13' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='1' target='14' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='1' target='15' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='2' target='2' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='2' target='3' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='2' target='4' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='2' target='5' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='2' target='6' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='2' target='7' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='2' target='8' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='2' target='9' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='2' target='10' type='access' value='726' unit='GiB'/>
+        <bandwidth initiator='2' target='11' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='2' target='12' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='2' target='13' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='2' target='14' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='2' target='15' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='3' target='3' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='3' target='4' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='3' target='5' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='3' target='6' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='3' target='7' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='3' target='8' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='3' target='9' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='3' target='10' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='3' target='11' type='access' value='726' unit='GiB'/>
+        <bandwidth initiator='3' target='12' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='3' target='13' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='3' target='14' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='3' target='15' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='4' target='4' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='4' target='5' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='4' target='6' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='4' target='7' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='4' target='8' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='4' target='9' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='4' target='10' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='4' target='11' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='4' target='12' type='access' value='726' unit='GiB'/>
+        <bandwidth initiator='4' target='13' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='4' target='14' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='4' target='15' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='5' target='5' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='5' target='6' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='5' target='7' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='5' target='8' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='5' target='9' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='5' target='10' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='5' target='11' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='5' target='12' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='5' target='13' type='access' value='726' unit='GiB'/>
+        <bandwidth initiator='5' target='14' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='5' target='15' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='6' target='6' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='6' target='7' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='6' target='8' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='6' target='9' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='6' target='10' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='6' target='11' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='6' target='12' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='6' target='13' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='6' target='14' type='access' value='726' unit='GiB'/>
+        <bandwidth initiator='6' target='15' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='7' target='7' type='access' value='34' unit='GiB'/>
+        <bandwidth initiator='7' target='8' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='7' target='9' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='7' target='10' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='7' target='11' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='7' target='12' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='7' target='13' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='7' target='14' type='access' value='26' unit='GiB'/>
+        <bandwidth initiator='7' target='15' type='access' value='726' unit='GiB'/>
+
+        <latency initiator='0' target='0' type='access' value='72'/>
+        <latency initiator='0' target='1' type='access' value='133'/>
+        <latency initiator='0' target='2' type='access' value='133'/>
+        <latency initiator='0' target='3' type='access' value='133'/>
+        <latency initiator='0' target='4' type='access' value='133'/>
+        <latency initiator='0' target='5' type='access' value='133'/>
+        <latency initiator='0' target='6' type='access' value='133'/>
+        <latency initiator='0' target='7' type='access' value='133'/>
+        <latency initiator='0' target='8' type='access' value='72'/>
+        <latency initiator='0' target='9' type='access' value='176'/>
+        <latency initiator='0' target='10' type='access' value='176'/>
+        <latency initiator='0' target='11' type='access' value='176'/>
+        <latency initiator='0' target='12' type='access' value='176'/>
+        <latency initiator='0' target='13' type='access' value='176'/>
+        <latency initiator='0' target='14' type='access' value='176'/>
+        <latency initiator='0' target='15' type='access' value='176'/>
+        <latency initiator='1' target='1' type='access' value='72'/>
+        <latency initiator='1' target='2' type='access' value='133'/>
+        <latency initiator='1' target='3' type='access' value='133'/>
+        <latency initiator='1' target='4' type='access' value='133'/>
+        <latency initiator='1' target='5' type='access' value='133'/>
+        <latency initiator='1' target='6' type='access' value='133'/>
+        <latency initiator='1' target='7' type='access' value='133'/>
+        <latency initiator='1' target='8' type='access' value='176'/>
+        <latency initiator='1' target='9' type='access' value='72'/>
+        <latency initiator='1' target='10' type='access' value='176'/>
+        <latency initiator='1' target='11' type='access' value='176'/>
+        <latency initiator='1' target='12' type='access' value='176'/>
+        <latency initiator='1' target='13' type='access' value='176'/>
+        <latency initiator='1' target='14' type='access' value='176'/>
+        <latency initiator='1' target='15' type='access' value='176'/>
+        <latency initiator='2' target='2' type='access' value='72'/>
+        <latency initiator='2' target='3' type='access' value='133'/>
+        <latency initiator='2' target='4' type='access' value='133'/>
+        <latency initiator='2' target='5' type='access' value='133'/>
+        <latency initiator='2' target='6' type='access' value='133'/>
+        <latency initiator='2' target='7' type='access' value='133'/>
+        <latency initiator='2' target='8' type='access' value='176'/>
+        <latency initiator='2' target='9' type='access' value='176'/>
+        <latency initiator='2' target='10' type='access' value='72'/>
+        <latency initiator='2' target='11' type='access' value='176'/>
+        <latency initiator='2' target='12' type='access' value='176'/>
+        <latency initiator='2' target='13' type='access' value='176'/>
+        <latency initiator='2' target='14' type='access' value='176'/>
+        <latency initiator='2' target='15' type='access' value='176'/>
+        <latency initiator='3' target='3' type='access' value='72'/>
+        <latency initiator='3' target='4' type='access' value='133'/>
+        <latency initiator='3' target='5' type='access' value='133'/>
+        <latency initiator='3' target='6' type='access' value='133'/>
+        <latency initiator='3' target='7' type='access' value='133'/>
+        <latency initiator='3' target='8' type='access' value='176'/>
+        <latency initiator='3' target='9' type='access' value='176'/>
+        <latency initiator='3' target='10' type='access' value='176'/>
+        <latency initiator='3' target='11' type='access' value='72'/>
+        <latency initiator='3' target='12' type='access' value='176'/>
+        <latency initiator='3' target='13' type='access' value='176'/>
+        <latency initiator='3' target='14' type='access' value='176'/>
+        <latency initiator='3' target='15' type='access' value='176'/>
+        <latency initiator='4' target='4' type='access' value='72'/>
+        <latency initiator='4' target='5' type='access' value='133'/>
+        <latency initiator='4' target='6' type='access' value='133'/>
+        <latency initiator='4' target='7' type='access' value='133'/>
+        <latency initiator='4' target='8' type='access' value='176'/>
+        <latency initiator='4' target='9' type='access' value='176'/>
+        <latency initiator='4' target='10' type='access' value='176'/>
+        <latency initiator='4' target='11' type='access' value='176'/>
+        <latency initiator='4' target='12' type='access' value='72'/>
+        <latency initiator='4' target='13' type='access' value='176'/>
+        <latency initiator='4' target='14' type='access' value='176'/>
+        <latency initiator='4' target='15' type='access' value='176'/>
+        <latency initiator='5' target='5' type='access' value='72'/>
+        <latency initiator='5' target='6' type='access' value='133'/>
+        <latency initiator='5' target='7' type='access' value='133'/>
+        <latency initiator='5' target='8' type='access' value='176'/>
+        <latency initiator='5' target='9' type='access' value='176'/>
+        <latency initiator='5' target='10' type='access' value='176'/>
+        <latency initiator='5' target='11' type='access' value='176'/>
+        <latency initiator='5' target='12' type='access' value='176'/>
+        <latency initiator='5' target='13' type='access' value='72'/>
+        <latency initiator='5' target='14' type='access' value='176'/>
+        <latency initiator='5' target='15' type='access' value='176'/>
+        <latency initiator='6' target='6' type='access' value='72'/>
+        <latency initiator='6' target='7' type='access' value='133'/>
+        <latency initiator='6' target='8' type='access' value='176'/>
+        <latency initiator='6' target='9' type='access' value='176'/>
+        <latency initiator='6' target='10' type='access' value='176'/>
+        <latency initiator='6' target='11' type='access' value='176'/>
+        <latency initiator='6' target='12' type='access' value='176'/>
+        <latency initiator='6' target='13' type='access' value='176'/>
+        <latency initiator='6' target='14' type='access' value='72'/>
+        <latency initiator='6' target='15' type='access' value='176'/>
+        <latency initiator='7' target='7' type='access' value='72'/>
+        <latency initiator='7' target='8' type='access' value='176'/>
+        <latency initiator='7' target='9' type='access' value='176'/>
+        <latency initiator='7' target='10' type='access' value='176'/>
+        <latency initiator='7' target='11' type='access' value='176'/>
+        <latency initiator='7' target='12' type='access' value='176'/>
+        <latency initiator='7' target='13' type='access' value='176'/>
+        <latency initiator='7' target='14' type='access' value='176'/>
+        <latency initiator='7' target='15' type='access' value='72'/>
+      </interconnects>
+    </numa>
+  </cpu>
+</domain>
diff --git a/scripts/qemu/requirements.txt b/scripts/qemu/requirements.txt
index a4d92cc08d..4a6ecefc58 100644
--- a/scripts/qemu/requirements.txt
+++ b/scripts/qemu/requirements.txt
@@ -1 +1 @@
-psutil
+psutil==7.0.0
diff --git a/scripts/qemu/run-build.sh b/scripts/qemu/run-build.sh
index 06d6043f6b..724e6d7ff2 100755
--- a/scripts/qemu/run-build.sh
+++ b/scripts/qemu/run-build.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
-# 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
 
@@ -14,18 +14,18 @@ pwd
 
 echo password | sudo -Sk apt-get update
 echo password | sudo -Sk apt-get install -y git cmake gcc g++ pkg-config \
-    numactl libnuma-dev hwloc libhwloc-dev libjemalloc-dev libtbb-dev valgrind lcov
+    numactl libnuma-dev hwloc libhwloc-dev libtbb-dev valgrind lcov
 
 mkdir build
 cd build
 
 cmake .. \
     -DCMAKE_BUILD_TYPE=Debug \
+    -DUMF_QEMU_BUILD=1 \
     -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON \
     -DUMF_BUILD_CUDA_PROVIDER=ON \
     -DUMF_FORMAT_CODE_STYLE=OFF \
     -DUMF_DEVELOPER_MODE=ON \
-    -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON \
     -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON \
     -DUMF_BUILD_EXAMPLES=ON \
     -DUMF_USE_COVERAGE=${COVERAGE} \
diff --git a/scripts/qemu/run-tests.sh b/scripts/qemu/run-tests.sh
index 9d855590ba..341e2f9ab8 100755
--- a/scripts/qemu/run-tests.sh
+++ b/scripts/qemu/run-tests.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
-# 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
 
@@ -23,8 +23,6 @@ UMF_DIR=$(pwd)
 # Drop caches, restores free memory on NUMA nodes
 echo password | sudo sync;
 echo password | sudo sh -c "/usr/bin/echo 3 > /proc/sys/vm/drop_caches"
-# Set ptrace value for IPC test
-echo password | sudo bash -c "echo 0 > /proc/sys/kernel/yama/ptrace_scope"
 
 numactl -H
 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 57050e8276..45046fdc6d 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,4 +1,4 @@
-# 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
 
@@ -27,44 +27,27 @@ endforeach()
 #
 # TODO: Cleanup the compile definitions across all the CMake files
 set(UMF_COMMON_COMPILE_DEFINITIONS
-    UMF_VERSION=${UMF_VERSION}
+    ${UMF_COMMON_COMPILE_DEFINITIONS} UMF_VERSION=${UMF_VERSION}
     UMF_ALL_CMAKE_VARIABLES="${UMF_ALL_CMAKE_VARIABLES}")
 
 add_subdirectory(utils)
+add_subdirectory(base_alloc)
+add_subdirectory(coarse)
 
-set(UMF_LIBS $<BUILD_INTERFACE:umf_utils>)
-
-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)
-
-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(HWLOC_DEPENDENT_SOURCES topology.c)
+set(UMF_LIBS umf_utils umf_ba umf_coarse $<BUILD_INTERFACE:${UMF_HWLOC_NAME}>)
 
 set(UMF_SOURCES
-    ${BA_SOURCES}
+    ctl/ctl.c
+    ctl/ctl_defaults.c
     libumf.c
     ipc.c
     ipc_cache.c
     memory_pool.c
+    memory_properties.c
     memory_provider.c
     memory_provider_get_last_failed.c
     memtarget.c
+    memtargets/memtarget_numa.c
     mempolicy.c
     memspace.c
     memspaces/memspace_host_all.c
@@ -72,47 +55,54 @@ set(UMF_SOURCES
     memspaces/memspace_highest_bandwidth.c
     memspaces/memspace_lowest_latency.c
     memspaces/memspace_numa.c
-    provider/provider_coarse.c
     provider/provider_cuda.c
     provider/provider_devdax_memory.c
     provider/provider_file_memory.c
+    provider/provider_fixed_memory.c
     provider/provider_level_zero.c
     provider/provider_os_memory.c
     provider/provider_tracking.c
     critnib/critnib.c
     ravl/ravl.c
+    pool/pool_disjoint.c
+    pool/pool_jemalloc.c
     pool/pool_proxy.c
-    pool/pool_scalable.c)
+    pool/pool_scalable.c
+    topology.c)
 
-if(NOT UMF_DISABLE_HWLOC)
-    set(UMF_SOURCES ${UMF_SOURCES} ${HWLOC_DEPENDENT_SOURCES}
-                    memtargets/memtarget_numa.c)
-    set(UMF_LIBS ${UMF_LIBS} ${LIBHWLOC_LIBRARIES})
+if(UMF_POOL_JEMALLOC_ENABLED)
+    set(UMF_LIBS ${UMF_LIBS} ${JEMALLOC_LIBRARIES})
     set(UMF_PRIVATE_LIBRARY_DIRS ${UMF_PRIVATE_LIBRARY_DIRS}
-                                 ${LIBHWLOC_LIBRARY_DIRS})
-else()
+                                 ${JEMALLOC_LIBRARY_DIRS})
+    set(UMF_PRIVATE_INCLUDE_DIRS ${UMF_PRIVATE_INCLUDE_DIRS}
+                                 ${JEMALLOC_INCLUDE_DIRS})
     set(UMF_COMMON_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS}
-                                       "UMF_NO_HWLOC=1")
+                                       "UMF_POOL_JEMALLOC_ENABLED=1")
 endif()
 
+set(UMF_PRIVATE_LIBRARY_DIRS ${UMF_PRIVATE_LIBRARY_DIRS}
+                             ${LIBHWLOC_LIBRARY_DIRS})
+
 set(UMF_SOURCES_LINUX libumf_linux.c)
 set(UMF_SOURCES_MACOSX libumf_linux.c)
 set(UMF_SOURCES_WINDOWS libumf_windows.c)
 
-# Add compile definitions to handle unsupported functions
-if(NOT UMF_BUILD_CUDA_PROVIDER)
-    set(UMF_COMMON_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS}
-                                       "UMF_NO_CUDA_PROVIDER=1")
-endif()
-if(NOT UMF_BUILD_LEVEL_ZERO_PROVIDER)
+if(UMF_BUILD_LEVEL_ZERO_PROVIDER)
+    if(LINUX)
+        # WA for error ze_api.h:14234:20: no newline at end of file
+        # [-Werror,-Wnewline-eof]
+        set_source_files_properties(
+            provider/provider_level_zero.c
+            PROPERTIES APPEND_STRING PROPERTY COMPILE_FLAGS "-Wno-newline-eof")
+    endif()
+
     set(UMF_COMMON_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS}
-                                       "UMF_NO_LEVEL_ZERO_PROVIDER=1")
+                                       "UMF_BUILD_LEVEL_ZERO_PROVIDER=1")
 endif()
-if(UMF_DISABLE_HWLOC OR WINDOWS)
-    set(UMF_COMMON_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS}
-                                       "UMF_NO_DEVDAX_PROVIDER=1")
+
+if(UMF_BUILD_CUDA_PROVIDER)
     set(UMF_COMMON_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS}
-                                       "UMF_NO_FILE_PROVIDER=1")
+                                       "UMF_BUILD_CUDA_PROVIDER=1")
 endif()
 
 if(LINUX)
@@ -134,14 +124,11 @@ if(UMF_BUILD_SHARED_LIBRARY)
         set(CMAKE_INSTALL_RPATH "${UMF_INSTALL_RPATH}")
     endif()
 
-    if(NOT UMF_DISABLE_HWLOC)
-        set(HWLOC_LIB ${UMF_HWLOC_NAME})
-    endif()
     add_umf_library(
         NAME umf
         TYPE SHARED
         SRCS ${UMF_SOURCES}
-        LIBS ${UMF_LIBS} ${HWLOC_LIB}
+        LIBS ${UMF_LIBS}
         LINUX_MAP_FILE ${CMAKE_CURRENT_SOURCE_DIR}/libumf.map
         WINDOWS_DEF_FILE ${CMAKE_CURRENT_SOURCE_DIR}/libumf.def)
     set(UMF_COMMON_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS}
@@ -159,30 +146,30 @@ else()
         LIBS ${UMF_LIBS})
 endif()
 
-if(UMF_LINK_HWLOC_STATICALLY)
-    add_dependencies(umf ${UMF_HWLOC_NAME})
-endif()
-
+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})
 
-if(UMF_BUILD_LEVEL_ZERO_PROVIDER)
-    if(LINUX)
-        # WA for error ze_api.h:14234:20: no newline at end of file
-        # [-Werror,-Wnewline-eof]
-        set_source_files_properties(
-            provider/provider_level_zero.c
-            PROPERTIES APPEND_STRING PROPERTY COMPILE_FLAGS "-Wno-newline-eof")
-    endif()
+add_dependencies(umf umf_ba umf_coarse umf_utils)
 
-    set(UMF_COMPILE_DEFINITIONS ${UMF_COMPILE_DEFINITIONS}
-                                "UMF_BUILD_LEVEL_ZERO_PROVIDER=1")
+if(UMF_LINK_HWLOC_STATICALLY)
+    add_dependencies(umf ${UMF_HWLOC_NAME})
+    # On Darwin, link with the IOKit and Foundation frameworks, if they are
+    # available in the system. This is to comply with hwloc which links these,
+    # if available. There is no option to disable these frameworks on Darwin
+    # hwloc builds.
+    if(MACOSX)
+        find_library(IOKIT_LIBRARY IOKit)
+        find_library(FOUNDATION_LIBRARY Foundation)
+        if(IOKIT_LIBRARY OR FOUNDATION_LIBRARY)
+            target_link_libraries(umf PRIVATE ${IOKIT_LIBRARY}
+                                              ${FOUNDATION_LIBRARY})
+        endif()
+    endif()
 endif()
 
-if(UMF_BUILD_CUDA_PROVIDER)
-    set(UMF_COMPILE_DEFINITIONS ${UMF_COMPILE_DEFINITIONS}
-                                "UMF_BUILD_CUDA_PROVIDER=1")
+if(NOT WINDOWS AND UMF_POOL_JEMALLOC_ENABLED)
+    add_dependencies(umf jemalloc)
 endif()
 
 add_library(${PROJECT_NAME}::umf ALIAS umf)
@@ -213,8 +200,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 0000000000..ed84cc9a54
--- /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/base_alloc/base_alloc.c b/src/base_alloc/base_alloc.c
index 209ace7fe3..9f254e6758 100644
--- a/src/base_alloc/base_alloc.c
+++ b/src/base_alloc/base_alloc.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -67,6 +67,7 @@ struct umf_ba_next_pool_t {
 };
 
 #ifndef NDEBUG
+#ifdef UMF_DEVELOPER_MODE
 static void ba_debug_checks(umf_ba_pool_t *pool) {
     // count pools
     size_t n_pools = 1;
@@ -89,6 +90,12 @@ static void ba_debug_checks(umf_ba_pool_t *pool) {
     }
     assert(n_free_chunks == pool->metadata.n_chunks - pool->metadata.n_allocs);
 }
+#else  /* !UMF_DEVELOPER_MODE */
+static inline void ba_debug_checks(umf_ba_pool_t *pool) {
+    // no debug checks in release mode
+    (void)pool; // suppress unused parameter warning
+}
+#endif /* !UMF_DEVELOPER_MODE */
 #endif /* NDEBUG */
 
 // ba_divide_memory_into_chunks - divide given memory into chunks of chunk_size and add them to the free_list
@@ -121,7 +128,7 @@ static void ba_divide_memory_into_chunks(umf_ba_pool_t *pool, void *ptr,
     current_chunk->next = NULL;
     pool->metadata.free_list = ptr; // address of the first chunk
 
-    // mark the memory as unaccessible again
+    // mark the memory as inaccessible again
     utils_annotate_memory_inaccessible(ptr, size);
 }
 
@@ -230,6 +237,7 @@ void *umf_ba_alloc(umf_ba_pool_t *pool) {
     // check if the free list is not empty
     if (pool->metadata.free_list == NULL) {
         LOG_ERR("base_alloc: Free list should not be empty before new alloc");
+        utils_mutex_unlock(&pool->metadata.free_lock);
         return NULL;
     }
 
@@ -303,7 +311,15 @@ void umf_ba_destroy(umf_ba_pool_t *pool) {
 #ifndef NDEBUG
     ba_debug_checks(pool);
     if (pool->metadata.n_allocs) {
-        LOG_ERR("pool->metadata.n_allocs = %zu", pool->metadata.n_allocs);
+#ifdef UMF_DEVELOPER_MODE
+        LOG_FATAL("number of base allocator memory leaks: %zu",
+                  pool->metadata.n_allocs);
+        assert(pool->metadata.n_allocs == 0 &&
+               "memory leaks in base allocator occurred");
+#else
+        LOG_ERR("number of base allocator memory leaks: %zu",
+                pool->metadata.n_allocs);
+#endif
     }
 #endif /* NDEBUG */
 
diff --git a/src/base_alloc/base_alloc_global.c b/src/base_alloc/base_alloc_global.c
index 2aca5d29cf..c7c4e22758 100644
--- a/src/base_alloc/base_alloc_global.c
+++ b/src/base_alloc/base_alloc_global.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -23,6 +23,7 @@
 
 // global base allocator used by all providers and pools
 static UTIL_ONCE_FLAG ba_is_initialized = UTIL_ONCE_FLAG_INIT;
+static bool ba_is_destroyed = false;
 
 #define ALLOC_METADATA_SIZE (sizeof(size_t))
 
@@ -40,6 +41,9 @@ struct base_alloc_t {
 static struct base_alloc_t BASE_ALLOC = {.ac_sizes = ALLOCATION_CLASSES};
 
 void umf_ba_destroy_global(void) {
+    LOG_DEBUG("destroying global base allocator");
+    ba_is_destroyed = true;
+
     for (int i = 0; i < NUM_ALLOCATION_CLASSES; i++) {
         if (BASE_ALLOC.ac[i]) {
             umf_ba_destroy(BASE_ALLOC.ac[i]);
@@ -48,10 +52,12 @@ void umf_ba_destroy_global(void) {
     }
 
     // portable version of "ba_is_initialized = UTIL_ONCE_FLAG_INIT;"
-    static UTIL_ONCE_FLAG is_initialized = UTIL_ONCE_FLAG_INIT;
-    memcpy(&ba_is_initialized, &is_initialized, sizeof(ba_is_initialized));
+    static UTIL_ONCE_FLAG set_once = UTIL_ONCE_FLAG_INIT;
+    memcpy(&ba_is_initialized, &set_once, sizeof(ba_is_initialized));
 }
 
+bool umf_ba_global_is_destroyed(void) { return ba_is_destroyed; }
+
 static void umf_ba_create_global(void) {
     for (int i = 0; i < NUM_ALLOCATION_CLASSES; i++) {
         // allocation classes need to be powers of 2
@@ -66,9 +72,10 @@ static void umf_ba_create_global(void) {
     }
 
     size_t smallestSize = BASE_ALLOC.ac_sizes[0];
-    BASE_ALLOC.smallest_ac_size_log2 = log2Utils(smallestSize);
+    BASE_ALLOC.smallest_ac_size_log2 = utils_msb64(smallestSize);
 
-    LOG_DEBUG("UMF base allocator created");
+    LOG_DEBUG("global base allocator created");
+    ba_is_destroyed = false;
 }
 
 // returns index of the allocation class for a given size
@@ -78,8 +85,8 @@ static int size_to_idx(size_t size) {
     }
 
     int isPowerOf2 = (0 == (size & (size - 1)));
-    int index =
-        (int)(log2Utils(size) + !isPowerOf2 - BASE_ALLOC.smallest_ac_size_log2);
+    int index = (int)(utils_msb64(size) + !isPowerOf2 -
+                      BASE_ALLOC.smallest_ac_size_log2);
 
     assert(index >= 0);
     return index;
@@ -125,7 +132,7 @@ static void *add_metadata_and_align(void *ptr, size_t size, size_t alignment) {
 // return original ptr (the one that has been passed to add_metadata_and_align)
 // along with total allocation size (needed to find proper alloc class
 // in free) and usable size
-static void *get_original_alloc(void *user_ptr, size_t *total_size,
+static void *get_original_alloc(const void *user_ptr, size_t *total_size,
                                 size_t *usable_size) {
     assert(user_ptr);
 
@@ -179,14 +186,28 @@ void *umf_ba_global_aligned_alloc(size_t size, size_t alignment) {
 
     int ac_index = size_to_idx(size);
     if (ac_index >= NUM_ALLOCATION_CLASSES) {
-        return add_metadata_and_align(ba_os_alloc(size), size, alignment);
+        void *ptr = ba_os_alloc(size);
+        if (!ptr) {
+            return NULL;
+        }
+        VALGRIND_DO_MALLOCLIKE_BLOCK(ptr, size, 0, 0);
+        // utils_annotate_memory_undefined(ptr, size); is redundant here,
+        // as mmap() in ba_os_alloc() already marked the memory as undefined
+        return add_metadata_and_align(ptr, size, alignment);
     }
 
     if (!BASE_ALLOC.ac[ac_index]) {
         // if creating ac failed, fall back to os allocation
         LOG_WARN("base_alloc: allocation class not created. Falling "
                  "back to OS memory allocation.");
-        return add_metadata_and_align(ba_os_alloc(size), size, alignment);
+        void *ptr = ba_os_alloc(size);
+        if (!ptr) {
+            return NULL;
+        }
+        VALGRIND_DO_MALLOCLIKE_BLOCK(ptr, size, 0, 0);
+        // utils_annotate_memory_undefined(ptr, size); is redundant here,
+        // as mmap() in ba_os_alloc() already marked the memory as undefined
+        return add_metadata_and_align(ptr, size, alignment);
     }
 
     return add_metadata_and_align(umf_ba_alloc(BASE_ALLOC.ac[ac_index]), size,
@@ -202,17 +223,29 @@ void umf_ba_global_free(void *ptr) {
         return;
     }
 
+    if (ba_is_destroyed) {
+        LOG_WARN(
+            "base_alloc: calling free() after the base allocator is destroyed");
+        return;
+    }
+
     size_t total_size;
     ptr = get_original_alloc(ptr, &total_size, NULL);
 
     int ac_index = size_to_idx(total_size);
     if (ac_index >= NUM_ALLOCATION_CLASSES) {
+        VALGRIND_DO_FREELIKE_BLOCK(ptr, 0);
+        // utils_annotate_memory_inaccessible(ptr, total_size); is redundant here,
+        // as munmap() in ba_os_free() will make it inaccessible anyway
         ba_os_free(ptr, total_size);
         return;
     }
 
     if (!BASE_ALLOC.ac[ac_index]) {
         // if creating ac failed, memory must have been allocated by os
+        VALGRIND_DO_FREELIKE_BLOCK(ptr, 0);
+        // utils_annotate_memory_inaccessible(ptr, total_size); is redundant here,
+        // as munmap() in ba_os_free() will make it inaccessible anyway
         ba_os_free(ptr, total_size);
         return;
     }
@@ -222,7 +255,7 @@ void umf_ba_global_free(void *ptr) {
     umf_ba_free(BASE_ALLOC.ac[ac_index], ptr);
 }
 
-size_t umf_ba_global_malloc_usable_size(void *ptr) {
+size_t umf_ba_global_malloc_usable_size(const void *ptr) {
     if (!ptr) {
         return 0;
     }
@@ -232,3 +265,19 @@ size_t umf_ba_global_malloc_usable_size(void *ptr) {
 
     return usable_size;
 }
+
+char *umf_ba_global_strdup(const char *s) {
+    if (!s) {
+        return NULL;
+    }
+
+    size_t len = strlen(s);
+
+    char *ptr = umf_ba_global_alloc(len + 1);
+    if (!ptr) {
+        return NULL;
+    }
+
+    memcpy(ptr, s, len + 1);
+    return ptr;
+}
diff --git a/src/base_alloc/base_alloc_global.h b/src/base_alloc/base_alloc_global.h
index ad7f12ce54..71216ec6cf 100644
--- a/src/base_alloc/base_alloc_global.h
+++ b/src/base_alloc/base_alloc_global.h
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -8,6 +8,8 @@
 #ifndef UMF_BASE_ALLOC_GLOBAL_H
 #define UMF_BASE_ALLOC_GLOBAL_H 1
 
+#include <stdbool.h>
+
 #include "base_alloc.h"
 
 #ifdef __cplusplus
@@ -17,8 +19,10 @@ extern "C" {
 void *umf_ba_global_alloc(size_t size);
 void umf_ba_global_free(void *ptr);
 void umf_ba_destroy_global(void);
-size_t umf_ba_global_malloc_usable_size(void *ptr);
+bool umf_ba_global_is_destroyed(void);
+size_t umf_ba_global_malloc_usable_size(const void *ptr);
 void *umf_ba_global_aligned_alloc(size_t size, size_t alignment);
+char *umf_ba_global_strdup(const char *s);
 
 #ifdef __cplusplus
 }
diff --git a/src/base_alloc/base_alloc_linear.c b/src/base_alloc/base_alloc_linear.c
index a35a6c2431..0554b94559 100644
--- a/src/base_alloc/base_alloc_linear.c
+++ b/src/base_alloc/base_alloc_linear.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -13,6 +13,7 @@
 #include "utils_common.h"
 #include "utils_concurrency.h"
 #include "utils_log.h"
+#include "utils_sanitizers.h"
 
 #ifndef NDEBUG
 #define _DEBUG_EXECUTE(expression) DO_WHILE_EXPRS(expression)
@@ -184,6 +185,7 @@ void *umf_ba_linear_alloc(umf_ba_linear_pool_t *pool, size_t size) {
     }
     _DEBUG_EXECUTE(pool->metadata.global_n_allocs++);
     _DEBUG_EXECUTE(ba_debug_checks(pool));
+    VALGRIND_DO_MALLOCLIKE_BLOCK(ptr, aligned_size, 0, 0);
     utils_mutex_unlock(&pool->metadata.lock);
 
     return ptr;
@@ -206,6 +208,7 @@ int umf_ba_linear_free(umf_ba_linear_pool_t *pool, void *ptr) {
     if (pool_contains_ptr(pool, pool->metadata.pool_size, pool->data, ptr)) {
         pool->metadata.pool_n_allocs--;
         _DEBUG_EXECUTE(pool->metadata.global_n_allocs--);
+        VALGRIND_DO_FREELIKE_BLOCK(ptr, 0);
         size_t page_size = ba_os_get_page_size();
         if ((pool->metadata.pool_n_allocs == 0) && pool->next_pool &&
             (pool->metadata.pool_size > page_size)) {
@@ -241,6 +244,7 @@ int umf_ba_linear_free(umf_ba_linear_pool_t *pool, void *ptr) {
             }
             _DEBUG_EXECUTE(ba_debug_checks(pool));
             utils_mutex_unlock(&pool->metadata.lock);
+            VALGRIND_DO_FREELIKE_BLOCK(ptr, 0);
             return 0;
         }
         prev_pool = next_pool;
diff --git a/src/base_alloc/base_alloc_linux.c b/src/base_alloc/base_alloc_linux.c
index 260eec5aac..9b1dc63fe0 100644
--- a/src/base_alloc/base_alloc_linux.c
+++ b/src/base_alloc/base_alloc_linux.c
@@ -1,26 +1,22 @@
 /*
- * 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
 */
 
 #include <assert.h>
-#include <stdio.h>
 #include <sys/mman.h>
-#include <sys/syscall.h>
 #include <unistd.h>
 
-#include "base_alloc.h"
-#include "base_alloc_global.h"
 #include "utils_concurrency.h"
 
 static UTIL_ONCE_FLAG Page_size_is_initialized = UTIL_ONCE_FLAG_INIT;
 static size_t Page_size;
 
 void *ba_os_alloc(size_t size) {
-    void *ptr = mmap(NULL, size, PROT_READ | PROT_WRITE,
-                     MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    void *ptr = utils_mmap(NULL, size, PROT_READ | PROT_WRITE,
+                           MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
     // this should be unnecessary but pairs of mmap/munmap do not reset
     // asan's user-poisoning flags, leading to invalid error reports
     // Bug 81619: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81619
@@ -29,7 +25,7 @@ void *ba_os_alloc(size_t size) {
 }
 
 void ba_os_free(void *ptr, size_t size) {
-    int ret = munmap(ptr, size);
+    int ret = utils_munmap(ptr, size);
     assert(ret == 0);
     (void)ret; // unused
 }
diff --git a/src/coarse/CMakeLists.txt b/src/coarse/CMakeLists.txt
new file mode 100644
index 0000000000..32465b4e4f
--- /dev/null
+++ b/src/coarse/CMakeLists.txt
@@ -0,0 +1,24 @@
+# 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
+
+include(${UMF_CMAKE_SOURCE_DIR}/cmake/helpers.cmake)
+
+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 umf_coarse
+    TYPE STATIC
+    SRCS ${UMF_COARSE_SOURCES}
+    LIBS ${UMF_COARSE_LIBS})
+
+target_include_directories(
+    umf_coarse
+    PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/coarse
+            ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc
+            ${UMF_CMAKE_SOURCE_DIR}/src/ravl)
+
+if(NOT UMF_BUILD_SHARED_LIBRARY)
+    install(TARGETS umf_coarse EXPORT ${PROJECT_NAME}-targets)
+endif()
diff --git a/src/coarse/coarse.c b/src/coarse/coarse.c
new file mode 100644
index 0000000000..a161ea5753
--- /dev/null
+++ b/src/coarse/coarse.c
@@ -0,0 +1,1415 @@
+/*
+ * 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
+*/
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <umf.h>
+
+#include "base_alloc_global.h"
+#include "coarse.h"
+#include "libumf.h"
+#include "ravl.h"
+#include "utils_common.h"
+#include "utils_concurrency.h"
+#include "utils_log.h"
+
+#ifdef _WIN32
+UTIL_ONCE_FLAG Log_initialized = UTIL_ONCE_FLAG_INIT;
+#else
+void __attribute__((constructor)) coarse_init(void) { utils_log_init(); }
+void __attribute__((destructor)) coarse_destroy(void) {}
+#endif /* _WIN32 */
+
+typedef struct coarse_t {
+    // handle of the memory provider
+    void *provider;
+
+    // coarse callbacks
+    coarse_callbacks_t cb;
+
+    // memory allocation strategy
+    coarse_strategy_t allocation_strategy;
+
+    // page size of the memory provider
+    size_t page_size;
+
+    // all_blocks - tree of all blocks - sorted by an address of data
+    struct ravl *all_blocks;
+
+    // free_blocks - tree of free blocks - sorted by a size of data,
+    // each node contains a pointer (ravl_free_blocks_head_t)
+    // to the head of the list of free blocks of the same size
+    struct ravl *free_blocks;
+
+    struct utils_mutex_t lock;
+
+    // statistics
+    size_t used_size;
+    size_t alloc_size;
+} coarse_t;
+
+typedef struct ravl_node ravl_node_t;
+
+typedef enum check_free_blocks_t {
+    CHECK_ONLY_THE_FIRST_BLOCK = 0,
+    CHECK_ALL_BLOCKS_OF_SIZE,
+} check_free_blocks_t;
+
+typedef struct block_t {
+    size_t size;
+    unsigned char *data;
+    bool used;
+
+    // Node in the list of free blocks of the same size pointing to this block.
+    // The list is located in the (coarse->free_blocks) RAVL tree.
+    struct ravl_free_blocks_elem_t *free_list_ptr;
+} block_t;
+
+// A general node in a RAVL tree.
+// 1) coarse->all_blocks RAVL tree (tree of all blocks - sorted by an address of data):
+//    key   - pointer (block_t->data) to the beginning of the block data
+//    value - pointer (block_t) to the block of the allocation
+// 2) coarse->free_blocks RAVL tree (tree of free blocks - sorted by a size of data):
+//    key   - size of the allocation (block_t->size)
+//    value - pointer (ravl_free_blocks_head_t) to the head of the list of free blocks of the same size
+typedef struct ravl_data_t {
+    uintptr_t key;
+    void *value;
+} ravl_data_t;
+
+// The head of the list of free blocks of the same size.
+typedef struct ravl_free_blocks_head_t {
+    struct ravl_free_blocks_elem_t *head;
+} ravl_free_blocks_head_t;
+
+// The node of the list of free blocks of the same size
+typedef struct ravl_free_blocks_elem_t {
+    struct block_t *block;
+    struct ravl_free_blocks_elem_t *next;
+    struct ravl_free_blocks_elem_t *prev;
+} ravl_free_blocks_elem_t;
+
+// The compare function of a RAVL tree
+static int coarse_ravl_comp(const void *lhs, const void *rhs) {
+    const ravl_data_t *lhs_ravl = (const ravl_data_t *)lhs;
+    const ravl_data_t *rhs_ravl = (const ravl_data_t *)rhs;
+
+    if (lhs_ravl->key < rhs_ravl->key) {
+        return -1;
+    }
+
+    if (lhs_ravl->key > rhs_ravl->key) {
+        return 1;
+    }
+
+    // lhs_ravl->key == rhs_ravl->key
+    return 0;
+}
+
+static inline block_t *get_node_block(ravl_node_t *node) {
+    ravl_data_t *node_data = ravl_data(node);
+    assert(node_data);
+    assert(node_data->value);
+    return node_data->value;
+}
+
+static inline ravl_node_t *get_node_prev(ravl_node_t *node) {
+    return ravl_node_predecessor(node);
+}
+
+static inline ravl_node_t *get_node_next(ravl_node_t *node) {
+    return ravl_node_successor(node);
+}
+
+#if !defined(NDEBUG) && defined(UMF_DEVELOPER_MODE)
+static block_t *get_block_prev(ravl_node_t *node) {
+    ravl_node_t *ravl_prev = ravl_node_predecessor(node);
+    if (!ravl_prev) {
+        return NULL;
+    }
+
+    return get_node_block(ravl_prev);
+}
+
+static block_t *get_block_next(ravl_node_t *node) {
+    ravl_node_t *ravl_next = ravl_node_successor(node);
+    if (!ravl_next) {
+        return NULL;
+    }
+
+    return get_node_block(ravl_next);
+}
+#endif /* !defined(NDEBUG) && defined(UMF_DEVELOPER_MODE) */
+
+// The functions "coarse_ravl_*" handles the coarse->all_blocks list of blocks
+// sorted by a pointer (block_t->data) to the beginning of the block data.
+//
+// coarse_ravl_add_new - allocate and add a new block to the tree
+// and link this block to the next and the previous one.
+static block_t *coarse_ravl_add_new(struct ravl *rtree, unsigned char *data,
+                                    size_t size, ravl_node_t **node) {
+    assert(rtree);
+    assert(data);
+    assert(size);
+
+    // TODO add valgrind annotations
+    block_t *block = umf_ba_global_alloc(sizeof(*block));
+    if (block == NULL) {
+        return NULL;
+    }
+
+    block->data = data;
+    block->size = size;
+    block->free_list_ptr = NULL;
+
+    ravl_data_t rdata = {(uintptr_t)block->data, block};
+    assert(NULL == ravl_find(rtree, &data, RAVL_PREDICATE_EQUAL));
+    int ret = ravl_emplace_copy(rtree, &rdata);
+    if (ret) {
+        umf_ba_global_free(block);
+        return NULL;
+    }
+
+    ravl_node_t *new_node = ravl_find(rtree, &rdata, RAVL_PREDICATE_EQUAL);
+    assert(NULL != new_node);
+
+    if (node) {
+        *node = new_node;
+    }
+
+    return block;
+}
+
+// coarse_ravl_find_node - find the node in the tree
+static ravl_node_t *coarse_ravl_find_node(struct ravl *rtree, void *ptr) {
+    ravl_data_t data = {(uintptr_t)ptr, NULL};
+    return ravl_find(rtree, &data, RAVL_PREDICATE_EQUAL);
+}
+
+// coarse_ravl_rm - remove the block from the tree
+static block_t *coarse_ravl_rm(struct ravl *rtree, void *ptr) {
+    ravl_data_t data = {(uintptr_t)ptr, NULL};
+    ravl_node_t *node;
+    node = ravl_find(rtree, &data, RAVL_PREDICATE_EQUAL);
+    if (node) {
+        ravl_data_t *node_data = ravl_data(node);
+        assert(node_data);
+        block_t *block = node_data->value;
+        assert(block);
+        ravl_remove(rtree, node);
+        assert(NULL == ravl_find(rtree, &data, RAVL_PREDICATE_EQUAL));
+        return block;
+    }
+    return NULL;
+}
+
+// The functions "node_list_*" handle lists of free blocks of the same size.
+// The heads (ravl_free_blocks_head_t) of those lists are stored in nodes of
+// the coarse->free_blocks RAVL tree.
+//
+// node_list_add - add a free block to the list of free blocks of the same size
+static ravl_free_blocks_elem_t *
+node_list_add(ravl_free_blocks_head_t *head_node, struct block_t *block) {
+    assert(head_node);
+    assert(block);
+
+    ravl_free_blocks_elem_t *node = umf_ba_global_alloc(sizeof(*node));
+    if (node == NULL) {
+        return NULL;
+    }
+
+    if (head_node->head) {
+        head_node->head->prev = node;
+    }
+
+    node->block = block;
+    node->next = head_node->head;
+    node->prev = NULL;
+    head_node->head = node;
+
+    return node;
+}
+
+// node_list_rm - remove the given free block from the list of free blocks of the same size
+static block_t *node_list_rm(ravl_free_blocks_head_t *head_node,
+                             ravl_free_blocks_elem_t *node) {
+    assert(head_node);
+    assert(node);
+    assert(head_node->head);
+
+    if (node == head_node->head) {
+        assert(node->prev == NULL);
+        head_node->head = node->next;
+    }
+
+    ravl_free_blocks_elem_t *node_next = node->next;
+    ravl_free_blocks_elem_t *node_prev = node->prev;
+    if (node_next) {
+        node_next->prev = node_prev;
+    }
+
+    if (node_prev) {
+        node_prev->next = node_next;
+    }
+
+    struct block_t *block = node->block;
+    block->free_list_ptr = NULL;
+    umf_ba_global_free(node);
+
+    return block;
+}
+
+// node_list_rm_first - remove the first free block from the list of free blocks of the same size only if it can be properly aligned
+static block_t *node_list_rm_first(ravl_free_blocks_head_t *head_node,
+                                   size_t alignment) {
+    assert(head_node);
+    assert(head_node->head);
+
+    ravl_free_blocks_elem_t *node = head_node->head;
+    assert(node->prev == NULL);
+    struct block_t *block = node->block;
+
+    if (IS_NOT_ALIGNED(((uintptr_t)block->data), alignment)) {
+        return NULL;
+    }
+
+    if (node->next) {
+        node->next->prev = NULL;
+    }
+
+    head_node->head = node->next;
+    block->free_list_ptr = NULL;
+    umf_ba_global_free(node);
+
+    return block;
+}
+
+// node_list_rm_with_alignment - remove the first free block with the correct alignment from the list of free blocks of the same size
+static block_t *node_list_rm_with_alignment(ravl_free_blocks_head_t *head_node,
+                                            size_t alignment) {
+    assert(head_node);
+    assert(head_node->head);
+
+    assert(((ravl_free_blocks_elem_t *)head_node->head)->prev == NULL);
+
+    ravl_free_blocks_elem_t *node;
+    for (node = head_node->head; node != NULL; node = node->next) {
+        if (IS_ALIGNED(((uintptr_t)node->block->data), alignment)) {
+            return node_list_rm(head_node, node);
+        }
+    }
+
+    return NULL;
+}
+
+// The functions "free_blocks_*" handle the coarse->free_blocks RAVL tree
+// sorted by a size of the allocation (block_t->size).
+// This is a tree of heads (ravl_free_blocks_head_t) of lists of free blocks of the same size.
+//
+// free_blocks_add - add a free block to the list of free blocks of the same size
+static int free_blocks_add(struct ravl *free_blocks, block_t *block) {
+    ravl_free_blocks_head_t *head_node = NULL;
+    int rv;
+
+    ravl_data_t head_node_data = {(uintptr_t)block->size, NULL};
+    ravl_node_t *node;
+    node = ravl_find(free_blocks, &head_node_data, RAVL_PREDICATE_EQUAL);
+    if (node) {
+        ravl_data_t *node_data = ravl_data(node);
+        assert(node_data);
+        head_node = node_data->value;
+        assert(head_node);
+    } else { // no head_node
+        head_node = umf_ba_global_alloc(sizeof(*head_node));
+        if (!head_node) {
+            return -1;
+        }
+
+        head_node->head = NULL;
+
+        ravl_data_t data = {(uintptr_t)block->size, head_node};
+        rv = ravl_emplace_copy(free_blocks, &data);
+        if (rv) {
+            umf_ba_global_free(head_node);
+            return -1;
+        }
+    }
+
+    block->free_list_ptr = node_list_add(head_node, block);
+    if (!block->free_list_ptr) {
+        return -1; // out of memory
+    }
+
+    assert(block->free_list_ptr->block->size == block->size);
+
+    return 0;
+}
+
+// free_blocks_rm_ge - remove the first free block of a size greater or equal to the given size only if it can be properly aligned
+// If it was the last block, the head node is freed and removed from the tree.
+// It is used during memory allocation (looking for a free block).
+static block_t *free_blocks_rm_ge(struct ravl *free_blocks, size_t size,
+                                  size_t alignment,
+                                  check_free_blocks_t check_blocks) {
+    ravl_data_t data = {(uintptr_t)size, NULL};
+    ravl_node_t *node;
+    node = ravl_find(free_blocks, &data, RAVL_PREDICATE_GREATER_EQUAL);
+    if (!node) {
+        return NULL;
+    }
+
+    ravl_data_t *node_data = ravl_data(node);
+    assert(node_data);
+    assert(node_data->key >= size);
+
+    ravl_free_blocks_head_t *head_node = node_data->value;
+    assert(head_node);
+
+    block_t *block = NULL;
+    switch (check_blocks) {
+    case CHECK_ONLY_THE_FIRST_BLOCK:
+        block = node_list_rm_first(head_node, alignment);
+        break;
+    case CHECK_ALL_BLOCKS_OF_SIZE:
+        block = node_list_rm_with_alignment(head_node, alignment);
+        break;
+    }
+
+    if (head_node->head == NULL) {
+        umf_ba_global_free(head_node);
+        ravl_remove(free_blocks, node);
+    }
+
+    return block;
+}
+
+// free_blocks_rm_node - remove the free block pointed by the given node.
+// If it was the last block, the head node is freed and removed from the tree.
+// It is used during merging free blocks and destroying the coarse->free_blocks tree.
+static block_t *free_blocks_rm_node(struct ravl *free_blocks,
+                                    ravl_free_blocks_elem_t *node) {
+    assert(free_blocks);
+    assert(node);
+    size_t size = node->block->size;
+    ravl_data_t data = {(uintptr_t)size, NULL};
+    ravl_node_t *ravl_node;
+    ravl_node = ravl_find(free_blocks, &data, RAVL_PREDICATE_EQUAL);
+    assert(ravl_node);
+
+    ravl_data_t *node_data = ravl_data(ravl_node);
+    assert(node_data);
+    assert(node_data->key == size);
+
+    ravl_free_blocks_head_t *head_node = node_data->value;
+    assert(head_node);
+
+    block_t *block = node_list_rm(head_node, node);
+
+    if (head_node->head == NULL) {
+        umf_ba_global_free(head_node);
+        ravl_remove(free_blocks, ravl_node);
+    }
+
+    return block;
+}
+
+// user_block_merge - merge two blocks from one of two lists of user blocks: all_blocks or free_blocks
+static umf_result_t user_block_merge(coarse_t *coarse, ravl_node_t *node1,
+                                     ravl_node_t *node2, bool used,
+                                     ravl_node_t **merged_node) {
+    assert(node1);
+    assert(node2);
+    assert(node1 == get_node_prev(node2));
+    assert(node2 == get_node_next(node1));
+    assert(merged_node);
+
+    *merged_node = NULL;
+
+    struct ravl *all_blocks = coarse->all_blocks;
+    struct ravl *free_blocks = coarse->free_blocks;
+
+    block_t *block1 = get_node_block(node1);
+    block_t *block2 = get_node_block(node2);
+    assert(block1->data < block2->data);
+
+    bool same_used = ((block1->used == used) && (block2->used == used));
+    bool contiguous_data = (block1->data + block1->size == block2->data);
+
+    // check if blocks can be merged
+    if (!same_used || !contiguous_data) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    // check if blocks can be merged
+    umf_result_t umf_result =
+        coarse->cb.merge(coarse->provider, block1->data, block2->data,
+                         block1->size + block2->size);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("coarse_merge_cb(lowPtr=%p, highPtr=%p, totalSize=%zu) failed",
+                (void *)block1->data, (void *)block2->data,
+                block1->size + block2->size);
+        return umf_result;
+    }
+
+    if (block1->free_list_ptr) {
+        free_blocks_rm_node(free_blocks, block1->free_list_ptr);
+        block1->free_list_ptr = NULL;
+    }
+
+    if (block2->free_list_ptr) {
+        free_blocks_rm_node(free_blocks, block2->free_list_ptr);
+        block2->free_list_ptr = NULL;
+    }
+
+    // update the size
+    block1->size += block2->size;
+
+    block_t *block_rm = coarse_ravl_rm(all_blocks, block2->data);
+    assert(block_rm == block2);
+    (void)block_rm; // WA for unused variable error
+    umf_ba_global_free(block2);
+
+    *merged_node = node1;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+// free_block_merge_with_prev - merge the given free block
+// with the previous one if both are unused and have continuous data.
+// Remove the merged block from the tree of free blocks.
+static ravl_node_t *free_block_merge_with_prev(coarse_t *coarse,
+                                               ravl_node_t *node) {
+    ravl_node_t *node_prev = get_node_prev(node);
+    if (!node_prev) {
+        return node;
+    }
+
+    ravl_node_t *merged_node = NULL;
+    umf_result_t umf_result =
+        user_block_merge(coarse, node_prev, node, false, &merged_node);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        return node;
+    }
+
+    assert(merged_node != NULL);
+
+    return merged_node;
+}
+
+// free_block_merge_with_next - merge the given free block
+// with the next one if both are unused and have continuous data.
+// Remove the merged block from the tree of free blocks.
+static ravl_node_t *free_block_merge_with_next(coarse_t *coarse,
+                                               ravl_node_t *node) {
+    ravl_node_t *node_next = get_node_next(node);
+    if (!node_next) {
+        return node;
+    }
+
+    ravl_node_t *merged_node = NULL;
+    umf_result_t umf_result =
+        user_block_merge(coarse, node, node_next, false, &merged_node);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        return node;
+    }
+
+    assert(merged_node != NULL);
+
+    return merged_node;
+}
+
+#ifndef NDEBUG // begin of DEBUG code
+#ifdef UMF_DEVELOPER_MODE
+
+typedef struct debug_cb_args_t {
+    coarse_t *provider;
+    size_t sum_used;
+    size_t sum_blocks_size;
+    size_t num_all_blocks;
+    size_t num_free_blocks;
+} debug_cb_args_t;
+
+static void debug_verify_all_blocks_cb(void *data, void *arg) {
+    assert(data);
+    assert(arg);
+
+    ravl_data_t *node_data = data;
+    block_t *block = node_data->value;
+    assert(block);
+
+    debug_cb_args_t *cb_args = (debug_cb_args_t *)arg;
+    coarse_t *provider = cb_args->provider;
+
+    ravl_node_t *node =
+        ravl_find(provider->all_blocks, data, RAVL_PREDICATE_EQUAL);
+    assert(node);
+
+    block_t *block_next = get_block_next(node);
+    block_t *block_prev = get_block_prev(node);
+
+    cb_args->num_all_blocks++;
+    if (!block->used) {
+        cb_args->num_free_blocks++;
+    }
+
+    assert(block->data);
+    assert(block->size > 0);
+
+    // data addresses in the list are in ascending order
+    if (block_prev) {
+        assert(block_prev->data < block->data);
+    }
+
+    if (block_next) {
+        assert(block->data < block_next->data);
+    }
+
+    // two block's data should not overlap
+    if (block_next) {
+        assert((block->data + block->size) <= block_next->data);
+    }
+
+    cb_args->sum_blocks_size += block->size;
+    if (block->used) {
+        cb_args->sum_used += block->size;
+    }
+}
+
+static umf_result_t coarse_get_stats_no_lock(coarse_t *coarse,
+                                             coarse_stats_t *stats);
+
+static bool debug_check(coarse_t *provider) {
+    assert(provider);
+
+    coarse_stats_t stats = {0};
+    coarse_get_stats_no_lock(provider, &stats);
+
+    debug_cb_args_t cb_args = {0};
+    cb_args.provider = provider;
+
+    // verify the all_blocks list
+    ravl_foreach(provider->all_blocks, debug_verify_all_blocks_cb, &cb_args);
+
+    assert(cb_args.num_all_blocks == stats.num_all_blocks);
+    assert(cb_args.num_free_blocks == stats.num_free_blocks);
+    assert(cb_args.sum_used == provider->used_size);
+    assert(cb_args.sum_blocks_size == provider->alloc_size);
+    assert(provider->alloc_size >= provider->used_size);
+
+    return true;
+}
+#else               /* !UMF_DEVELOPER_MODE */
+static inline bool debug_check(coarse_t *provider) {
+    (void)provider; // suppress unused variable warning
+    return true;
+}
+#endif              /* !UMF_DEVELOPER_MODE */
+#endif /* NDEBUG */ // end of DEBUG code
+
+static umf_result_t coarse_add_used_block(coarse_t *coarse, void *addr,
+                                          size_t size) {
+    block_t *new_block =
+        coarse_ravl_add_new(coarse->all_blocks, addr, size, NULL);
+    if (new_block == NULL) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    new_block->used = true;
+    coarse->alloc_size += size;
+    coarse->used_size += size;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t coarse_add_free_block(coarse_t *coarse, void *addr,
+                                          size_t size, block_t **free_block) {
+    *free_block = NULL;
+
+    block_t *new_block =
+        coarse_ravl_add_new(coarse->all_blocks, addr, size, NULL);
+    if (new_block == NULL) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    new_block->used = false;
+    coarse->alloc_size += size;
+
+    *free_block = new_block;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static void coarse_ravl_cb_rm_all_blocks_node(void *data, void *arg) {
+    assert(data);
+    assert(arg);
+
+    coarse_t *coarse = (struct coarse_t *)arg;
+    ravl_data_t *node_data = data;
+    block_t *block = node_data->value;
+    assert(block);
+
+    if (block->used) {
+#ifndef NDEBUG
+        LOG_WARN("not freed block (addr: %p, size: %zu)", (void *)block->data,
+                 block->size);
+#endif
+        assert(coarse->used_size >= block->size);
+        coarse->used_size -= block->size;
+    }
+
+    if (block->free_list_ptr) {
+        free_blocks_rm_node(coarse->free_blocks, block->free_list_ptr);
+    }
+
+    if (coarse->cb.free) {
+        coarse->cb.free(coarse->provider, block->data, block->size);
+    }
+
+    assert(coarse->alloc_size >= block->size);
+    coarse->alloc_size -= block->size;
+
+    umf_ba_global_free(block);
+}
+
+static umf_result_t can_provider_split(coarse_t *coarse, void *ptr,
+                                       size_t totalSize, size_t firstSize) {
+    // check if the block can be split
+    umf_result_t umf_result =
+        coarse->cb.split(coarse->provider, ptr, totalSize, firstSize);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_ERR(
+            "coarse_split_cb->(ptr=%p, totalSize = %zu = (%zu + %zu)) failed",
+            ptr, totalSize, firstSize, totalSize - firstSize);
+    }
+
+    return umf_result;
+}
+
+static umf_result_t create_aligned_block(coarse_t *coarse, size_t orig_size,
+                                         size_t alignment, block_t **current) {
+    (void)orig_size; // unused in the Release version
+    int rv;
+
+    block_t *curr = *current;
+
+    // In case of non-zero alignment create an aligned block what would be further used.
+    uintptr_t orig_data = (uintptr_t)curr->data;
+    uintptr_t aligned_data = ALIGN_UP(orig_data, alignment);
+    size_t padding = aligned_data - orig_data;
+    if (alignment > 0 && padding > 0) {
+        // check if block can be split by the upstream provider
+        umf_result_t umf_result =
+            can_provider_split(coarse, curr->data, curr->size, padding);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            return umf_result;
+        }
+
+        block_t *aligned_block =
+            coarse_ravl_add_new(coarse->all_blocks, curr->data + padding,
+                                curr->size - padding, NULL);
+        if (aligned_block == NULL) {
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        }
+
+        curr->used = false;
+        curr->size = padding;
+
+        rv = free_blocks_add(coarse->free_blocks, curr);
+        if (rv) {
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        }
+
+        // use aligned block
+        *current = aligned_block;
+        assert((*current)->size >= orig_size);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+// Split the current block and put the new block after the one that we use.
+static umf_result_t split_current_block(coarse_t *coarse, block_t *curr,
+                                        size_t size) {
+
+    // check if block can be split by the upstream provider
+    umf_result_t umf_result =
+        can_provider_split(coarse, curr->data, curr->size, size);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        return umf_result;
+    }
+
+    ravl_node_t *new_node = NULL;
+
+    block_t *new_block = coarse_ravl_add_new(
+        coarse->all_blocks, curr->data + size, curr->size - size, &new_node);
+    if (new_block == NULL) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    new_block->used = false;
+
+    int rv = free_blocks_add(coarse->free_blocks, get_node_block(new_node));
+    if (rv) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static block_t *find_free_block(struct ravl *free_blocks, size_t size,
+                                size_t alignment,
+                                coarse_strategy_t allocation_strategy) {
+    block_t *block;
+    size_t new_size = size + alignment;
+
+    switch (allocation_strategy) {
+    case UMF_COARSE_MEMORY_STRATEGY_FASTEST:
+        // Always allocate a free block of the (size + alignment) size
+        // and later cut out the properly aligned part leaving two remaining parts.
+        if (new_size < size) {
+            LOG_ERR("arithmetic overflow (size + alignment)");
+            return NULL;
+        }
+
+        return free_blocks_rm_ge(free_blocks, new_size, 0,
+                                 CHECK_ONLY_THE_FIRST_BLOCK);
+
+    case UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE:
+        // First check if the first free block of the 'size' size has the correct alignment.
+        block = free_blocks_rm_ge(free_blocks, size, alignment,
+                                  CHECK_ONLY_THE_FIRST_BLOCK);
+        if (block) {
+            return block;
+        }
+
+        if (new_size < size) {
+            LOG_ERR("arithmetic overflow (size + alignment)");
+            return NULL;
+        }
+
+        // If not, use the `UMF_COARSE_MEMORY_STRATEGY_FASTEST` strategy.
+        return free_blocks_rm_ge(free_blocks, new_size, 0,
+                                 CHECK_ONLY_THE_FIRST_BLOCK);
+
+    case UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE:
+        // First look through all free blocks of the 'size' size
+        // and choose the first one with the correct alignment.
+        block = free_blocks_rm_ge(free_blocks, size, alignment,
+                                  CHECK_ALL_BLOCKS_OF_SIZE);
+        if (block) {
+            return block;
+        }
+
+        if (new_size < size) {
+            LOG_ERR("arithmetic overflow (size + alignment)");
+            return NULL;
+        }
+
+        // If none of them had the correct alignment,
+        // use the `UMF_COARSE_MEMORY_STRATEGY_FASTEST` strategy.
+        return free_blocks_rm_ge(free_blocks, new_size, 0,
+                                 CHECK_ONLY_THE_FIRST_BLOCK);
+    }
+
+    return NULL;
+}
+
+static int free_blocks_re_add(coarse_t *coarse, block_t *block) {
+    assert(coarse);
+
+    ravl_node_t *node = coarse_ravl_find_node(coarse->all_blocks, block->data);
+    assert(node);
+
+    // merge with prev and/or next block if they are unused and have continuous data
+    node = free_block_merge_with_prev(coarse, node);
+    node = free_block_merge_with_next(coarse, node);
+
+    return free_blocks_add(coarse->free_blocks, get_node_block(node));
+}
+
+static void ravl_cb_count(void *data, void *arg) {
+    assert(arg);
+    (void)data; // unused
+
+    size_t *num_all_blocks = arg;
+    (*num_all_blocks)++;
+}
+
+static void ravl_cb_count_free(void *data, void *arg) {
+    assert(data);
+    assert(arg);
+
+    ravl_data_t *node_data = data;
+    assert(node_data);
+    ravl_free_blocks_head_t *head_node = node_data->value;
+    assert(head_node);
+    struct ravl_free_blocks_elem_t *free_block = head_node->head;
+    assert(free_block);
+
+    size_t *num_all_blocks = arg;
+    while (free_block) {
+        (*num_all_blocks)++;
+        free_block = free_block->next;
+    }
+}
+
+static umf_result_t coarse_get_stats_no_lock(coarse_t *coarse,
+                                             coarse_stats_t *stats) {
+    assert(coarse);
+
+    size_t num_all_blocks = 0;
+    ravl_foreach(coarse->all_blocks, ravl_cb_count, &num_all_blocks);
+
+    size_t num_free_blocks = 0;
+    ravl_foreach(coarse->free_blocks, ravl_cb_count_free, &num_free_blocks);
+
+    stats->alloc_size = coarse->alloc_size;
+    stats->used_size = coarse->used_size;
+    stats->num_all_blocks = num_all_blocks;
+    stats->num_free_blocks = num_free_blocks;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+// PUBLIC API
+
+umf_result_t coarse_new(coarse_params_t *coarse_params, coarse_t **pcoarse) {
+#ifdef _WIN32
+    utils_init_once(&Log_initialized, utils_log_init);
+#endif /* _WIN32 */
+
+    if (coarse_params == NULL || pcoarse == NULL) {
+        LOG_ERR("coarse parameters or handle is missing");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (!coarse_params->provider) {
+        LOG_ERR("memory provider is not set");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (!coarse_params->page_size) {
+        LOG_ERR("page size of the memory provider is not set");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (!coarse_params->cb.split) {
+        LOG_ERR("coarse split callback is not set");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (!coarse_params->cb.merge) {
+        LOG_ERR("coarse merge callback is not set");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    // alloc() and free() callbacks are optional
+
+    coarse_t *coarse = umf_ba_global_alloc(sizeof(*coarse));
+    if (!coarse) {
+        LOG_ERR("out of the host memory");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    memset(coarse, 0, sizeof(*coarse));
+
+    coarse->provider = coarse_params->provider;
+    coarse->page_size = coarse_params->page_size;
+    coarse->cb = coarse_params->cb;
+    coarse->allocation_strategy = coarse_params->allocation_strategy;
+
+    umf_result_t umf_result = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+
+    coarse->free_blocks = ravl_new_sized(coarse_ravl_comp, sizeof(ravl_data_t));
+    if (coarse->free_blocks == NULL) {
+        LOG_ERR("out of the host memory");
+        goto err_free_coarse;
+    }
+
+    coarse->all_blocks = ravl_new_sized(coarse_ravl_comp, sizeof(ravl_data_t));
+    if (coarse->all_blocks == NULL) {
+        LOG_ERR("out of the host memory");
+        goto err_delete_ravl_free_blocks;
+    }
+
+    coarse->alloc_size = 0;
+    coarse->used_size = 0;
+
+    umf_result = UMF_RESULT_ERROR_UNKNOWN;
+
+    if (utils_mutex_init(&coarse->lock) == NULL) {
+        LOG_ERR("lock initialization failed");
+        goto err_delete_ravl_all_blocks;
+    }
+
+    assert(coarse->used_size == 0);
+    assert(coarse->alloc_size == 0);
+    assert(debug_check(coarse));
+
+    *pcoarse = coarse;
+
+    return UMF_RESULT_SUCCESS;
+
+err_delete_ravl_all_blocks:
+    ravl_delete(coarse->all_blocks);
+err_delete_ravl_free_blocks:
+    ravl_delete(coarse->free_blocks);
+err_free_coarse:
+    umf_ba_global_free(coarse);
+    return umf_result;
+}
+
+void coarse_delete(coarse_t *coarse) {
+    if (coarse == NULL) {
+        LOG_ERR("coarse handle is missing");
+        return;
+    }
+
+    utils_mutex_destroy_not_free(&coarse->lock);
+
+    ravl_foreach(coarse->all_blocks, coarse_ravl_cb_rm_all_blocks_node, coarse);
+    assert(coarse->used_size == 0);
+    assert(coarse->alloc_size == 0);
+
+    ravl_delete(coarse->all_blocks);
+    ravl_delete(coarse->free_blocks);
+
+    umf_ba_global_free(coarse);
+}
+
+umf_result_t coarse_add_memory_from_provider(coarse_t *coarse, size_t size) {
+    umf_result_t umf_result;
+    void *ptr = NULL;
+
+    if (coarse == NULL || size == 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (!coarse->cb.alloc) {
+        LOG_ERR("error: alloc callback is not set");
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+
+    umf_result = coarse_alloc(coarse, size, coarse->page_size, &ptr);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        return umf_result;
+    }
+
+    assert(ptr);
+
+    return coarse_free(coarse, ptr, size);
+}
+
+umf_result_t coarse_add_memory_fixed(coarse_t *coarse, void *addr,
+                                     size_t size) {
+    umf_result_t umf_result;
+
+    if (coarse == NULL || addr == NULL || size == 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (coarse->cb.alloc || coarse->cb.free) {
+        LOG_ERR("error: alloc or free callback is set");
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+
+    if (utils_mutex_lock(&coarse->lock) != 0) {
+        LOG_ERR("locking the lock failed");
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    assert(debug_check(coarse));
+
+    umf_result = coarse_add_used_block(coarse, addr, size);
+
+    assert(debug_check(coarse));
+    utils_mutex_unlock(&coarse->lock);
+
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        return umf_result;
+    }
+
+    umf_result = coarse_free(coarse, addr, size);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        return umf_result;
+    }
+
+    LOG_DEBUG("coarse_ALLOC (add_memory_block) %zu used %zu alloc %zu", size,
+              coarse->used_size, coarse->alloc_size);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t coarse_alloc(coarse_t *coarse, size_t size, size_t alignment,
+                          void **resultPtr) {
+    umf_result_t umf_result = UMF_RESULT_ERROR_UNKNOWN;
+
+    if (coarse == NULL || resultPtr == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    // alignment must be a power of two and a multiple or a divider of the page size
+    if (alignment == 0) {
+        alignment = coarse->page_size;
+    } else if ((alignment & (alignment - 1)) ||
+               ((alignment % coarse->page_size) &&
+                (coarse->page_size % alignment))) {
+        LOG_ERR("wrong alignment: %zu (not a power of 2 or a multiple or a "
+                "divider of the page size (%zu))",
+                alignment, coarse->page_size);
+        return UMF_RESULT_ERROR_INVALID_ALIGNMENT;
+    } else if (IS_NOT_ALIGNED(alignment, coarse->page_size)) {
+        alignment = ALIGN_UP_SAFE(alignment, coarse->page_size);
+    }
+
+    if (utils_mutex_lock(&coarse->lock) != 0) {
+        LOG_ERR("locking the lock failed");
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    assert(debug_check(coarse));
+
+    *resultPtr = NULL;
+
+    // Find a block with greater or equal size using the given memory allocation strategy
+    block_t *curr = find_free_block(coarse->free_blocks, size, alignment,
+                                    coarse->allocation_strategy);
+    if (curr == NULL) {
+        // no suitable block found - try to get more memory from the upstream provider
+        umf_result = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+
+        if (!coarse->cb.alloc) {
+            LOG_ERR("out of memory (the memory provider does not support "
+                    "allocating more memory)");
+            goto err_unlock;
+        }
+
+        size_t size_aligned = ALIGN_UP_SAFE(size, alignment);
+        if (size_aligned == 0) {
+            // cannot align up (arithmetic overflow)
+            umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
+            LOG_ERR("size too huge (arithmetic overflow)");
+            goto err_unlock;
+        }
+
+        umf_result = coarse->cb.alloc(coarse->provider, size_aligned, alignment,
+                                      resultPtr);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            LOG_ERR("alloc() of memory provider failed: out of memory");
+            goto err_unlock;
+        }
+
+        ASSERT_IS_ALIGNED(((uintptr_t)(*resultPtr)), alignment);
+
+        block_t *new_free_block = NULL;
+        umf_result = coarse_add_free_block(coarse, *resultPtr, size_aligned,
+                                           &new_free_block);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            LOG_ERR("failed to add a newly allocated block from the memory "
+                    "provider");
+            if (coarse->cb.free) {
+                coarse->cb.free(coarse->provider, *resultPtr, size_aligned);
+            } else {
+                LOG_WARN("the memory provider does not support the free() "
+                         "operation, so the following memory block was leaked: "
+                         "address %p, size %zu",
+                         *resultPtr, size_aligned);
+            }
+            goto err_unlock;
+        }
+
+        LOG_DEBUG("coarse_ALLOC (memory_provider) %zu used %zu alloc %zu",
+                  size_aligned, coarse->used_size, coarse->alloc_size);
+
+        curr = new_free_block;
+    }
+
+    // If the block that we want to reuse has a greater size, split it.
+    // Try to merge the split part with the successor if it is not used.
+    enum { ACTION_NONE = 0, ACTION_USE, ACTION_SPLIT } action = ACTION_NONE;
+
+    if (curr && curr->size > size) {
+        action = ACTION_SPLIT;
+    } else if (curr && curr->size == size) {
+        action = ACTION_USE;
+    } else {
+        umf_result = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        LOG_ERR("out of memory");
+        goto err_unlock;
+    }
+
+    // ACTION_SPLIT or ACTION_USE
+    assert(curr->used == false);
+
+    // In case of non-zero alignment create an aligned block what would be further used.
+    if (alignment > 0) {
+        umf_result = create_aligned_block(coarse, size, alignment, &curr);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            (void)free_blocks_re_add(coarse, curr);
+            goto err_unlock;
+        }
+    }
+
+    if (action == ACTION_SPLIT) {
+        // Split the current block and put the new block after the one that we use.
+        umf_result = split_current_block(coarse, curr, size);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            (void)free_blocks_re_add(coarse, curr);
+            goto err_unlock;
+        }
+
+        curr->size = size;
+
+        LOG_DEBUG("coarse_ALLOC (split_block) %zu used %zu alloc %zu", size,
+                  coarse->used_size, coarse->alloc_size);
+
+    } else { // action == ACTION_USE
+        LOG_DEBUG("coarse_ALLOC (same_block) %zu used %zu alloc %zu", size,
+                  coarse->used_size, coarse->alloc_size);
+    }
+
+    curr->used = true;
+    *resultPtr = curr->data;
+    coarse->used_size += size;
+
+    umf_result = UMF_RESULT_SUCCESS;
+
+err_unlock:
+    assert(debug_check(coarse));
+    utils_mutex_unlock(&coarse->lock);
+
+    return umf_result;
+}
+
+umf_result_t coarse_free(coarse_t *coarse, void *ptr, size_t bytes) {
+    if (coarse == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (ptr == NULL) {
+        return UMF_RESULT_SUCCESS;
+    }
+
+    if (utils_mutex_lock(&coarse->lock) != 0) {
+        LOG_ERR("locking the lock failed");
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    assert(debug_check(coarse));
+
+    ravl_node_t *node = coarse_ravl_find_node(coarse->all_blocks, ptr);
+    if (node == NULL) {
+        // the block was not found
+        LOG_ERR("memory block not found (ptr = %p, size = %zu)", ptr, bytes);
+        utils_mutex_unlock(&coarse->lock);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    block_t *block = get_node_block(node);
+    if (!block->used) {
+        LOG_ERR("double free");
+        utils_mutex_unlock(&coarse->lock);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (bytes > 0 && bytes != block->size) {
+        LOG_ERR("wrong size of allocation");
+        utils_mutex_unlock(&coarse->lock);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    LOG_DEBUG("coarse_FREE (return_block_to_pool) %zu used %zu alloc %zu",
+              block->size, coarse->used_size - block->size, coarse->alloc_size);
+
+    assert(coarse->used_size >= block->size);
+    coarse->used_size -= block->size;
+
+    block->used = false;
+
+    // Merge with prev and/or next block if they are unused and have continuous data.
+    node = free_block_merge_with_prev(coarse, node);
+    node = free_block_merge_with_next(coarse, node);
+
+    int rv = free_blocks_add(coarse->free_blocks, get_node_block(node));
+    if (rv) {
+        utils_mutex_unlock(&coarse->lock);
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    assert(debug_check(coarse));
+    utils_mutex_unlock(&coarse->lock);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t coarse_merge(coarse_t *coarse, void *lowPtr, void *highPtr,
+                          size_t totalSize) {
+    umf_result_t umf_result;
+
+    if (coarse == NULL || lowPtr == NULL || highPtr == NULL || totalSize == 0 ||
+        ((uintptr_t)highPtr <= (uintptr_t)lowPtr) ||
+        ((uintptr_t)highPtr - (uintptr_t)lowPtr >= totalSize)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (utils_mutex_lock(&coarse->lock) != 0) {
+        LOG_ERR("locking the lock failed");
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    assert(debug_check(coarse));
+
+    umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
+
+    ravl_node_t *low_node = coarse_ravl_find_node(coarse->all_blocks, lowPtr);
+    if (low_node == NULL) {
+        LOG_ERR("the lowPtr memory block not found");
+        goto err_mutex_unlock;
+    }
+
+    block_t *low_block = get_node_block(low_node);
+    if (!low_block->used) {
+        LOG_ERR("the lowPtr block is not allocated");
+        goto err_mutex_unlock;
+    }
+
+    ravl_node_t *high_node = coarse_ravl_find_node(coarse->all_blocks, highPtr);
+    if (high_node == NULL) {
+        LOG_ERR("the highPtr memory block not found");
+        goto err_mutex_unlock;
+    }
+
+    block_t *high_block = get_node_block(high_node);
+    if (!high_block->used) {
+        LOG_ERR("the highPtr block is not allocated");
+        goto err_mutex_unlock;
+    }
+
+    if (get_node_next(low_node) != high_node ||
+        ((uintptr_t)highPtr != ((uintptr_t)lowPtr + low_block->size))) {
+        LOG_ERR("given allocations are not adjacent");
+        goto err_mutex_unlock;
+    }
+
+    assert(get_node_prev(high_node) == low_node);
+
+    if (low_block->size + high_block->size != totalSize) {
+        LOG_ERR("wrong totalSize: %zu != %zu", totalSize,
+                low_block->size + high_block->size);
+        goto err_mutex_unlock;
+    }
+
+    ravl_node_t *merged_node = NULL;
+
+    umf_result =
+        user_block_merge(coarse, low_node, high_node, true, &merged_node);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("merging a block failed");
+        goto err_mutex_unlock;
+    }
+
+    assert(merged_node == low_node);
+    assert(low_block->size == totalSize);
+
+    umf_result = UMF_RESULT_SUCCESS;
+
+err_mutex_unlock:
+    assert(debug_check(coarse));
+    utils_mutex_unlock(&coarse->lock);
+
+    return umf_result;
+}
+
+umf_result_t coarse_split(coarse_t *coarse, void *ptr, size_t totalSize,
+                          size_t firstSize) {
+    umf_result_t umf_result;
+
+    if (coarse == NULL || ptr == NULL || (firstSize >= totalSize) ||
+        firstSize == 0 || totalSize == 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (utils_mutex_lock(&coarse->lock) != 0) {
+        LOG_ERR("locking the lock failed");
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    assert(debug_check(coarse));
+
+    umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
+
+    ravl_node_t *node = coarse_ravl_find_node(coarse->all_blocks, ptr);
+    if (node == NULL) {
+        LOG_ERR("memory block not found");
+        goto err_mutex_unlock;
+    }
+
+    block_t *block = get_node_block(node);
+
+    if (block->size != totalSize) {
+        LOG_ERR("wrong totalSize: %zu != %zu", totalSize, block->size);
+        goto err_mutex_unlock;
+    }
+
+    if (!block->used) {
+        LOG_ERR("block is not allocated");
+        goto err_mutex_unlock;
+    }
+
+    // check if block can be split by the memory provider
+    umf_result = can_provider_split(coarse, ptr, totalSize, firstSize);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("memory provider cannot split a memory block");
+        goto err_mutex_unlock;
+    }
+
+    umf_result = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+
+    block_t *new_block =
+        coarse_ravl_add_new(coarse->all_blocks, block->data + firstSize,
+                            block->size - firstSize, NULL);
+    if (new_block == NULL) {
+        goto err_mutex_unlock;
+    }
+
+    block->size = firstSize;
+    new_block->used = true;
+
+    assert(new_block->size == (totalSize - firstSize));
+
+    umf_result = UMF_RESULT_SUCCESS;
+
+err_mutex_unlock:
+    assert(debug_check(coarse));
+    utils_mutex_unlock(&coarse->lock);
+
+    return umf_result;
+}
+
+coarse_stats_t coarse_get_stats(coarse_t *coarse) {
+    coarse_stats_t stats = {0};
+
+    if (coarse == NULL) {
+        return stats;
+    }
+
+    if (utils_mutex_lock(&coarse->lock) != 0) {
+        LOG_ERR("locking the lock failed");
+        return stats;
+    }
+
+    coarse_get_stats_no_lock(coarse, &stats);
+
+    utils_mutex_unlock(&coarse->lock);
+
+    return stats;
+}
diff --git a/src/coarse/coarse.h b/src/coarse/coarse.h
new file mode 100644
index 0000000000..93ec990027
--- /dev/null
+++ b/src/coarse/coarse.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#ifndef UMF_COARSE_H
+#define UMF_COARSE_H
+
+#include <stdbool.h>
+#include <string.h>
+
+#include <umf/base.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct coarse_t coarse_t;
+
+// coarse callbacks implement provider-specific actions
+typedef struct coarse_callbacks_t {
+    // alloc() is optional (can be NULL for the fixed-size memory provider)
+    umf_result_t (*alloc)(void *provider, size_t size, size_t alignment,
+                          void **ptr);
+    // free() is optional (can be NULL if the provider does not support the free() op)
+    umf_result_t (*free)(void *provider, void *ptr, size_t size);
+    umf_result_t (*split)(void *provider, void *ptr, size_t totalSize,
+                          size_t firstSize);
+    umf_result_t (*merge)(void *provider, void *lowPtr, void *highPtr,
+                          size_t totalSize);
+} coarse_callbacks_t;
+
+// coarse library allocation strategy
+typedef enum coarse_strategy_t {
+    // Check if the first free block of the 'size' size has the correct alignment.
+    // If not, use the `UMF_COARSE_MEMORY_STRATEGY_FASTEST` strategy.
+    UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE = 0,
+
+    // Always allocate a free block of the (size + alignment) size
+    // and cut out the properly aligned part leaving two remaining parts.
+    // It is the fastest strategy but causes memory fragmentation
+    // when alignment is greater than 0.
+    // It is the best strategy when alignment always equals 0.
+    UMF_COARSE_MEMORY_STRATEGY_FASTEST,
+
+    // Look through all free blocks of the 'size' size
+    // and choose the first one with the correct alignment.
+    // If none of them had the correct alignment,
+    // use the `UMF_COARSE_MEMORY_STRATEGY_FASTEST` strategy.
+    UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE,
+} coarse_strategy_t;
+
+// coarse library settings structure
+typedef struct coarse_params_t {
+    // handle of the memory provider
+    void *provider;
+
+    // coarse callbacks
+    coarse_callbacks_t cb;
+
+    // memory allocation strategy,
+    // see coarse_strategy_t for details
+    coarse_strategy_t allocation_strategy;
+
+    // page size of the memory provider
+    size_t page_size;
+} coarse_params_t;
+
+// coarse library statistics
+typedef struct coarse_stats_t {
+    // total allocation size
+    size_t alloc_size;
+
+    // size of used memory
+    size_t used_size;
+
+    // total number of allocated memory blocks
+    size_t num_all_blocks;
+
+    // number of free memory blocks
+    size_t num_free_blocks;
+} coarse_stats_t;
+
+umf_result_t coarse_new(coarse_params_t *coarse_params, coarse_t **pcoarse);
+void coarse_delete(coarse_t *coarse);
+
+umf_result_t coarse_alloc(coarse_t *coarse, size_t size, size_t alignment,
+                          void **resultPtr);
+umf_result_t coarse_free(coarse_t *coarse, void *ptr, size_t bytes);
+
+umf_result_t coarse_merge(coarse_t *coarse, void *lowPtr, void *highPtr,
+                          size_t totalSize);
+umf_result_t coarse_split(coarse_t *coarse, void *ptr, size_t totalSize,
+                          size_t firstSize);
+
+// supported only if the alloc callback is set,
+// returns UMF_RESULT_ERROR_NOT_SUPPORTED otherwise
+umf_result_t coarse_add_memory_from_provider(coarse_t *coarse, size_t size);
+
+// supported only if the alloc and the free callbacks are NOT set
+// returns UMF_RESULT_ERROR_NOT_SUPPORTED otherwise
+umf_result_t coarse_add_memory_fixed(coarse_t *coarse, void *addr, size_t size);
+
+coarse_stats_t coarse_get_stats(coarse_t *coarse);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // UMF_COARSE_H
diff --git a/src/critnib/critnib.c b/src/critnib/critnib.c
index 62d14af73d..8ff5796684 100644
--- a/src/critnib/critnib.c
+++ b/src/critnib/critnib.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -64,6 +64,7 @@
 #include "utils_assert.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
+#include "utils_math.h"
 
 /*
  * A node that has been deleted is left untouched for this many delete
@@ -88,8 +89,11 @@
 #define NIB ((1ULL << SLICE) - 1)
 #define SLNODES (1 << SLICE)
 
+// it has to be >= 2
+#define LEAF_VALID (2ULL)
+
 typedef uintptr_t word;
-typedef unsigned char sh_t;
+typedef uint8_t sh_t;
 
 struct critnib_node {
     /*
@@ -115,10 +119,29 @@ struct critnib_node {
 struct critnib_leaf {
     word key;
     void *value;
+    /*
+     * When cb_free_leaf() is set (values of leaves should be freed),
+     * critnib_remove() sets 'to_be_freed' to the 'value' of the leaf
+     * and sets 'value' to NULL, because the 'value' of a removed leaf
+     * is not valid anymore and should not be returned to a user.
+     * The 'value' of the leaf saved in 'to_be_freed' is freed in critnib_release()
+     * when the reference count of the leaf drops to 0.
+     */
+    void *to_be_freed;
+    /*
+     * 'pending_deleted_leaf' is set when critnib_release() should add this leaf
+     * to the 'c->deleted_leaf' list when the reference count drops to 0.
+     */
+    uint8_t pending_deleted_leaf;
+    // the 'next' pointer in the 'c->deleted_leaf' list
+    void *next;
+    uint64_t ref_count;
 };
 
 struct critnib {
     struct critnib_node *root;
+    free_leaf_t cb_free_leaf; // callback for freeing a leaf
+    void *leaf_allocator;     // handle of allocator for leaves
 
     /* pool of freed nodes: singly linked list, next at child[0] */
     struct critnib_node *deleted_node;
@@ -133,24 +156,6 @@ struct critnib {
     struct utils_mutex_t mutex; /* writes/removes */
 };
 
-/*
- * atomic load
- */
-static void load(void *src, void *dst) {
-    utils_atomic_load_acquire((word *)src, (word *)dst);
-}
-
-static void load64(uint64_t *src, uint64_t *dst) {
-    utils_atomic_load_acquire(src, dst);
-}
-
-/*
- * atomic store
- */
-static void store(void *dst, void *src) {
-    utils_atomic_store_release((word *)dst, (word)src);
-}
-
 /*
  * internal: is_leaf -- check tagged pointer for leafness
  */
@@ -178,8 +183,12 @@ static inline unsigned slice_index(word key, sh_t shift) {
 
 /*
  * critnib_new -- allocates a new critnib structure
+ *
+ * Arguments:
+ * - cb_free_leaf - callback for freeing a leaf (can be NULL)
+ * - leaf_allocator - handle of allocator for leaves (can be NULL)
  */
-struct critnib *critnib_new(void) {
+struct critnib *critnib_new(free_leaf_t cb_free_leaf, void *leaf_allocator) {
     struct critnib *c = umf_ba_global_alloc(sizeof(struct critnib));
     if (!c) {
         return NULL;
@@ -192,8 +201,10 @@ struct critnib *critnib_new(void) {
         goto err_free_critnib;
     }
 
-    VALGRIND_HG_DRD_DISABLE_CHECKING(&c->root, sizeof(c->root));
-    VALGRIND_HG_DRD_DISABLE_CHECKING(&c->remove_count, sizeof(c->remove_count));
+    c->leaf_allocator = leaf_allocator;
+    c->cb_free_leaf = cb_free_leaf;
+    utils_annotate_memory_no_check(&c->root, sizeof(c->root));
+    utils_annotate_memory_no_check(&c->remove_count, sizeof(c->remove_count));
 
     return c;
 err_free_critnib:
@@ -206,6 +217,15 @@ struct critnib *critnib_new(void) {
  */
 static void delete_node(struct critnib *c, struct critnib_node *__restrict n) {
     if (is_leaf(n)) {
+        // call the callback freeing the leaf
+        if (c->cb_free_leaf) {
+            if (to_leaf(n)->value) {
+                c->cb_free_leaf(c->leaf_allocator, (void *)to_leaf(n)->value);
+            } else if (to_leaf(n)->to_be_freed) {
+                c->cb_free_leaf(c->leaf_allocator,
+                                (void *)to_leaf(n)->to_be_freed);
+            }
+        }
         umf_ba_global_free(to_leaf(n));
     } else {
         for (int i = 0; i < SLNODES; i++) {
@@ -235,13 +255,22 @@ void critnib_delete(struct critnib *c) {
     }
 
     for (struct critnib_leaf *k = c->deleted_leaf; k;) {
-        struct critnib_leaf *kk = k->value;
+        struct critnib_leaf *kk = k->next;
         umf_ba_global_free(k);
         k = kk;
     }
 
     for (int i = 0; i < DELETED_LIFE; i++) {
         umf_ba_global_free(c->pending_del_nodes[i]);
+        if (c->cb_free_leaf && c->pending_del_leaves[i]) {
+            if (c->pending_del_leaves[i]->value) {
+                c->cb_free_leaf(c->leaf_allocator,
+                                (void *)c->pending_del_leaves[i]->value);
+            } else if (c->pending_del_leaves[i]->to_be_freed) {
+                c->cb_free_leaf(c->leaf_allocator,
+                                (void *)c->pending_del_leaves[i]->to_be_freed);
+            }
+        }
         umf_ba_global_free(c->pending_del_leaves[i]);
     }
 
@@ -263,8 +292,8 @@ static void free_node(struct critnib *__restrict c,
     }
 
     ASSERT(!is_leaf(n));
-    n->child[0] = c->deleted_node;
-    c->deleted_node = n;
+    utils_atomic_store_release_ptr((void **)&n->child[0], c->deleted_node);
+    utils_atomic_store_release_ptr((void **)&c->deleted_node, n);
 }
 
 /*
@@ -278,11 +307,25 @@ static struct critnib_node *alloc_node(struct critnib *__restrict c) {
     struct critnib_node *n = c->deleted_node;
 
     c->deleted_node = n->child[0];
-    VALGRIND_ANNOTATE_NEW_MEMORY(n, sizeof(*n));
+    utils_annotate_memory_new(n, sizeof(*n));
 
     return n;
 }
 
+static void add_to_deleted_leaf_list(struct critnib *__restrict c,
+                                     struct critnib_leaf *__restrict k) {
+    assert(k);
+    struct critnib_leaf *deleted_leaf;
+
+    utils_atomic_load_acquire_ptr((void **)&c->deleted_leaf,
+                                  (void **)&deleted_leaf);
+    utils_atomic_store_release_ptr(&k->next, deleted_leaf);
+    while (!utils_compare_exchange_u64((uint64_t *)&c->deleted_leaf,
+                                       (uint64_t *)&k->next, (uint64_t *)&k)) {
+        ;
+    }
+}
+
 /*
  * internal: free_leaf -- free (to internal pool, not malloc) a leaf.
  *
@@ -294,22 +337,43 @@ static void free_leaf(struct critnib *__restrict c,
         return;
     }
 
-    k->value = c->deleted_leaf;
-    c->deleted_leaf = k;
+    // k should be added to the c->deleted_leaf list here
+    // or in critnib_release() when the reference count drops to 0.
+    utils_atomic_store_release_u8(&k->pending_deleted_leaf, 1);
+
+    if (c->cb_free_leaf) {
+        uint64_t ref_count;
+        utils_atomic_load_acquire_u64(&k->ref_count, &ref_count);
+        if (ref_count > 0) {
+            // k will be added to the c->deleted_leaf list in critnib_release()
+            // when the reference count drops to 0.
+            return;
+        }
+    }
+
+    uint8_t expected = 1;
+    uint8_t desired = 0;
+    if (utils_compare_exchange_u8(&k->pending_deleted_leaf, &expected,
+                                  &desired)) {
+        add_to_deleted_leaf_list(c, k);
+    }
 }
 
 /*
  * internal: alloc_leaf -- allocate a leaf from our pool or from malloc
  */
 static struct critnib_leaf *alloc_leaf(struct critnib *__restrict c) {
-    if (!c->deleted_leaf) {
-        return umf_ba_global_alloc(sizeof(struct critnib_leaf));
-    }
+    struct critnib_leaf *k;
 
-    struct critnib_leaf *k = c->deleted_leaf;
+    utils_atomic_load_acquire_ptr((void **)&c->deleted_leaf, (void **)&k);
+    do {
+        if (!k) {
+            return umf_ba_global_aligned_alloc(sizeof(struct critnib_leaf), 8);
+        }
+    } while (!utils_compare_exchange_u64((uint64_t *)&c->deleted_leaf,
+                                         (uint64_t *)&k, (uint64_t *)&k->next));
 
-    c->deleted_leaf = k->value;
-    VALGRIND_ANNOTATE_NEW_MEMORY(k, sizeof(*k));
+    utils_annotate_memory_new(k, sizeof(*k));
 
     return k;
 }
@@ -334,19 +398,27 @@ int critnib_insert(struct critnib *c, word key, void *value, int update) {
         return ENOMEM;
     }
 
-    VALGRIND_HG_DRD_DISABLE_CHECKING(k, sizeof(struct critnib_leaf));
+    utils_annotate_memory_no_check(k, sizeof(struct critnib_leaf));
 
-    k->key = key;
-    k->value = value;
+    utils_atomic_store_release_ptr(&k->to_be_freed, 0);
+    utils_atomic_store_release_ptr((void **)&k->key, (void *)key);
+    utils_atomic_store_release_ptr(&k->value, value);
+    utils_atomic_store_release_u8(&k->pending_deleted_leaf, 0);
+
+    if (c->cb_free_leaf) {
+        // mark the leaf as valid (ref_count == 2)
+        utils_atomic_store_release_u64(&k->ref_count, LEAF_VALID);
+    } else {
+        // the reference counter is not used in this case
+        utils_atomic_store_release_u64(&k->ref_count, 0ULL);
+    }
 
     struct critnib_node *kn = (void *)((word)k | 1);
 
     struct critnib_node *n = c->root;
     if (!n) {
-        store(&c->root, kn);
-
+        utils_atomic_store_release_ptr((void **)&c->root, kn);
         utils_mutex_unlock(&c->mutex);
-
         return 0;
     }
 
@@ -361,22 +433,34 @@ int critnib_insert(struct critnib *c, word key, void *value, int update) {
 
     if (!n) {
         n = prev;
-        store(&n->child[slice_index(key, n->shift)], kn);
+        utils_atomic_store_release_ptr(
+            (void **)&n->child[slice_index(key, n->shift)], kn);
 
         utils_mutex_unlock(&c->mutex);
 
         return 0;
     }
 
-    word path = is_leaf(n) ? to_leaf(n)->key : n->path;
+    word path;
+    if (is_leaf(n)) {
+        utils_atomic_load_acquire_u64((uint64_t *)&to_leaf(n)->key,
+                                      (uint64_t *)&path);
+    } else {
+        path = n->path;
+    }
+
     /* Find where the path differs from our key. */
     word at = path ^ key;
     if (!at) {
         ASSERT(is_leaf(n));
+        if (c->cb_free_leaf) {
+            // mark the leaf as not used (ref_count == 0)
+            utils_atomic_store_release_u64(&(to_leaf(kn))->ref_count, 0ULL);
+        }
         free_leaf(c, to_leaf(kn));
 
         if (update) {
-            to_leaf(n)->value = value;
+            utils_atomic_store_release_ptr(&to_leaf(n)->value, value);
             utils_mutex_unlock(&c->mutex);
             return 0;
         } else {
@@ -386,27 +470,31 @@ int critnib_insert(struct critnib *c, word key, void *value, int update) {
     }
 
     /* and convert that to an index. */
-    sh_t sh = utils_mssb_index(at) & (sh_t) ~(SLICE - 1);
+    sh_t sh = utils_msb64(at) & (sh_t) ~(SLICE - 1);
 
     struct critnib_node *m = alloc_node(c);
     if (!m) {
+        if (c->cb_free_leaf) {
+            // mark the leaf as not used (ref_count == 0)
+            utils_atomic_store_release_u64(&(to_leaf(kn))->ref_count, 0ULL);
+        }
         free_leaf(c, to_leaf(kn));
-
         utils_mutex_unlock(&c->mutex);
-
         return ENOMEM;
     }
-    VALGRIND_HG_DRD_DISABLE_CHECKING(m, sizeof(struct critnib_node));
+
+    utils_annotate_memory_no_check(m, sizeof(struct critnib_node));
 
     for (int i = 0; i < SLNODES; i++) {
-        m->child[i] = NULL;
+        utils_atomic_store_release_ptr((void *)&m->child[i], NULL);
     }
 
-    m->child[slice_index(key, sh)] = kn;
-    m->child[slice_index(path, sh)] = n;
-    m->shift = sh;
-    m->path = key & path_mask(sh);
-    store(parent, m);
+    utils_atomic_store_release_ptr((void *)&m->child[slice_index(key, sh)], kn);
+    utils_atomic_store_release_ptr((void *)&m->child[slice_index(path, sh)], n);
+    utils_atomic_store_release_u8(&m->shift, sh);
+    utils_atomic_store_release_u64((uint64_t *)&m->path, key & path_mask(sh));
+
+    utils_atomic_store_release_ptr((void **)parent, m);
 
     utils_mutex_unlock(&c->mutex);
 
@@ -415,10 +503,23 @@ int critnib_insert(struct critnib *c, word key, void *value, int update) {
 
 /*
  * critnib_remove -- delete a key from the critnib structure, return its value
+ *
+ * ref - returns a reference to the returned value, which must be released
+ *       with critnib_release() when it is no longer needed.
+ *       If ref is NULL, critnib_remove() returns NULL.
  */
-void *critnib_remove(struct critnib *c, word key) {
+void *critnib_remove(struct critnib *c, word key, void **ref) {
     struct critnib_leaf *k;
     void *value = NULL;
+    word kkey;
+
+    if (!c || (c->cb_free_leaf && !ref)) {
+        return NULL;
+    }
+
+    if (ref) {
+        *ref = NULL;
+    }
 
     utils_mutex_lock(&c->mutex);
 
@@ -427,7 +528,9 @@ void *critnib_remove(struct critnib *c, word key) {
         goto not_found;
     }
 
-    word del = (utils_atomic_increment(&c->remove_count) - 1) % DELETED_LIFE;
+    word del =
+        (utils_atomic_increment_u64(&c->remove_count) - 1) % DELETED_LIFE;
+
     free_node(c, c->pending_del_nodes[del]);
     free_leaf(c, c->pending_del_leaves[del]);
     c->pending_del_nodes[del] = NULL;
@@ -435,8 +538,9 @@ void *critnib_remove(struct critnib *c, word key) {
 
     if (is_leaf(n)) {
         k = to_leaf(n);
-        if (k->key == key) {
-            store(&c->root, NULL);
+        utils_atomic_load_acquire_u64((uint64_t *)&k->key, (uint64_t *)&kkey);
+        if (kkey == key) {
+            utils_atomic_store_release_ptr((void **)&c->root, NULL);
             goto del_leaf;
         }
 
@@ -462,11 +566,13 @@ void *critnib_remove(struct critnib *c, word key) {
     }
 
     k = to_leaf(kn);
-    if (k->key != key) {
+    utils_atomic_load_acquire_u64((uint64_t *)&k->key, (uint64_t *)&kkey);
+    if (kkey != key) {
         goto not_found;
     }
 
-    store(&n->child[slice_index(key, n->shift)], NULL);
+    utils_atomic_store_release_ptr(
+        (void **)&n->child[slice_index(key, n->shift)], NULL);
 
     /* Remove the node if there's only one remaining child. */
     int ochild = -1;
@@ -482,11 +588,16 @@ void *critnib_remove(struct critnib *c, word key) {
 
     ASSERTne(ochild, -1);
 
-    store(n_parent, n->child[ochild]);
+    utils_atomic_store_release_ptr((void **)n_parent, n->child[ochild]);
     c->pending_del_nodes[del] = n;
 
 del_leaf:
     value = k->value;
+    if (c->cb_free_leaf) {
+        utils_atomic_store_release_ptr(&k->to_be_freed, value);
+        utils_atomic_store_release_ptr(&k->value, NULL);
+        *ref = k;
+    }
     c->pending_del_leaves[del] = k;
 
 not_found:
@@ -494,6 +605,101 @@ void *critnib_remove(struct critnib *c, word key) {
     return value;
 }
 
+/*
+ * critnib_release -- release a reference to a key
+ */
+int critnib_release(struct critnib *c, void *ref) {
+    if (!c || !ref || !c->cb_free_leaf) {
+        return -1;
+    }
+
+    struct critnib_leaf *k = (struct critnib_leaf *)ref;
+
+    uint64_t ref_count;
+    uint64_t ref_desired;
+    /* decrement the reference count */
+    utils_atomic_load_acquire_u64(&k->ref_count, &ref_count);
+    do {
+        if (ref_count < LEAF_VALID) {
+#ifndef NDEBUG
+            LOG_FATAL("critnib_release() was called too many times (ref_count "
+                      "= %llu)\n",
+                      (unsigned long long)ref_count);
+            assert(ref_count >= LEAF_VALID);
+#endif
+            return -1;
+        }
+        ref_desired = ref_count - 1;
+    } while (
+        !utils_compare_exchange_u64(&k->ref_count, &ref_count, &ref_desired));
+
+    if (ref_desired >= LEAF_VALID) {
+        // ref_counter was decremented and it is still valid
+        return 0;
+    }
+
+    /* ref_counter == (LEAF_VALID - 1)) - the leaf will be freed */
+    void *to_be_freed = NULL;
+    utils_atomic_load_acquire_ptr(&k->to_be_freed, &to_be_freed);
+    utils_atomic_store_release_ptr(&k->to_be_freed, NULL);
+#ifndef NDEBUG
+    if (to_be_freed == NULL) {
+        LOG_FATAL("leaf will not be freed (to_be_freed == NULL, value = %p)\n",
+                  k->value);
+        assert(to_be_freed != NULL);
+    }
+#endif
+
+    // mark the leaf as not used (ref_count == 0)
+    utils_atomic_store_release_u64(&k->ref_count, 0ULL);
+
+    c->cb_free_leaf(c->leaf_allocator, to_be_freed);
+
+    uint8_t expected = 1;
+    uint8_t desired = 0;
+    if (utils_compare_exchange_u8(&k->pending_deleted_leaf, &expected,
+                                  &desired)) {
+        add_to_deleted_leaf_list(c, k);
+    }
+
+    return 0;
+}
+
+/*
+ * critnib_remove_release -- delete a key from the critnib structure
+ *
+ * Returns 0 on success, -1 if the key was not found.
+ */
+int critnib_remove_release(struct critnib *c, word key) {
+    void *ref = NULL;
+    void *value = critnib_remove(c, key, &ref);
+    if (ref) {
+        critnib_release(c, ref);
+    }
+
+    return (value) ? 0 : -1;
+}
+
+/*
+ * Check if the leaf has just been removed (i.e. if ref_count == 0).
+ * If so, we return -1 (failure), otherwise increment the reference
+ * counter and return 0 (success).
+ */
+static inline int increment_ref_count(struct critnib_leaf *k) {
+    uint64_t expected;
+    uint64_t desired;
+
+    utils_atomic_load_acquire_u64(&k->ref_count, &expected);
+    do {
+        if (expected < LEAF_VALID) {
+            return -1;
+        }
+        desired = expected + 1;
+    } while (!utils_compare_exchange_u64(&k->ref_count, &expected, &desired));
+
+    return 0;
+}
+
 /*
  * critnib_get -- query for a key ("==" match), returns value or NULL
  *
@@ -503,16 +709,30 @@ void *critnib_remove(struct critnib *c, word key) {
  *
  * Counterintuitively, it's pointless to return the most current answer,
  * we need only one that was valid at any point after the call started.
+ *
+ * ref - returns a reference to the returned value that must be released
+ *       with critnib_release() when it is no longer needed,
+ *       critnib_get() returns NULL if ref is NULL
  */
-void *critnib_get(struct critnib *c, word key) {
+void *critnib_get(struct critnib *c, word key, void **ref) {
+    struct critnib_leaf *k;
+    struct critnib_node *n;
     uint64_t wrs1, wrs2;
-    void *res;
+    void *res = NULL;
+    sh_t shift;
+    word kkey;
 
-    do {
-        struct critnib_node *n;
+    if (!c || (c->cb_free_leaf && !ref)) {
+        return NULL;
+    }
+
+    if (ref) {
+        *ref = NULL;
+    }
 
-        load64(&c->remove_count, &wrs1);
-        load(&c->root, &n);
+    do {
+        utils_atomic_load_acquire_u64(&c->remove_count, &wrs1);
+        utils_atomic_load_acquire_ptr((void **)&c->root, (void **)&n);
 
         /*
 		 * critbit algorithm: dive into the tree, looking at nothing but
@@ -520,15 +740,32 @@ void *critnib_get(struct critnib *c, word key) {
 		 * going wrong way if our path is missing, but that's ok...
 		 */
         while (n && !is_leaf(n)) {
-            load(&n->child[slice_index(key, n->shift)], &n);
+            utils_atomic_load_acquire_u8(&n->shift, &shift);
+            utils_atomic_load_acquire_ptr(
+                (void **)&n->child[slice_index(key, shift)], (void **)&n);
         }
 
         /* ... as we check it at the end. */
-        struct critnib_leaf *k = to_leaf(n);
-        res = (n && k->key == key) ? k->value : NULL;
-        load64(&c->remove_count, &wrs2);
+        res = NULL;
+        k = to_leaf(n);
+        if (n) {
+            utils_atomic_load_acquire_u64((uint64_t *)&k->key,
+                                          (uint64_t *)&kkey);
+            if (kkey == key) {
+                utils_atomic_load_acquire_ptr(&k->value, &res);
+            }
+        }
+        utils_atomic_load_acquire_u64(&c->remove_count, &wrs2);
     } while (wrs1 + DELETED_LIFE <= wrs2);
 
+    if (c->cb_free_leaf && res) {
+        if (increment_ref_count(k)) {
+            return NULL;
+        }
+
+        *ref = k;
+    }
+
     return res;
 }
 
@@ -540,7 +777,9 @@ find_predecessor(struct critnib_node *__restrict n) {
     while (1) {
         int nib;
         for (nib = NIB; nib >= 0; nib--) {
-            if (n->child[nib]) {
+            struct critnib_node *m;
+            utils_atomic_load_acquire_ptr((void **)&n->child[nib], (void **)&m);
+            if (m) {
                 break;
             }
         }
@@ -549,7 +788,12 @@ find_predecessor(struct critnib_node *__restrict n) {
             return NULL;
         }
 
-        n = n->child[nib];
+        utils_atomic_load_acquire_ptr((void **)&n->child[nib], (void **)&n);
+
+        if (!n) {
+            return NULL;
+        }
+
         if (is_leaf(n)) {
             return to_leaf(n);
         }
@@ -561,13 +805,16 @@ find_predecessor(struct critnib_node *__restrict n) {
  */
 static struct critnib_leaf *find_le(struct critnib_node *__restrict n,
                                     word key) {
+    word kkey;
+
     if (!n) {
         return NULL;
     }
 
     if (is_leaf(n)) {
         struct critnib_leaf *k = to_leaf(n);
-        return (k->key <= key) ? k : NULL;
+        utils_atomic_load_acquire_u64((uint64_t *)&k->key, (uint64_t *)&kkey);
+        return (kkey <= key) ? k : NULL;
     }
 
     /*
@@ -577,12 +824,16 @@ static struct critnib_leaf *find_le(struct critnib_node *__restrict n,
 	 * that shift points at the nib's lower rather than upper edge, so it
 	 * needs to be masked away as well.
 	 */
-    if ((key ^ n->path) >> (n->shift) & ~NIB) {
+    word path;
+    sh_t shift;
+    utils_atomic_load_acquire_u8(&n->shift, &shift);
+    utils_atomic_load_acquire_u64((uint64_t *)&n->path, (uint64_t *)&path);
+    if ((key ^ path) >> (shift) & ~NIB) {
         /*
 		 * subtree is too far to the left?
 		 * -> its rightmost value is good
 		 */
-        if (n->path < key) {
+        if (path < key) {
             return find_predecessor(n);
         }
 
@@ -593,11 +844,11 @@ static struct critnib_leaf *find_le(struct critnib_node *__restrict n,
         return NULL;
     }
 
-    unsigned nib = slice_index(key, n->shift);
+    unsigned nib = slice_index(key, shift);
     /* recursive call: follow the path */
     {
         struct critnib_node *m;
-        load(&n->child[nib], &m);
+        utils_atomic_load_acquire_ptr((void **)&n->child[nib], (void **)&m);
         struct critnib_leaf *k = find_le(m, key);
         if (k) {
             return k;
@@ -611,7 +862,7 @@ static struct critnib_leaf *find_le(struct critnib_node *__restrict n,
 	 */
     for (; nib > 0; nib--) {
         struct critnib_node *m;
-        load(&n->child[nib - 1], &m);
+        utils_atomic_load_acquire_ptr((void **)&n->child[nib - 1], (void **)&m);
         if (m) {
             n = m;
             if (is_leaf(n)) {
@@ -629,20 +880,45 @@ static struct critnib_leaf *find_le(struct critnib_node *__restrict n,
  * critnib_find_le -- query for a key ("<=" match), returns value or NULL
  *
  * Same guarantees as critnib_get().
+ *
+ * ref - returns a reference to the returned value that must be released
+ *       with critnib_release() when it is no longer needed,
+ *       critnib_find_le() returns NULL if ref is NULL
  */
-void *critnib_find_le(struct critnib *c, word key) {
+void *critnib_find_le(struct critnib *c, word key, void **ref) {
+    struct critnib_leaf *k;
     uint64_t wrs1, wrs2;
     void *res;
 
+    if (!c || (c->cb_free_leaf && !ref)) {
+        return NULL;
+    }
+
+    if (ref) {
+        *ref = NULL;
+    }
+
     do {
-        load64(&c->remove_count, &wrs1);
+        utils_atomic_load_acquire_u64(&c->remove_count, &wrs1);
         struct critnib_node *n; /* avoid a subtle TOCTOU */
-        load(&c->root, &n);
-        struct critnib_leaf *k = n ? find_le(n, key) : NULL;
-        res = k ? k->value : NULL;
-        load64(&c->remove_count, &wrs2);
+        utils_atomic_load_acquire_ptr((void **)&c->root, (void **)&n);
+        k = n ? find_le(n, key) : NULL;
+        if (k) {
+            utils_atomic_load_acquire_ptr(&k->value, &res);
+        } else {
+            res = NULL;
+        }
+        utils_atomic_load_acquire_u64(&c->remove_count, &wrs2);
     } while (wrs1 + DELETED_LIFE <= wrs2);
 
+    if (c->cb_free_leaf && res) {
+        if (increment_ref_count(k)) {
+            return NULL;
+        }
+
+        *ref = k;
+    }
+
     return res;
 }
 
@@ -653,7 +929,9 @@ static struct critnib_leaf *find_successor(struct critnib_node *__restrict n) {
     while (1) {
         unsigned nib;
         for (nib = 0; nib <= NIB; nib++) {
-            if (n->child[nib]) {
+            struct critnib_node *m;
+            utils_atomic_load_acquire_ptr((void **)&n->child[nib], (void **)&m);
+            if (m) {
                 break;
             }
         }
@@ -662,7 +940,12 @@ static struct critnib_leaf *find_successor(struct critnib_node *__restrict n) {
             return NULL;
         }
 
-        n = n->child[nib];
+        utils_atomic_load_acquire_ptr((void **)&n->child[nib], (void **)&n);
+
+        if (!n) {
+            return NULL;
+        }
+
         if (is_leaf(n)) {
             return to_leaf(n);
         }
@@ -674,13 +957,16 @@ static struct critnib_leaf *find_successor(struct critnib_node *__restrict n) {
  */
 static struct critnib_leaf *find_ge(struct critnib_node *__restrict n,
                                     word key) {
+    word kkey;
+
     if (!n) {
         return NULL;
     }
 
     if (is_leaf(n)) {
         struct critnib_leaf *k = to_leaf(n);
-        return (k->key >= key) ? k : NULL;
+        utils_atomic_load_acquire_u64((uint64_t *)&k->key, (uint64_t *)&kkey);
+        return (kkey >= key) ? k : NULL;
     }
 
     if ((key ^ n->path) >> (n->shift) & ~NIB) {
@@ -694,7 +980,7 @@ static struct critnib_leaf *find_ge(struct critnib_node *__restrict n,
     unsigned nib = slice_index(key, n->shift);
     {
         struct critnib_node *m;
-        load(&n->child[nib], &m);
+        utils_atomic_load_acquire_ptr((void **)&n->child[nib], (void **)&m);
         struct critnib_leaf *k = find_ge(m, key);
         if (k) {
             return k;
@@ -703,7 +989,7 @@ static struct critnib_leaf *find_ge(struct critnib_node *__restrict n,
 
     for (; nib < NIB; nib++) {
         struct critnib_node *m;
-        load(&n->child[nib + 1], &m);
+        utils_atomic_load_acquire_ptr((void **)&n->child[nib + 1], (void **)&m);
         if (m) {
             n = m;
             if (is_leaf(n)) {
@@ -719,14 +1005,26 @@ static struct critnib_leaf *find_ge(struct critnib_node *__restrict n,
 
 /*
  * critnib_find -- parametrized query, returns 1 if found
+ *
+ * ref - returns a reference to the returned value that must be released
+ *       with critnib_release() when it is no longer needed,
+ *       critnib_find() returns 0 if ref is NULL
  */
 int critnib_find(struct critnib *c, uintptr_t key, enum find_dir_t dir,
-                 uintptr_t *rkey, void **rvalue) {
+                 uintptr_t *rkey, void **rvalue, void **ref) {
     uint64_t wrs1, wrs2;
     struct critnib_leaf *k;
     uintptr_t _rkey = (uintptr_t)0x0;
     void **_rvalue = NULL;
 
+    if (!c || (c->cb_free_leaf && !ref)) {
+        return 0;
+    }
+
+    if (ref) {
+        *ref = NULL;
+    }
+
     /* <42 ≡ ≤41 */
     if (dir < -1) {
         if (!key) {
@@ -741,9 +1039,9 @@ int critnib_find(struct critnib *c, uintptr_t key, enum find_dir_t dir,
     }
 
     do {
-        load64(&c->remove_count, &wrs1);
+        utils_atomic_load_acquire_u64(&c->remove_count, &wrs1);
         struct critnib_node *n;
-        load(&c->root, &n);
+        utils_atomic_load_acquire_ptr((void **)&c->root, (void **)&n);
 
         if (dir < 0) {
             k = find_le(n, key);
@@ -751,20 +1049,34 @@ int critnib_find(struct critnib *c, uintptr_t key, enum find_dir_t dir,
             k = find_ge(n, key);
         } else {
             while (n && !is_leaf(n)) {
-                load(&n->child[slice_index(key, n->shift)], &n);
+                utils_atomic_load_acquire_ptr(
+                    (void **)&n->child[slice_index(key, n->shift)],
+                    (void **)&n);
             }
 
+            word kkey;
             struct critnib_leaf *kk = to_leaf(n);
-            k = (n && kk->key == key) ? kk : NULL;
+            utils_atomic_load_acquire_u64((uint64_t *)&kk->key,
+                                          (uint64_t *)&kkey);
+            k = (n && kkey == key) ? kk : NULL;
         }
         if (k) {
-            _rkey = k->key;
-            _rvalue = k->value;
+            utils_atomic_load_acquire_u64((uint64_t *)&k->key,
+                                          (uint64_t *)&_rkey);
+            utils_atomic_load_acquire_ptr(&k->value, (void **)&_rvalue);
         }
-        load64(&c->remove_count, &wrs2);
+        utils_atomic_load_acquire_u64(&c->remove_count, &wrs2);
     } while (wrs1 + DELETED_LIFE <= wrs2);
 
     if (k) {
+        if (c->cb_free_leaf) {
+            if (increment_ref_count(k)) {
+                return 0;
+            }
+
+            *ref = k;
+        }
+
         if (rkey) {
             *rkey = _rkey;
         }
@@ -782,13 +1094,18 @@ int critnib_find(struct critnib *c, uintptr_t key, enum find_dir_t dir,
  *
  * If func() returns non-zero, the search is aborted.
  */
-static int iter(struct critnib_node *__restrict n, word min, word max,
+static int iter(struct critnib_node *__restrict n, const word min,
+                const word max,
                 int (*func)(word key, void *value, void *privdata),
                 void *privdata) {
     if (is_leaf(n)) {
-        word k = to_leaf(n)->key;
+        word k;
+        void *value;
+        utils_atomic_load_acquire_u64((uint64_t *)&to_leaf(n)->key,
+                                      (uint64_t *)&k);
+        utils_atomic_load_acquire_ptr(&to_leaf(n)->value, &value);
         if (k >= min && k <= max) {
-            return func(to_leaf(n)->key, to_leaf(n)->value, privdata);
+            return func(k, value, privdata);
         }
         return 0;
     }
@@ -813,9 +1130,21 @@ static int iter(struct critnib_node *__restrict n, word min, word max,
 void critnib_iter(critnib *c, uintptr_t min, uintptr_t max,
                   int (*func)(uintptr_t key, void *value, void *privdata),
                   void *privdata) {
+    bool wasIterating = false;
     utils_mutex_lock(&c->mutex);
     if (c->root) {
         iter(c->root, min, max, func, privdata);
+        wasIterating = true;
     }
     utils_mutex_unlock(&c->mutex);
+    if (!wasIterating) {
+        LOG_DEBUG("there was no root, iterating critnib: %p was skipped",
+                  (void *)c);
+    }
+}
+
+void critnib_iter_all(critnib *c,
+                      int (*func)(uintptr_t key, void *value, void *privdata),
+                      void *privdata) {
+    critnib_iter(c, 0, (uintptr_t)-1, func, privdata);
 }
diff --git a/src/critnib/critnib.h b/src/critnib/critnib.h
index e03780374c..c9f215d079 100644
--- a/src/critnib/critnib.h
+++ b/src/critnib/critnib.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -18,6 +18,7 @@ extern "C" {
 
 struct critnib;
 typedef struct critnib critnib;
+typedef void (*free_leaf_t)(void *leaf_allocator, void *ptr);
 
 enum find_dir_t {
     FIND_L = -2,
@@ -27,18 +28,35 @@ enum find_dir_t {
     FIND_G = +2,
 };
 
-critnib *critnib_new(void);
+critnib *critnib_new(free_leaf_t cb_free_leaf, void *leaf_allocator);
 void critnib_delete(critnib *c);
 
 int critnib_insert(critnib *c, uintptr_t key, void *value, int update);
-void *critnib_remove(critnib *c, uintptr_t key);
-void *critnib_get(critnib *c, uintptr_t key);
-void *critnib_find_le(critnib *c, uintptr_t key);
-int critnib_find(critnib *c, uintptr_t key, enum find_dir_t dir,
-                 uintptr_t *rkey, void **rvalue);
 void critnib_iter(critnib *c, uintptr_t min, uintptr_t max,
                   int (*func)(uintptr_t key, void *value, void *privdata),
                   void *privdata);
+void critnib_iter_all(critnib *c,
+                      int (*func)(uintptr_t key, void *value, void *privdata),
+                      void *privdata);
+
+int critnib_remove_release(critnib *c, uintptr_t key);
+
+/*
+ * When cb_free_leaf() is SET in critnib_new() the following 4 functions:
+ * - critnib_remove(),
+ * - critnib_get(),
+ * - critnib_find_le() and
+ * - critnib_find()
+ * return a reference (void *ref) to the returned value,
+ * that MUST be released by calling critnib_release()
+ * when it is no longer used and can be freed using the cb_free_leaf() callback.
+ */
+void *critnib_remove(critnib *c, uintptr_t key, void **ref);
+void *critnib_get(critnib *c, uintptr_t key, void **ref);
+void *critnib_find_le(critnib *c, uintptr_t key, void **ref);
+int critnib_find(critnib *c, uintptr_t key, enum find_dir_t dir,
+                 uintptr_t *rkey, void **rvalue, void **ref);
+int critnib_release(struct critnib *c, void *ref);
 
 #ifdef __cplusplus
 }
diff --git a/src/ctl/ctl.c b/src/ctl/ctl.c
new file mode 100644
index 0000000000..2edca576a0
--- /dev/null
+++ b/src/ctl/ctl.c
@@ -0,0 +1,865 @@
+/*
+ *
+ * Copyright (C) 2016-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+// This file was originally under following license:
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2024, Intel Corporation */
+
+/*
+ * ctl.c -- implementation of the interface for examination and modification of
+ *    the library's internal state
+ */
+
+#include <ctype.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <umf/base.h>
+
+#include "base_alloc/base_alloc_global.h"
+#include "ctl_internal.h"
+#include "uthash/utlist.h"
+#include "utils/utils_common.h"
+#include "utils_log.h"
+
+#ifdef _WIN32
+#define strtok_r strtok_s
+#endif
+
+#define MAX_CONFIG_FILE_LEN (1 << 20) /* 1 megabyte */
+
+#define CTL_STRING_QUERY_SEPARATOR ";"
+#define CTL_NAME_VALUE_SEPARATOR "="
+#define CTL_QUERY_NODE_SEPARATOR "."
+#define CTL_VALUE_ARG_SEPARATOR ","
+#define CTL_WILDCARD "{}"
+
+/* GLOBAL TREE */
+static int ctl_global_first_free = 0;
+static umf_ctl_node_t CTL_NODE(global)[CTL_MAX_ENTRIES];
+
+static void *(*ctl_malloc_fn)(size_t) = NULL;
+static void (*ctl_free_fn)(void *) = NULL;
+
+void ctl_init(void *(*Malloc)(size_t), void (*Free)(void *)) {
+    if (Malloc) {
+        ctl_malloc_fn = Malloc;
+    }
+    if (Free) {
+        ctl_free_fn = Free;
+    }
+}
+
+typedef struct optional_umf_result_t {
+    bool is_valid;
+    umf_result_t value;
+} optional_umf_result_t;
+
+void *Zalloc(size_t sz) {
+    void *ptr = ctl_malloc_fn(sz);
+    if (ptr) {
+        memset(ptr, 0, sz);
+    }
+    return ptr;
+}
+
+char *Strdup(const char *s) {
+    size_t len = strlen(s) + 1;
+    char *p = ctl_malloc_fn(len);
+    if (p) {
+        memcpy(p, s, len);
+    }
+    return p;
+}
+
+// this must be a macro as passing a va_list to a function makes the va_list
+// in the original function indeterminate if the function invokes the va_arg macro.
+// Ref 7.15/3 of C99 standard
+#define pop_va_list(va, ctl_argument, output)                                  \
+    do {                                                                       \
+        switch (ctl_argument->type) {                                          \
+        case CTL_ARG_TYPE_BOOLEAN: {                                           \
+            int b = va_arg(va, int);                                           \
+            *(bool *)output = b ? true : false;                                \
+            break;                                                             \
+        }                                                                      \
+        case CTL_ARG_TYPE_STRING: {                                            \
+            char *str = va_arg(va, char *);                                    \
+            snprintf((char *)output, ctl_argument->dest_size, "%s", str);      \
+            break;                                                             \
+        }                                                                      \
+        case CTL_ARG_TYPE_INT: {                                               \
+            int i = va_arg(va, int);                                           \
+            *(int *)output = i;                                                \
+            break;                                                             \
+        }                                                                      \
+        case CTL_ARG_TYPE_LONG_LONG: {                                         \
+            long long ll = va_arg(va, long long);                              \
+            *(long long *)output = ll;                                         \
+            break;                                                             \
+        }                                                                      \
+        case CTL_ARG_TYPE_UNSIGNED_LONG_LONG: {                                \
+            unsigned long long ll = va_arg(va, unsigned long long);            \
+            *(unsigned long long *)output = ll;                                \
+            break;                                                             \
+        }                                                                      \
+        case CTL_ARG_TYPE_PTR: {                                               \
+            void *ptr = va_arg(va, void *);                                    \
+            *(uintptr_t *)output = (uintptr_t)ptr;                             \
+            break;                                                             \
+        }                                                                      \
+        default:                                                               \
+            LOG_FATAL("Unknown ctl argument type %d", ctl_argument->type);     \
+            abort();                                                           \
+        }                                                                      \
+    } while (false)
+
+/*
+ * ctl_delete_indexes --
+ *    (internal) removes and frees all entries on the index list
+ */
+static void ctl_delete_indexes(umf_ctl_index_utlist_t *indexes) {
+    if (!indexes) {
+        return;
+    }
+    umf_ctl_index_utlist_t *elem, *tmp;
+    LL_FOREACH_SAFE(indexes, elem, tmp) {
+        LL_DELETE(indexes, elem);
+        if (elem) {
+            if (elem->arg) {
+                ctl_free_fn(elem->arg);
+            }
+            ctl_free_fn(elem);
+        }
+    }
+}
+
+/*
+ * ctl_query_cleanup_real_args -- (internal) cleanups relevant argument
+ *    structures allocated as a result of the get_real_args call
+ */
+static void ctl_query_cleanup_real_args(const umf_ctl_node_t *n, void *real_arg,
+                                        umf_ctl_query_source_t source) {
+    /* suppress unused-parameter errors */
+    (void)n;
+
+    switch (source) {
+    case CTL_QUERY_CONFIG_INPUT:
+        ctl_free_fn(real_arg);
+        break;
+    case CTL_QUERY_PROGRAMMATIC:
+        break;
+    default:
+        break;
+    }
+}
+
+/*
+ * ctl_parse_args -- (internal) parses a string argument based on the node
+ *    structure
+ */
+static void *ctl_parse_args(const struct ctl_argument *arg_proto, char *arg) {
+    char *dest_arg = ctl_malloc_fn(arg_proto->dest_size);
+    if (dest_arg == NULL) {
+        return NULL;
+    }
+
+    char *sptr = NULL;
+    char *arg_sep = strtok_r(arg, CTL_VALUE_ARG_SEPARATOR, &sptr);
+    for (const struct ctl_argument_parser *p = arg_proto->parsers;
+         p->parser != NULL; ++p) {
+
+        if (p->parser(arg_sep, dest_arg + p->dest_offset, p->dest_size) != 0) {
+            goto error_parsing;
+        }
+
+        arg_sep = strtok_r(NULL, CTL_VALUE_ARG_SEPARATOR, &sptr);
+    }
+
+    return dest_arg;
+
+error_parsing:
+    ctl_free_fn(dest_arg);
+    return NULL;
+}
+
+/*
+ * ctl_query_get_real_args -- (internal) returns a pointer with actual argument
+ *    structure as required by the node callback
+ */
+static void *ctl_query_get_real_args(const umf_ctl_node_t *n, void *write_arg,
+                                     umf_ctl_query_source_t source,
+                                     size_t *size) {
+    void *real_arg = NULL;
+    switch (source) {
+    case CTL_QUERY_CONFIG_INPUT:
+        real_arg = ctl_parse_args(n->arg, write_arg);
+        *size = n->arg->dest_size;
+        break;
+    case CTL_QUERY_PROGRAMMATIC:
+        real_arg = write_arg;
+        break;
+    default:
+        break;
+    }
+
+    return real_arg;
+}
+
+/*
+ * ctl_exec_query_read -- (internal) calls the read callback of a node
+ */
+static umf_result_t ctl_exec_query_read(void *ctx, const umf_ctl_node_t *n,
+                                        umf_ctl_query_source_t source,
+                                        void *arg, size_t size,
+                                        umf_ctl_index_utlist_t *indexes) {
+    assert(n != NULL);
+
+    if (n->read_cb == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (arg == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    return n->read_cb(ctx, source, arg, size, indexes);
+}
+
+/*
+ * ctl_exec_query_write -- (internal) calls the write callback of a node
+ */
+static umf_result_t ctl_exec_query_write(void *ctx, const umf_ctl_node_t *n,
+                                         umf_ctl_query_source_t source,
+                                         void *arg, size_t size,
+                                         umf_ctl_index_utlist_t *indexes) {
+    assert(n != NULL);
+
+    if (n->write_cb == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (arg == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    void *real_arg = ctl_query_get_real_args(n, arg, source, &size);
+    if (real_arg == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_result_t ret = n->write_cb(ctx, source, real_arg, size, indexes);
+    ctl_query_cleanup_real_args(n, real_arg, source);
+
+    return ret;
+}
+
+/*
+ * ctl_exec_query_runnable -- (internal) calls the run callback of a node
+ */
+static umf_result_t ctl_exec_query_runnable(void *ctx, const umf_ctl_node_t *n,
+                                            umf_ctl_query_source_t source,
+                                            void *arg, size_t size,
+                                            umf_ctl_index_utlist_t *indexes) {
+    assert(n != NULL);
+
+    if (n->runnable_cb == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    return n->runnable_cb(ctx, source, arg, size, indexes);
+}
+
+static umf_result_t
+ctl_exec_query_subtree(void *ctx, const umf_ctl_node_t *n,
+                       umf_ctl_query_source_t source, void *arg, size_t size,
+                       umf_ctl_index_utlist_t *indexes, const char *extra_name,
+                       umf_ctl_query_type_t query_type, va_list args) {
+    assert(n != NULL);
+
+    if (n->subtree_cb == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    return n->subtree_cb(ctx, source, arg, size, indexes, extra_name,
+                         query_type, args);
+}
+
+/*
+ * ctl_find_and_execulte_node -- (internal) searches for a matching entry point in the
+ *    provided nodes
+ *
+ * Path offset is used to return the offset of the path in the query string.
+ * The caller is responsible for freeing all of the allocated indexes,
+ * regardless of the return value.
+ */
+
+static optional_umf_result_t
+ctl_find_and_execute_node(const umf_ctl_node_t *nodes, void *ctx,
+                          umf_ctl_query_source_t source, const char *path,
+                          umf_ctl_query_type_t type, void *arg, size_t size,
+                          va_list args) {
+    assert(nodes != NULL);
+    assert(path != NULL);
+
+    const umf_ctl_node_t *n = NULL;
+    optional_umf_result_t ret;
+    size_t path_offset = 0;
+    ret.is_valid = true;
+    ret.value = UMF_RESULT_SUCCESS;
+    char *sptr = NULL;
+    char *parse_str = Strdup(path);
+    if (parse_str == NULL) {
+        ret.is_valid = false;
+        return ret;
+    }
+
+    umf_ctl_index_utlist_t *indexes = Zalloc(sizeof(*indexes));
+    if (!indexes) {
+        ret.value = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        return ret;
+    }
+    char *node_name = strtok_r(parse_str, CTL_QUERY_NODE_SEPARATOR, &sptr);
+
+    /*
+     * Go through the string and separate tokens that correspond to nodes
+     * in the main ctl tree.
+     */
+    while (node_name != NULL) {
+        char *next_node = strtok_r(NULL, CTL_QUERY_NODE_SEPARATOR, &sptr);
+        path_offset = node_name - parse_str;
+        if (n != NULL && n->type == CTL_NODE_SUBTREE) {
+            // if a subtree occurs, the subtree handler should be called
+            break;
+        }
+
+        if (strcmp(node_name, CTL_WILDCARD) == 0) {
+            if (source == CTL_QUERY_CONFIG_INPUT) {
+                LOG_ERR("ctl {} wildcard is not supported for config input");
+                goto error;
+            }
+            // node is wildcard - we are expecting standard node name here, so lets
+            // pop next node_name from the va_list
+            node_name = va_arg(args, char *);
+        }
+
+        if (!nodes) {
+            goto error;
+        }
+
+        for (n = &nodes[0]; n->type != CTL_NODE_UNKNOWN; ++n) {
+            if (n->name && strcmp(n->name, node_name) == 0) {
+                if (n->type == CTL_NODE_LEAF && next_node != NULL) {
+                    // this is not the last node in the query, so it couldn't be leaf
+                    continue;
+                }
+                if (n->type != CTL_NODE_LEAF && next_node == NULL) {
+                    // this is the last node in the query, so it must be a leaf
+                    continue;
+                }
+                break;
+            }
+        }
+
+        if (n->type == CTL_NODE_UNKNOWN) {
+            goto error;
+        }
+
+        if (n->arg != NULL && n->type == CTL_NODE_NAMED) {
+            if (next_node == NULL) {
+                // if the node has an argument, but no next node, then it is an error
+                goto error;
+            }
+
+            char *node_arg = ctl_malloc_fn(n->arg->dest_size);
+            if (node_arg == NULL) {
+                goto error;
+            }
+
+            // Parse this argument. It might contain "struct" which is series of fields separated by comma.
+            // each field contains separate parser in the parsers array.
+            for (const struct ctl_argument_parser *p = n->arg->parsers;
+                 p->dest_size != 0; ++p) {
+
+                if (next_node && strcmp(next_node, CTL_WILDCARD) == 0) {
+                    if (source == CTL_QUERY_CONFIG_INPUT) {
+                        ctl_free_fn(node_arg);
+                        LOG_ERR("ctl {} wildcard is not supported for config "
+                                "input");
+                        goto error;
+                    }
+
+                    if (p->type == CTL_ARG_TYPE_UNKNOWN) {
+                        ctl_free_fn(node_arg);
+                        LOG_ERR("ctl {} wildcard is not supported for node: %s",
+                                node_name);
+                        goto error;
+                    }
+                    char *output = node_arg + p->dest_offset;
+                    pop_va_list(args, p, output);
+                } else {
+                    if (!p->parser) {
+                        LOG_ERR(
+                            "this node can be passed only as {} wildcard: %s",
+                            next_node);
+                        ctl_free_fn(node_arg);
+                        goto error;
+                    }
+                    int r = p->parser(next_node, node_arg + p->dest_offset,
+                                      p->dest_size);
+                    if (r < 0) {
+                        // Parsing failed — cleanup and propagate error
+                        ctl_free_fn(node_arg);
+                        goto error;
+                    } else if (r > 0) {
+                        // Parser did not consume next_node, which means this argument is optional
+                        // and not present. Optional arguments are always at the end of the expected
+                        // sequence, so we can safely stop parsing here.
+                        //
+                        // Example:
+                        // Given two paths:
+                        // "umf.pool.by_name.name.stats.allocs"
+                        // "umf.pool.by_name.name.1.stats.allocs"
+                        // The parser for 'by_name' expects the next node is string followed by optional
+                        // integer index, if its sees "stats" instead of integer, like in second example
+                        // it will return >0 to signal that the optional
+                        // integer argument is not present.
+                        // This allows the remaining nodes ("stats.allocs") to be parsed normally
+                        // without treating "stats" as part of 'by_name'.
+                        break;
+                    }
+                }
+                // we parsed next_node as an argument so we next one
+                next_node = strtok_r(NULL, CTL_QUERY_NODE_SEPARATOR, &sptr);
+            }
+
+            umf_ctl_index_utlist_t *entry = NULL;
+            entry = ctl_malloc_fn(sizeof(*entry));
+            if (entry == NULL) {
+                ctl_free_fn(node_arg);
+                goto error;
+            }
+
+            entry->arg = node_arg;
+            entry->name = node_name;
+            entry->arg_size = n->arg->dest_size;
+
+            LL_APPEND(indexes, entry);
+
+            if (next_node == NULL) {
+                // last node was a node with arg, but there is no next mode.
+                // check if there is nameless leaf on next level
+                for (n = n->children; n->type != CTL_NODE_UNKNOWN; ++n) {
+                    if (n->type == CTL_NODE_LEAF &&
+                        strcmp(n->name, CTL_STR(CTL_NONAME)) == 0) {
+                        // found a nameless leaf, so we can return it
+                        break;
+                    }
+                }
+
+                if (n->type == CTL_NODE_UNKNOWN) {
+                    goto error;
+                }
+            } else if (n->children) {
+                // if there is nameless subtree in the next node we should also stop here.
+                // This is the HACK which forbids mixing subtree and normal nodes as a child of the
+                // node with an argument. Probably no one will ever need to do so, so this is fine.
+                for (const umf_ctl_node_t *m = n->children;
+                     m->type != CTL_NODE_UNKNOWN; ++m) {
+                    if (m->type == CTL_NODE_SUBTREE &&
+                        strcmp(m->name, CTL_STR(CTL_NONAME)) == 0) {
+                        // found a nameless subtree, so lets assign it as a current node
+                        n = m;
+                        break;
+                    }
+                }
+            }
+        }
+
+        nodes = n->children;
+        node_name = next_node;
+    }
+
+    // if the appropriate node (leaf or subtree) is not found, then return error
+    if (n == NULL ||
+        (n->type != CTL_NODE_LEAF && n->type != CTL_NODE_SUBTREE)) {
+        ret.value = UMF_RESULT_ERROR_INVALID_CTL_PATH;
+        goto out;
+    }
+
+    if (n->type == CTL_NODE_SUBTREE) {
+        // if the node is a subtree, then we need to call the subtree handler
+        ret.value =
+            ctl_exec_query_subtree(ctx, n, source, arg, size, indexes->next,
+                                   path + path_offset, type, args);
+    } else {
+        switch (type) {
+        case CTL_QUERY_READ:
+            ret.value =
+                ctl_exec_query_read(ctx, n, source, arg, size, indexes->next);
+            break;
+        case CTL_QUERY_WRITE:
+            ret.value =
+                ctl_exec_query_write(ctx, n, source, arg, size, indexes->next);
+            break;
+        case CTL_QUERY_RUNNABLE:
+            ret.value = ctl_exec_query_runnable(ctx, n, source, arg, size,
+                                                indexes->next);
+            break;
+        }
+    }
+out:
+    ctl_free_fn(parse_str);
+    ctl_delete_indexes(indexes);
+    return ret;
+
+error:
+    ctl_delete_indexes(indexes);
+    ctl_free_fn(parse_str);
+    ret.is_valid = false;
+    return ret;
+}
+
+/*
+ * ctl_query -- (internal) parses the path and calls the appropriate methods
+ *    from the ctl tree
+ */
+umf_result_t ctl_query(struct ctl *ctl, void *ctx,
+                       umf_ctl_query_source_t source, const char *path,
+                       umf_ctl_query_type_t type, void *arg, size_t size,
+                       va_list args) {
+    if (path == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    va_list args_copy;
+    va_copy(args_copy, args);
+
+    optional_umf_result_t ret = ctl_find_and_execute_node(
+        CTL_NODE(global), ctx, source, path, type, arg, size, args_copy);
+
+    if (ret.is_valid == false && ctl) {
+        ret = ctl_find_and_execute_node(ctl->root, ctx, source, path, type, arg,
+                                        size, args);
+    }
+
+    va_end(args_copy);
+
+    return ret.is_valid ? ret.value : UMF_RESULT_ERROR_INVALID_CTL_PATH;
+}
+
+/*
+ * ctl_register_module_node -- adds a new node to the CTL tree root.
+ */
+void ctl_register_module_node(struct ctl *c, const char *name,
+                              umf_ctl_node_t *n) {
+    umf_ctl_node_t *nnode = c == NULL
+                                ? &CTL_NODE(global)[ctl_global_first_free++]
+                                : &c->root[c->first_free++];
+
+    nnode->children = n;
+    nnode->type = CTL_NODE_NAMED;
+    nnode->name = name;
+}
+
+/*
+ * ctl_parse_query -- (internal) splits an entire query string
+ *    into path and value
+ */
+static int ctl_parse_query(char *qbuf, char **path, char **value) {
+    if (qbuf == NULL) {
+        return -1;
+    }
+
+    char *sptr = NULL;
+    *path = strtok_r(qbuf, CTL_NAME_VALUE_SEPARATOR, &sptr);
+    if (*path == NULL) {
+        return -1;
+    }
+
+    *value = strtok_r(NULL, CTL_NAME_VALUE_SEPARATOR, &sptr);
+    if (*value == NULL) {
+        return -1;
+    }
+
+    /* the value itself mustn't include CTL_NAME_VALUE_SEPARATOR */
+    char *extra = strtok_r(NULL, CTL_NAME_VALUE_SEPARATOR, &sptr);
+    if (extra != NULL) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * ctl_load_config_helper -- windows do not allow to use uninitialized va_list,
+ * so this function allows us to initialize empty one
+ */
+static umf_result_t ctl_load_config_helper(struct ctl *ctl, void *ctx,
+                                           char *buf, ...) {
+    umf_result_t ret = UMF_RESULT_SUCCESS;
+    char *sptr = NULL; /* for internal use of strtok */
+    char *path;
+    char *value;
+    char *qbuf = strtok_r(buf, CTL_STRING_QUERY_SEPARATOR, &sptr);
+    va_list empty_args;
+    va_start(empty_args, buf);
+    while (qbuf != NULL) {
+        int parse_res = ctl_parse_query(qbuf, &path, &value);
+        if (parse_res != 0) {
+            ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
+            goto end;
+        }
+        // we do not need to copy va_list before call as we know that for query_config_input
+        // ctl_query will not call va_arg on it. Ref 7.15/3 of C99 standard
+        ret = ctl_query(ctl, ctx, CTL_QUERY_CONFIG_INPUT, path, CTL_QUERY_WRITE,
+                        value, strlen(value) + 1, empty_args);
+
+        if (ret != UMF_RESULT_SUCCESS && ctx != NULL) {
+            goto end;
+        }
+
+        qbuf = strtok_r(NULL, CTL_STRING_QUERY_SEPARATOR, &sptr);
+    }
+
+end:
+    va_end(empty_args);
+    return ret;
+}
+
+/*
+ * ctl_load_config -- executes the entire query collection from a provider
+ */
+static umf_result_t ctl_load_config(struct ctl *ctl, void *ctx, char *buf) {
+    return ctl_load_config_helper(ctl, ctx, buf);
+}
+
+/*
+ * ctl_load_config_from_string -- loads obj configuration from string
+ */
+umf_result_t ctl_load_config_from_string(struct ctl *ctl, void *ctx,
+                                         const char *cfg_string) {
+    char *buf = Strdup(cfg_string);
+    if (buf == NULL) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    umf_result_t ret = ctl_load_config(ctl, ctx, buf);
+
+    ctl_free_fn(buf);
+    return ret;
+}
+
+/*
+ * ctl_load_config_from_file -- loads obj configuration from file
+ *
+ * This function opens up the config file, allocates a buffer of size equal to
+ * the size of the file, reads its content and sanitizes it for ctl_load_config.
+ */
+umf_result_t ctl_load_config_from_file(struct ctl *ctl, void *ctx,
+                                       const char *cfg_file) {
+    umf_result_t ret = UMF_RESULT_ERROR_UNKNOWN;
+    long fsize = 0;
+    char *buf = NULL;
+
+    FILE *fp = fopen(cfg_file, "r");
+    if (fp == NULL) {
+        return ret;
+    }
+
+    int err;
+    if ((err = fseek(fp, 0, SEEK_END)) != 0) {
+        goto error_file_parse;
+    }
+
+    fsize = ftell(fp);
+    if (fsize == -1) {
+        goto error_file_parse;
+    }
+
+    if (fsize > MAX_CONFIG_FILE_LEN) {
+        goto error_file_parse;
+    }
+
+    if ((err = fseek(fp, 0, SEEK_SET)) != 0) {
+        goto error_file_parse;
+    }
+
+    buf = Zalloc((size_t)fsize + 1); /* +1 for NULL-termination */
+    if (buf == NULL) {
+        goto error_file_parse;
+    }
+
+    {
+        size_t bufpos = 0;
+        int c;
+        int is_comment_section = 0;
+        while ((c = fgetc(fp)) != EOF) {
+            if (c == '#') {
+                is_comment_section = 1;
+            } else if (c == '\n') {
+                is_comment_section = 0;
+            } else if (!is_comment_section && !isspace(c)) {
+                buf[bufpos++] = (char)c;
+            }
+        }
+    }
+
+    ret = ctl_load_config(ctl, ctx, buf);
+
+    ctl_free_fn(buf);
+
+error_file_parse:
+    (void)fclose(fp);
+    return ret;
+}
+
+/*
+ * ctl_parse_ull -- (internal) parses and returns an unsigned long long
+ */
+static unsigned long long ctl_parse_ull(const char *str) {
+    char *endptr;
+    int olderrno = errno;
+    errno = 0;
+    unsigned long long val = strtoull(str, &endptr, 0);
+    if (endptr == str || errno != 0) {
+        return ULLONG_MAX;
+    }
+    errno = olderrno;
+
+    return val;
+}
+
+/*
+ * ctl_parse_ll -- (internal) parses and returns a long long signed integer
+ */
+static long long ctl_parse_ll(const char *str) {
+    char *endptr;
+    int olderrno = errno;
+    errno = 0;
+    long long val = strtoll(str, &endptr, 0);
+    if (endptr == str || errno != 0) {
+        return LLONG_MIN;
+    }
+    errno = olderrno;
+
+    return val;
+}
+
+/*
+ * ctl_arg_boolean -- checks whether the provided argument contains
+ *    either a 1 or y or Y.
+ */
+int ctl_arg_boolean(const void *arg, void *dest, size_t dest_size) {
+    /* suppress unused-parameter errors */
+    (void)dest_size;
+    if (!arg) {
+        return -1;
+    }
+
+    int *intp = dest;
+    char in = ((const char *)arg)[0];
+
+    if (tolower(in) == 'y' || in == '1') {
+        *intp = 1;
+        return 0;
+    } else if (tolower(in) == 'n' || in == '0') {
+        *intp = 0;
+        return 0;
+    }
+
+    return -1;
+}
+
+/*
+ * ctl_arg_unsigned -- parses unsigned integer argument
+ */
+int ctl_arg_unsigned(const void *arg, void *dest, size_t dest_size) {
+    if (!arg) {
+        return -1;
+    }
+
+    unsigned long long val = ctl_parse_ull(arg);
+    if (val == ULLONG_MAX) {
+        return -1;
+    }
+
+    switch (dest_size) {
+    case sizeof(unsigned int):
+        if (val > UINT_MAX) {
+            return -1;
+        }
+        *(unsigned int *)dest = (unsigned int)val;
+        break;
+    case sizeof(unsigned long long):
+        *(unsigned long long *)dest = val;
+        break;
+    case sizeof(uint8_t):
+        if (val > UINT8_MAX) {
+            return -1;
+        }
+        *(uint8_t *)dest = (uint8_t)val;
+        break;
+    default:
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * ctl_arg_integer -- parses signed integer argument
+ */
+int ctl_arg_integer(const void *arg, void *dest, size_t dest_size) {
+    if (!arg) {
+        return -1;
+    }
+    long long val = ctl_parse_ll(arg);
+    if (val == LLONG_MIN) {
+        return -1;
+    }
+
+    switch (dest_size) {
+    case sizeof(int):
+        if (val > INT_MAX || val < INT_MIN) {
+            return -1;
+        }
+        *(int *)dest = (int)val;
+        break;
+    case sizeof(long long):
+        *(long long *)dest = val;
+        break;
+    default:
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * ctl_arg_string -- verifies length and copies a string argument into a zeroed
+ *    buffer
+ */
+int ctl_arg_string(const void *arg, void *dest, size_t dest_size) {
+    if (!arg) {
+        return -1;
+    }
+
+    /* check if the incoming string is longer or equal to dest_size */
+    if (strnlen(arg, dest_size) == dest_size) {
+        return -1;
+    }
+
+    strncpy(dest, arg, dest_size);
+
+    return 0;
+}
diff --git a/src/ctl/ctl_defaults.c b/src/ctl/ctl_defaults.c
new file mode 100644
index 0000000000..57799d30d2
--- /dev/null
+++ b/src/ctl/ctl_defaults.c
@@ -0,0 +1,146 @@
+/*
+ *
+ * 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 <string.h>
+
+#include "base_alloc_global.h"
+#include "ctl_defaults.h"
+#include "utils_concurrency.h"
+#include "utils_log.h"
+#include "utlist.h"
+
+static umf_result_t default_ctl_helper(ctl_ext_ctl_fn fn, void *ctl,
+                                       umf_ctl_query_source_t source,
+                                       const char *name, void *arg, size_t size,
+                                       ...) {
+    va_list empty_args;
+    va_start(empty_args, size);
+    umf_result_t ret =
+        fn(ctl, source, name, arg, size, CTL_QUERY_WRITE, empty_args);
+    va_end(empty_args);
+    return ret;
+}
+
+umf_result_t ctl_default_subtree(ctl_default_entry_t **list, utils_mutex_t *mtx,
+                                 umf_ctl_query_source_t source, void *arg,
+                                 size_t size, const char *extra_name,
+                                 umf_ctl_query_type_t queryType) {
+    (void)source;
+    if (strstr(extra_name, "{}") != NULL) {
+        LOG_ERR("%s, default setting does not support wildcard parameters {}",
+                extra_name);
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+
+    utils_mutex_lock(mtx);
+
+    ctl_default_entry_t *entry = NULL;
+    LL_FOREACH(*list, entry) {
+        if (strcmp(entry->name, extra_name) == 0) {
+            break;
+        }
+    }
+
+    if (queryType == CTL_QUERY_WRITE) {
+        bool is_new_entry = false;
+        if (!entry) {
+            entry = umf_ba_global_alloc(sizeof(*entry));
+            if (!entry) {
+                utils_mutex_unlock(mtx);
+                return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+            }
+            entry->name = NULL;
+            entry->value = NULL;
+            entry->next = NULL;
+            is_new_entry = true;
+        }
+
+        char *new_name = umf_ba_global_strdup(extra_name);
+        if (!new_name) {
+            utils_mutex_unlock(mtx);
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        }
+
+        if (entry->name) {
+            umf_ba_global_free(entry->name);
+        }
+        entry->name = new_name;
+
+        void *new_value = NULL;
+        if (size > 0) {
+            new_value = umf_ba_global_alloc(size);
+            if (!new_value) {
+                utils_mutex_unlock(mtx);
+                return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+            }
+            memcpy(new_value, arg, size);
+        }
+        if (entry->value) {
+            umf_ba_global_free(entry->value);
+        }
+        entry->value = new_value;
+        entry->value_size = size;
+        entry->source = source;
+
+        if (is_new_entry) {
+            LL_APPEND(*list, entry);
+        }
+    } else if (queryType == CTL_QUERY_READ) {
+        if (!entry) {
+            LOG_WARN("Wrong path name: %s", extra_name);
+            utils_mutex_unlock(mtx);
+            return UMF_RESULT_ERROR_INVALID_CTL_PATH;
+        }
+
+        if (entry->value_size > size) {
+            LOG_ERR("Provided buffer size %zu is smaller than field size %zu",
+                    size, entry->value_size);
+            utils_mutex_unlock(mtx);
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+        memcpy(arg, entry->value, entry->value_size);
+    }
+
+    utils_mutex_unlock(mtx);
+    return UMF_RESULT_SUCCESS;
+}
+
+void ctl_default_apply(ctl_default_entry_t *list, const char *pname,
+                       ctl_ext_ctl_fn ext_ctl, void *priv) {
+    if (!pname || !ext_ctl) {
+        return;
+    }
+
+    size_t pname_len = strlen(pname);
+    ctl_default_entry_t *it = NULL;
+    LL_FOREACH(list, it) {
+        if (strlen(it->name) > pname_len + 1 &&
+            strncmp(it->name, pname, pname_len) == 0 &&
+            it->name[pname_len] == '.') {
+            const char *ctl_name = it->name + pname_len + 1;
+            default_ctl_helper(ext_ctl, priv, it->source, ctl_name, it->value,
+                               it->value_size);
+        }
+    }
+}
+
+void ctl_default_destroy(ctl_default_entry_t **list, utils_mutex_t *mtx) {
+    utils_mutex_lock(mtx);
+    ctl_default_entry_t *entry = NULL, *tmp = NULL;
+    LL_FOREACH_SAFE(*list, entry, tmp) {
+        LL_DELETE(*list, entry);
+        if (entry->name) {
+            umf_ba_global_free(entry->name);
+        }
+        if (entry->value) {
+            umf_ba_global_free(entry->value);
+        }
+        umf_ba_global_free(entry);
+    }
+    utils_mutex_unlock(mtx);
+}
diff --git a/src/ctl/ctl_defaults.h b/src/ctl/ctl_defaults.h
new file mode 100644
index 0000000000..1da73692ee
--- /dev/null
+++ b/src/ctl/ctl_defaults.h
@@ -0,0 +1,51 @@
+/*
+ *
+ * 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
+ */
+
+#ifndef UMF_CTL_DEFAULTS_H
+#define UMF_CTL_DEFAULTS_H 1
+
+#include <stdarg.h>
+#include <stddef.h>
+
+#include <umf/base.h>
+
+#include "ctl_internal.h"
+#include "utils_concurrency.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct ctl_default_entry_t {
+    char *name;
+    void *value;
+    size_t value_size;
+    umf_ctl_query_source_t source;
+    struct ctl_default_entry_t *next;
+} ctl_default_entry_t;
+
+umf_result_t ctl_default_subtree(ctl_default_entry_t **list, utils_mutex_t *mtx,
+                                 umf_ctl_query_source_t source, void *arg,
+                                 size_t size, const char *extra_name,
+                                 umf_ctl_query_type_t queryType);
+
+typedef umf_result_t (*ctl_ext_ctl_fn)(void *obj, umf_ctl_query_source_t source,
+                                       const char *name, void *arg, size_t size,
+                                       umf_ctl_query_type_t queryType,
+                                       va_list args);
+
+void ctl_default_apply(ctl_default_entry_t *list, const char *pname,
+                       ctl_ext_ctl_fn ext_ctl, void *priv);
+
+void ctl_default_destroy(ctl_default_entry_t **list, utils_mutex_t *mtx);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_CTL_DEFAULTS_H */
diff --git a/src/ctl/ctl_internal.h b/src/ctl/ctl_internal.h
new file mode 100644
index 0000000000..fe6ea2884a
--- /dev/null
+++ b/src/ctl/ctl_internal.h
@@ -0,0 +1,299 @@
+/*
+ *
+ * Copyright (C) 2016-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+// This file was originally under following license:
+/* SPDX-License-Identifier: BSD-3-Clause */
+/* Copyright 2016-2020, Intel Corporation */
+
+/*
+ * ctl_internal.h -- internal declaration of statistics and control related structures
+ */
+
+#ifndef UMF_CTL_INTERNAL_H
+#define UMF_CTL_INTERNAL_H 1
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stddef.h>
+
+#include <umf/memory_pool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CTL_MAX_ENTRIES 100
+
+typedef struct ctl_index_utlist {
+    const char *name;
+    void *arg;
+    size_t arg_size; /* size of the argument */
+    struct ctl_index_utlist *next;
+} umf_ctl_index_utlist_t;
+
+typedef umf_result_t (*node_callback)(void *ctx, umf_ctl_query_source_t source,
+                                      void *arg, size_t size,
+                                      umf_ctl_index_utlist_t *indexes);
+
+typedef umf_result_t (*node_callback_subtree)(
+    void *ctx, umf_ctl_query_source_t source, void *arg, size_t size,
+    umf_ctl_index_utlist_t *indexes, const char *extra_name,
+    umf_ctl_query_type_t query_type, va_list args);
+
+enum ctl_node_type {
+    CTL_NODE_UNKNOWN,
+    CTL_NODE_NAMED,
+    CTL_NODE_LEAF,
+    CTL_NODE_SUBTREE,
+    MAX_CTL_NODE
+};
+
+typedef int (*ctl_arg_parser)(const void *arg, void *dest, size_t dest_size);
+
+typedef enum ctl_arg_type {
+    CTL_ARG_TYPE_UNKNOWN = 0,
+    CTL_ARG_TYPE_BOOLEAN,
+    CTL_ARG_TYPE_STRING,
+    CTL_ARG_TYPE_INT,
+    CTL_ARG_TYPE_LONG_LONG,
+    CTL_ARG_TYPE_UNSIGNED_LONG_LONG,
+    CTL_ARG_TYPE_PTR,
+    MAX_CTL_ARG_TYPE
+} ctl_arg_type_t;
+
+struct ctl_argument_parser {
+    size_t dest_offset;  /* offset of the field inside of the argument */
+    size_t dest_size;    /* size of the field inside of the argument */
+    ctl_arg_type_t type; /* type of the argument */
+    ctl_arg_parser parser;
+};
+
+struct ctl_argument {
+    size_t dest_size;                      /* size of the entire argument */
+    struct ctl_argument_parser parsers[8]; /* array of 'fields' in arg */
+};
+
+#define sizeof_member(type, member) sizeof(((type *)0)->member)
+
+#define CTL_ARG_PARSER(type, vaarg_type, parser)                               \
+    { 0, sizeof(type), vaarg_type, parser }
+
+#define CTL_ARG_PARSER_STRUCT(type, member, vaarg_type, parser)                \
+    { offsetof(type, member), sizeof_member(type, member), vaarg_type, parser }
+
+#define CTL_ARG_PARSER_END                                                     \
+    { 0, 0, 0, NULL }
+
+/*
+ * CTL Tree node structure, do not use directly. All the necessary functionality
+ * is provided by the included macros.
+ */
+typedef struct ctl_node {
+    const char *name;
+    enum ctl_node_type type;
+
+    node_callback read_cb;
+    node_callback write_cb;
+    node_callback runnable_cb;
+    node_callback_subtree subtree_cb;
+
+    const struct ctl_argument *arg;
+
+    const struct ctl_node *children;
+} umf_ctl_node_t;
+
+/*
+ * This is the top level node of the ctl tree structure. Each node can contain
+ * children and leaf nodes.
+ *
+ * Internal nodes simply create a new path in the tree whereas child nodes are
+ * the ones providing the read/write functionality by the means of callbacks.
+ *
+ * Each tree node must be NULL-terminated, CTL_NODE_END macro is provided for
+ * convenience.
+ */
+struct ctl {
+    umf_ctl_node_t root[CTL_MAX_ENTRIES];
+    int first_free;
+};
+
+void ctl_init(void *(*Malloc)(size_t), void (*Free)(void *));
+
+umf_result_t ctl_load_config_from_string(struct ctl *ctl, void *ctx,
+                                         const char *cfg_string);
+umf_result_t ctl_load_config_from_file(struct ctl *ctl, void *ctx,
+                                       const char *cfg_file);
+
+/* Use through CTL_REGISTER_MODULE, never directly */
+void ctl_register_module_node(struct ctl *c, const char *name,
+                              struct ctl_node *n);
+
+int ctl_arg_boolean(const void *arg, void *dest, size_t dest_size);
+int ctl_arg_integer(const void *arg, void *dest, size_t dest_size);
+int ctl_arg_unsigned(const void *arg, void *dest, size_t dest_size);
+int ctl_arg_string(const void *arg, void *dest, size_t dest_size);
+
+#define CTL_ARG_BOOLEAN                                                        \
+    {                                                                          \
+        sizeof(int), {                                                         \
+            {0, sizeof(int), CTL_ARG_TYPE_BOOLEAN, ctl_arg_boolean},           \
+                CTL_ARG_PARSER_END                                             \
+        }                                                                      \
+    }
+
+#define CTL_ARG_INT                                                            \
+    {                                                                          \
+        sizeof(int), {                                                         \
+            {0, sizeof(int), CTL_ARG_TYPE_INT, ctl_arg_integer},               \
+                CTL_ARG_PARSER_END                                             \
+        }                                                                      \
+    }
+
+#define CTL_ARG_LONG_LONG                                                      \
+    {                                                                          \
+        sizeof(long long), {                                                   \
+            {0, sizeof(long long), CTL_ARG_TYPE_LONG_LONG, ctl_arg_integer},   \
+                CTL_ARG_PARSER_END                                             \
+        }                                                                      \
+    }
+
+#define CTL_ARG_UNSIGNED_LONG_LONG                                             \
+    {                                                                          \
+        sizeof(unsigned long long), {                                          \
+            {0, sizeof(unsigned long long), CTL_ARG_TYPE_UNSIGNED_LONG_LONG,   \
+             ctl_arg_unsigned},                                                \
+                CTL_ARG_PARSER_END                                             \
+        }                                                                      \
+    }
+
+#define CTL_ARG_STRING(len)                                                    \
+    {                                                                          \
+        len, {                                                                 \
+            {0, len, CTL_ARG_TYPE_STRING, ctl_arg_string}, CTL_ARG_PARSER_END  \
+        }                                                                      \
+    }
+
+#define CTL_ARG_PTR                                                            \
+    {                                                                          \
+        sizeof(void *), {                                                      \
+            {0, sizeof(void *), CTL_ARG_TYPE_PTR, NULL}, CTL_ARG_PARSER_END    \
+        }                                                                      \
+    }
+
+#define _CTL_STR(name) #name
+#define CTL_STR(name) _CTL_STR(name)
+
+// this macro is only needed because Microsoft cannot implement C99 standard
+#define CTL_NONAME CTL_NAMELESS_NODE_
+
+#define CTL_NODE_END                                                           \
+    { NULL, CTL_NODE_UNKNOWN, NULL, NULL, NULL, NULL, NULL, NULL }
+
+#define CTL_NODE(name, ...) ctl_node_##__VA_ARGS__##_##name
+
+umf_result_t ctl_query(struct ctl *ctl, void *ctx,
+                       umf_ctl_query_source_t source, const char *path,
+                       umf_ctl_query_type_t type, void *arg, size_t size,
+                       va_list args);
+
+/* Declaration of a new child node */
+#define CTL_CHILD(name, ...)                                                   \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_NAMED, NULL, NULL, NULL, NULL, NULL,           \
+            (struct ctl_node *)CTL_NODE(name, __VA_ARGS__)                     \
+    }
+
+/*
+ * Declaration of a new child node with an argument
+ * This is used to declare that the following node is an argument node, which
+ * should be parsed and provided to the handler function in argument list.
+ */
+#define CTL_CHILD_WITH_ARG(name, ...)                                          \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_NAMED, NULL, NULL, NULL, NULL, &CTL_ARG(name), \
+            (struct ctl_node *)CTL_NODE(name, __VA_ARGS__)                     \
+    }
+
+/* Declaration of a new indexed node */
+#define CTL_INDEXED(name, ...)                                                 \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_INDEXED, NULL, NULL, NULL, NULL, NULL,         \
+            (struct ctl_node *)CTL_NODE(name, __VA_ARGS__)                     \
+    }
+
+#define CTL_HANDLER_NAME(name, action, ...)                                    \
+    ctl_##__VA_ARGS__##_##name##_##action
+
+#define CTL_READ_HANDLER(name, ...) CTL_HANDLER_NAME(name, read, __VA_ARGS__)
+#define CTL_WRITE_HANDLER(name, ...) CTL_HANDLER_NAME(name, write, __VA_ARGS__)
+
+#define CTL_RUNNABLE_HANDLER(name, ...)                                        \
+    CTL_HANDLER_NAME(name, runnable, __VA_ARGS__)
+
+#define CTL_SUBTREE_HANDLER(name, ...)                                         \
+    CTL_HANDLER_NAME(name, subtree, __VA_ARGS__)
+
+#define CTL_ARG(name) ctl_arg_##name
+
+/*
+ * Declaration of a new read-only leaf. If used the corresponding read function
+ * must be declared by CTL_READ_HANDLER macro.
+ */
+#define CTL_LEAF_RO(name, ...)                                                 \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_LEAF, CTL_READ_HANDLER(name, __VA_ARGS__),     \
+            NULL, NULL, NULL, NULL, NULL                                       \
+    }
+
+/*
+ * Declaration of a new write-only leaf. If used the corresponding write
+ * function must be declared by CTL_WRITE_HANDLER macro.
+ */
+#define CTL_LEAF_WO(name, ...)                                                 \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_LEAF, NULL,                                    \
+            CTL_WRITE_HANDLER(name, __VA_ARGS__), NULL, NULL, &CTL_ARG(name),  \
+            NULL                                                               \
+    }
+
+/*
+ * Declaration of a new runnable leaf. If used the corresponding run
+ * function must be declared by CTL_RUNNABLE_HANDLER macro.
+ */
+#define CTL_LEAF_RUNNABLE(name, ...)                                           \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_LEAF, NULL, NULL,                              \
+            CTL_RUNNABLE_HANDLER(name, __VA_ARGS__), NULL, NULL, NULL          \
+    }
+
+#define CTL_LEAF_SUBTREE(name, ...)                                            \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_SUBTREE, NULL, NULL, NULL,                     \
+            CTL_SUBTREE_HANDLER(name, __VA_ARGS__), NULL, NULL                 \
+    }
+
+/*
+ * Declaration of a new read-write leaf. If used both read and write function
+ * must be declared by CTL_READ_HANDLER and CTL_WRITE_HANDLER macros.
+ */
+#define CTL_LEAF_RW(name)                                                      \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_LEAF, CTL_READ_HANDLER(name),                  \
+            CTL_WRITE_HANDLER(name), NULL, NULL, &CTL_ARG(name), NULL          \
+    }
+
+#define CTL_REGISTER_MODULE(_ctl, name)                                        \
+    ctl_register_module_node((_ctl), CTL_STR(name),                            \
+                             (struct ctl_node *)CTL_NODE(name))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_CTL_INTERNAL_H */
diff --git a/src/ipc.c b/src/ipc.c
index 1b479fd7c5..29ed5bac20 100644
--- a/src/ipc.c
+++ b/src/ipc.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -15,6 +15,7 @@
 #include "base_alloc_global.h"
 #include "ipc_internal.h"
 #include "memory_pool_internal.h"
+#include "memory_provider_internal.h"
 #include "provider/provider_tracking.h"
 #include "utils_common.h"
 #include "utils_log.h"
@@ -57,14 +58,19 @@ umf_result_t umfGetIPCHandle(const void *ptr, umf_ipc_handle_t *umfIPCHandle,
     }
 
     size_t ipcHandleSize = 0;
-    umf_alloc_info_t allocInfo;
-    umf_result_t ret = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
+    umf_memory_properties_handle_t props = NULL;
+    umf_result_t ret = umfGetMemoryPropertiesHandle(ptr, &props);
     if (ret != UMF_RESULT_SUCCESS) {
-        LOG_ERR("cannot get alloc info for ptr = %p.", ptr);
+        LOG_ERR("cannot get alloc props for ptr = %p.", ptr);
         return ret;
     }
 
-    ret = umfPoolGetIPCHandleSize(allocInfo.pool, &ipcHandleSize);
+    if (props == NULL || props->pool == NULL) {
+        LOG_ERR("cannot get pool from alloc info for ptr = %p.", ptr);
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    ret = umfPoolGetIPCHandleSize(props->pool, &ipcHandleSize);
     if (ret != UMF_RESULT_SUCCESS) {
         LOG_ERR("cannot get IPC handle size.");
         return ret;
@@ -78,11 +84,14 @@ umf_result_t umfGetIPCHandle(const void *ptr, umf_ipc_handle_t *umfIPCHandle,
 
     // We cannot use umfPoolGetMemoryProvider function because it returns
     // upstream provider but we need tracking one
-    umf_memory_provider_handle_t provider = allocInfo.pool->provider;
-    assert(provider);
+    if (props->pool->provider == NULL) {
+        LOG_ERR("cannot get memory provider from pool");
+        umf_ba_global_free(ipcData);
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+    umf_memory_provider_handle_t provider = props->pool->provider;
 
-    ret = umfMemoryProviderGetIPCHandle(provider, allocInfo.base,
-                                        allocInfo.baseSize,
+    ret = umfMemoryProviderGetIPCHandle(provider, props->base, props->base_size,
                                         (void *)ipcData->providerIpcData);
     if (ret != UMF_RESULT_SUCCESS) {
         LOG_ERR("failed to get IPC handle.");
@@ -91,10 +100,10 @@ umf_result_t umfGetIPCHandle(const void *ptr, umf_ipc_handle_t *umfIPCHandle,
     }
 
     // ipcData->handle_id is filled by tracking provider
-    ipcData->base = allocInfo.base;
+    ipcData->base = props->base;
     ipcData->pid = utils_getpid();
-    ipcData->baseSize = allocInfo.baseSize;
-    ipcData->offset = (uintptr_t)ptr - (uintptr_t)allocInfo.base;
+    ipcData->baseSize = props->base_size;
+    ipcData->offset = (uintptr_t)ptr - (uintptr_t)props->base;
 
     *umfIPCHandle = ipcData;
     *size = ipcHandleSize;
@@ -123,14 +132,14 @@ umf_result_t umfOpenIPCHandle(umf_ipc_handler_handle_t hIPCHandler,
                               umf_ipc_handle_t umfIPCHandle, void **ptr) {
 
     // IPC handler is an instance of tracking memory provider
-    if (*(uint32_t *)hIPCHandler != UMF_VERSION_CURRENT) {
+    umf_memory_provider_handle_t hProvider = hIPCHandler;
+    if (hProvider->ops.version != UMF_PROVIDER_OPS_VERSION_CURRENT) {
         // It is a temporary hack to verify that user passes correct IPC handler,
         // not a pool handle, as it was required in previous version.
         LOG_ERR("Invalid IPC handler.");
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    umf_memory_provider_handle_t hProvider = hIPCHandler;
     void *base = NULL;
 
     umf_result_t ret = umfMemoryProviderOpenIPCHandle(
@@ -145,19 +154,15 @@ umf_result_t umfOpenIPCHandle(umf_ipc_handler_handle_t hIPCHandler,
 }
 
 umf_result_t umfCloseIPCHandle(void *ptr) {
-    umf_alloc_info_t allocInfo;
-    umf_result_t ret = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
+    umf_ipc_info_t ipcInfo;
+    umf_result_t ret = umfMemoryTrackerGetIpcInfo(ptr, &ipcInfo);
     if (ret != UMF_RESULT_SUCCESS) {
-        LOG_ERR("cannot get alloc info for ptr = %p.", ptr);
+        LOG_ERR("cannot get IPC info for ptr = %p.", ptr);
         return ret;
     }
 
-    // We cannot use umfPoolGetMemoryProvider function because it returns
-    // upstream provider but we need tracking one
-    umf_memory_provider_handle_t hProvider = allocInfo.pool->provider;
-
-    return umfMemoryProviderCloseIPCHandle(hProvider, allocInfo.base,
-                                           allocInfo.baseSize);
+    return umfMemoryProviderCloseIPCHandle(ipcInfo.provider, ipcInfo.base,
+                                           ipcInfo.baseSize);
 }
 
 umf_result_t umfPoolGetIPCHandler(umf_memory_pool_handle_t hPool,
diff --git a/src/ipc_cache.c b/src/ipc_cache.c
index 60072d4dfa..bf17a66a42 100644
--- a/src/ipc_cache.c
+++ b/src/ipc_cache.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -22,41 +22,57 @@
 #pragma warning(disable : 4702)
 #endif
 
-struct ipc_handle_cache_entry_t;
+struct ipc_opened_cache_entry_t;
 
-typedef struct ipc_handle_cache_entry_t *hash_map_t;
-typedef struct ipc_handle_cache_entry_t *lru_list_t;
+typedef struct ipc_opened_cache_entry_t *hash_map_t;
+typedef struct ipc_opened_cache_entry_t *lru_list_t;
 
-typedef struct ipc_handle_cache_entry_t {
+typedef struct ipc_opened_cache_entry_t {
     UT_hash_handle hh;
-    struct ipc_handle_cache_entry_t *next, *prev;
-    ipc_mapped_handle_cache_key_t key;
+    struct ipc_opened_cache_entry_t *next, *prev;
+    ipc_opened_cache_key_t key;
     uint64_t ref_count;
     uint64_t handle_id;
     hash_map_t
         *hash_table; // pointer to the hash table to which the entry belongs
-    ipc_mapped_handle_cache_value_t value;
-} ipc_handle_cache_entry_t;
+    ipc_opened_cache_value_t value;
+} ipc_opened_cache_entry_t;
 
-typedef struct ipc_mapped_handle_cache_global_t {
+typedef struct ipc_opened_cache_global_t {
     utils_mutex_t cache_lock;
     umf_ba_pool_t *cache_allocator;
     size_t max_size;
     size_t cur_size;
     lru_list_t lru_list;
-} ipc_mapped_handle_cache_global_t;
+} ipc_opened_cache_global_t;
 
-typedef struct ipc_mapped_handle_cache_t {
-    ipc_mapped_handle_cache_global_t *global;
+typedef struct ipc_opened_cache_t {
+    ipc_opened_cache_global_t *global;
     hash_map_t hash_table;
-    ipc_mapped_handle_cache_eviction_cb_t eviction_cb;
-} ipc_mapped_handle_cache_t;
-
-ipc_mapped_handle_cache_global_t *IPC_MAPPED_CACHE_GLOBAL = NULL;
+    ipc_opened_cache_eviction_cb_t eviction_cb;
+} ipc_opened_cache_t;
+
+ipc_opened_cache_global_t *IPC_OPENED_CACHE_GLOBAL = NULL;
+
+// Returns value of the UMF_MAX_OPENED_IPC_HANDLES environment variable
+// or 0 if it is not set.
+static size_t umfIpcCacheGlobalInitMaxOpenedHandles(void) {
+    const char *max_size_str = getenv("UMF_MAX_OPENED_IPC_HANDLES");
+    if (max_size_str) {
+        char *endptr;
+        size_t max_size = strtoul(max_size_str, &endptr, 10);
+        if (*endptr == '\0') {
+            return max_size;
+        }
+        LOG_ERR("Invalid value of UMF_MAX_OPENED_IPC_HANDLES: %s",
+                max_size_str);
+    }
+    return 0;
+}
 
 umf_result_t umfIpcCacheGlobalInit(void) {
     umf_result_t ret = UMF_RESULT_SUCCESS;
-    ipc_mapped_handle_cache_global_t *cache_global =
+    ipc_opened_cache_global_t *cache_global =
         umf_ba_global_alloc(sizeof(*cache_global));
     if (!cache_global) {
         LOG_ERR("Failed to allocate memory for the IPC cache global data");
@@ -71,19 +87,18 @@ umf_result_t umfIpcCacheGlobalInit(void) {
     }
 
     cache_global->cache_allocator =
-        umf_ba_create(sizeof(ipc_handle_cache_entry_t));
+        umf_ba_create(sizeof(ipc_opened_cache_entry_t));
     if (!cache_global->cache_allocator) {
         LOG_ERR("Failed to create IPC cache allocator");
         ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
         goto err_mutex_destroy;
     }
 
-    // TODO: make max_size configurable via environment variable
-    cache_global->max_size = 0;
+    cache_global->max_size = umfIpcCacheGlobalInitMaxOpenedHandles();
     cache_global->cur_size = 0;
     cache_global->lru_list = NULL;
 
-    IPC_MAPPED_CACHE_GLOBAL = cache_global;
+    IPC_OPENED_CACHE_GLOBAL = cache_global;
     goto err_exit;
 
 err_mutex_destroy:
@@ -97,15 +112,15 @@ umf_result_t umfIpcCacheGlobalInit(void) {
 #ifndef NDEBUG
 static size_t getGlobalLruListSize(lru_list_t lru_list) {
     size_t size = 0;
-    ipc_handle_cache_entry_t *tmp;
+    ipc_opened_cache_entry_t *tmp;
     DL_COUNT(lru_list, tmp, size);
     return size;
 }
 #endif /* NDEBUG */
 
 void umfIpcCacheGlobalTearDown(void) {
-    ipc_mapped_handle_cache_global_t *cache_global = IPC_MAPPED_CACHE_GLOBAL;
-    IPC_MAPPED_CACHE_GLOBAL = NULL;
+    ipc_opened_cache_global_t *cache_global = IPC_OPENED_CACHE_GLOBAL;
+    IPC_OPENED_CACHE_GLOBAL = NULL;
 
     if (!cache_global) {
         return;
@@ -119,31 +134,33 @@ void umfIpcCacheGlobalTearDown(void) {
     umf_ba_global_free(cache_global);
 }
 
-ipc_mapped_handle_cache_handle_t umfIpcHandleMappedCacheCreate(
-    ipc_mapped_handle_cache_eviction_cb_t eviction_cb) {
+ipc_opened_cache_handle_t
+umfIpcOpenedCacheCreate(ipc_opened_cache_eviction_cb_t eviction_cb) {
     if (eviction_cb == NULL) {
         LOG_ERR("Eviction callback is NULL");
         return NULL;
     }
 
-    ipc_mapped_handle_cache_t *cache = umf_ba_global_alloc(sizeof(*cache));
+    ipc_opened_cache_t *cache = umf_ba_global_alloc(sizeof(*cache));
 
     if (!cache) {
         LOG_ERR("Failed to allocate memory for the IPC cache");
         return NULL;
     }
 
-    assert(IPC_MAPPED_CACHE_GLOBAL != NULL);
+    assert(IPC_OPENED_CACHE_GLOBAL != NULL);
 
-    cache->global = IPC_MAPPED_CACHE_GLOBAL;
+    cache->global = IPC_OPENED_CACHE_GLOBAL;
     cache->hash_table = NULL;
     cache->eviction_cb = eviction_cb;
 
     return cache;
 }
 
-void umfIpcHandleMappedCacheDestroy(ipc_mapped_handle_cache_handle_t cache) {
-    ipc_handle_cache_entry_t *entry, *tmp;
+void umfIpcOpenedCacheDestroy(ipc_opened_cache_handle_t cache) {
+    ipc_opened_cache_entry_t *entry, *tmp;
+
+    utils_mutex_lock(&(cache->global->cache_lock));
     HASH_ITER(hh, cache->hash_table, entry, tmp) {
         DL_DELETE(cache->global->lru_list, entry);
         HASH_DEL(cache->hash_table, entry);
@@ -153,19 +170,19 @@ void umfIpcHandleMappedCacheDestroy(ipc_mapped_handle_cache_handle_t cache) {
         umf_ba_free(cache->global->cache_allocator, entry);
     }
     HASH_CLEAR(hh, cache->hash_table);
+    utils_mutex_unlock(&(cache->global->cache_lock));
 
     umf_ba_global_free(cache);
 }
 
-umf_result_t
-umfIpcHandleMappedCacheGet(ipc_mapped_handle_cache_handle_t cache,
-                           const ipc_mapped_handle_cache_key_t *key,
-                           uint64_t handle_id,
-                           ipc_mapped_handle_cache_value_t **retEntry) {
-    ipc_handle_cache_entry_t *entry = NULL;
+umf_result_t umfIpcOpenedCacheGet(ipc_opened_cache_handle_t cache,
+                                  const ipc_opened_cache_key_t *key,
+                                  uint64_t handle_id,
+                                  ipc_opened_cache_value_t **retEntry) {
+    ipc_opened_cache_entry_t *entry = NULL;
     umf_result_t ret = UMF_RESULT_SUCCESS;
     bool evicted = false;
-    ipc_mapped_handle_cache_value_t evicted_value;
+    ipc_opened_cache_value_t evicted_value;
 
     if (!cache || !key || !retEntry) {
         LOG_ERR("Some arguments are NULL, cache=%p, key=%p, retEntry=%p",
@@ -189,7 +206,19 @@ umfIpcHandleMappedCacheGet(ipc_mapped_handle_cache_handle_t cache,
         if (entry == NULL && cache->global->max_size != 0 &&
             cache->global->cur_size >= cache->global->max_size) {
             // If max_size is set and the cache is full, evict the least recently used entry.
-            entry = cache->global->lru_list->prev;
+            // we need to search for the least recently used entry with ref_count == 0
+            // The utlist implementation of the doubly-linked list keeps a tail pointer in head->prev
+            ipc_opened_cache_entry_t *candidate = cache->global->lru_list->prev;
+            do {
+                uint64_t ref_count = 0;
+                utils_atomic_load_acquire_u64(&candidate->ref_count,
+                                              &ref_count);
+                if (ref_count == 0) {
+                    entry = candidate;
+                    break;
+                }
+                candidate = candidate->prev;
+            } while (candidate != cache->global->lru_list->prev);
         }
 
         if (entry) { // we have eviction candidate
@@ -230,7 +259,7 @@ umfIpcHandleMappedCacheGet(ipc_mapped_handle_cache_handle_t cache,
 
 exit:
     if (ret == UMF_RESULT_SUCCESS) {
-        utils_atomic_increment(&entry->ref_count);
+        utils_atomic_increment_u64(&entry->ref_count);
         *retEntry = &entry->value;
     }
 
@@ -242,3 +271,20 @@ umfIpcHandleMappedCacheGet(ipc_mapped_handle_cache_handle_t cache,
 
     return ret;
 }
+
+umf_result_t
+umfIpcHandleMappedCacheRelease(ipc_opened_cache_value_t *cacheValue) {
+    if (!cacheValue) {
+        LOG_ERR("cacheValue is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    // get pointer to the entry
+    ipc_opened_cache_entry_t *entry =
+        (ipc_opened_cache_entry_t *)((char *)cacheValue -
+                                     offsetof(ipc_opened_cache_entry_t, value));
+    // decrement the ref count
+    utils_atomic_decrement_u64(&entry->ref_count);
+
+    return UMF_RESULT_SUCCESS;
+}
diff --git a/src/ipc_cache.h b/src/ipc_cache.h
index 59ae287872..545c6e1e7e 100644
--- a/src/ipc_cache.h
+++ b/src/ipc_cache.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -14,39 +14,39 @@
 
 #include "utils_concurrency.h"
 
-typedef struct ipc_mapped_handle_cache_key_t {
+typedef struct ipc_opened_cache_key_t {
     void *remote_base_ptr;
     umf_memory_provider_handle_t local_provider;
     int remote_pid;
-} ipc_mapped_handle_cache_key_t;
+} ipc_opened_cache_key_t;
 
-typedef struct ipc_mapped_handle_cache_value_t {
+typedef struct ipc_opened_cache_value_t {
     void *mapped_base_ptr;
     size_t mapped_size;
     utils_mutex_t mmap_lock;
-} ipc_mapped_handle_cache_value_t;
+} ipc_opened_cache_value_t;
 
-struct ipc_mapped_handle_cache_t;
+struct ipc_opened_cache_t;
 
-typedef struct ipc_mapped_handle_cache_t *ipc_mapped_handle_cache_handle_t;
+typedef struct ipc_opened_cache_t *ipc_opened_cache_handle_t;
 
 umf_result_t umfIpcCacheGlobalInit(void);
 void umfIpcCacheGlobalTearDown(void);
 
 // define pointer to the eviction callback function
-typedef void (*ipc_mapped_handle_cache_eviction_cb_t)(
-    const ipc_mapped_handle_cache_key_t *key,
-    const ipc_mapped_handle_cache_value_t *value);
+typedef void (*ipc_opened_cache_eviction_cb_t)(
+    const ipc_opened_cache_key_t *key, const ipc_opened_cache_value_t *value);
 
-ipc_mapped_handle_cache_handle_t umfIpcHandleMappedCacheCreate(
-    ipc_mapped_handle_cache_eviction_cb_t eviction_cb);
+ipc_opened_cache_handle_t
+umfIpcOpenedCacheCreate(ipc_opened_cache_eviction_cb_t eviction_cb);
 
-void umfIpcHandleMappedCacheDestroy(ipc_mapped_handle_cache_handle_t cache);
+void umfIpcOpenedCacheDestroy(ipc_opened_cache_handle_t cache);
 
-umf_result_t
-umfIpcHandleMappedCacheGet(ipc_mapped_handle_cache_handle_t cache,
-                           const ipc_mapped_handle_cache_key_t *key,
-                           uint64_t handle_id,
-                           ipc_mapped_handle_cache_value_t **retEntry);
+umf_result_t umfIpcOpenedCacheGet(ipc_opened_cache_handle_t cache,
+                                  const ipc_opened_cache_key_t *key,
+                                  uint64_t handle_id,
+                                  ipc_opened_cache_value_t **retEntry);
 
+umf_result_t
+umfIpcHandleMappedCacheRelease(ipc_opened_cache_value_t *cacheValue);
 #endif /* UMF_IPC_CACHE_H */
diff --git a/src/libumf.c b/src/libumf.c
index b89e5c844d..ab6be8704a 100644
--- a/src/libumf.c
+++ b/src/libumf.c
@@ -1,58 +1,122 @@
 /*
  *
- * 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
  *
  */
 
+#include <stdarg.h>
 #include <stddef.h>
+#include <string.h>
 
 #include "base_alloc_global.h"
+#include "ctl/ctl_internal.h"
 #include "ipc_cache.h"
+#include "libumf.h"
+#include "memory_pool_internal.h"
+#include "memory_provider_internal.h"
 #include "memspace_internal.h"
+#include "pool/pool_scalable_internal.h"
+#include "provider_cuda_internal.h"
+#include "provider_level_zero_internal.h"
 #include "provider_tracking.h"
+#include "topology.h"
 #include "utils_common.h"
+#include "utils_concurrency.h"
 #include "utils_log.h"
-#if !defined(UMF_NO_HWLOC)
-#include "topology.h"
-#endif
 
 umf_memory_tracker_handle_t TRACKER = NULL;
 
-static unsigned long long umfRefCount = 0;
+static uint64_t umfRefCount = 0;
+static utils_mutex_t initMutex;
+static UTIL_ONCE_FLAG initMutexOnce = UTIL_ONCE_FLAG_INIT;
+
+static void initialize_init_mutex(void) { utils_mutex_init(&initMutex); }
+
+static umf_ctl_node_t CTL_NODE(umf)[] = {CTL_CHILD(provider), CTL_CHILD(pool),
+                                         CTL_CHILD(logger), CTL_NODE_END};
+
+void initialize_ctl(void) {
+    ctl_init(umf_ba_global_alloc, umf_ba_global_free);
+
+    CTL_REGISTER_MODULE(NULL, umf);
+    const char *env_var = getenv("UMF_CONF");
+    if (env_var && env_var[0] != '\0') {
+        LOG_INFO("Loading UMF configuration from environment variable: %s",
+                 env_var);
+        ctl_load_config_from_string(NULL, NULL, env_var);
+    }
+
+    const char *file_var = getenv("UMF_CONF_FILE");
+    if (file_var && file_var[0] != '\0') {
+        LOG_INFO("Loading UMF configuration from file: %s", file_var);
+        ctl_load_config_from_file(NULL, NULL, file_var);
+    }
+}
+
+// Benchmarks may fork multiple times and topology init is slow.
+// Init topology before fork (if not already) so children don't repeat it.
+// TODO: This is a hack. Better solution is needed.
+#if !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+static void atfork_prepare(void) { umfGetTopologyReduced(); }
+#endif
+
+umf_result_t umfInit(void) {
+    utils_init_once(&initMutexOnce, initialize_init_mutex);
 
-int umfInit(void) {
-    if (utils_fetch_and_add64(&umfRefCount, 1) == 0) {
+    utils_mutex_lock(&initMutex);
+
+    if (umfRefCount == 0) {
         utils_log_init();
-        TRACKER = umfMemoryTrackerCreate();
-        if (!TRACKER) {
+        initialize_ctl();
+
+        umf_result_t umf_result = umfMemoryTrackerCreate(&TRACKER);
+        if (umf_result != UMF_RESULT_SUCCESS) {
             LOG_ERR("Failed to create memory tracker");
-            return -1;
+            utils_mutex_unlock(&initMutex);
+            return umf_result;
         }
 
         LOG_DEBUG("UMF tracker created");
 
-        umf_result_t umf_result = umfIpcCacheGlobalInit();
+        umf_result = umfIpcCacheGlobalInit();
         if (umf_result != UMF_RESULT_SUCCESS) {
             LOG_ERR("Failed to initialize IPC cache");
-            return -1;
+            umfMemoryTrackerDestroy(TRACKER);
+            utils_mutex_unlock(&initMutex);
+            return umf_result;
         }
 
         LOG_DEBUG("UMF IPC cache initialized");
     }
 
+    umfRefCount++;
+    utils_mutex_unlock(&initMutex);
+
     if (TRACKER) {
         LOG_DEBUG("UMF library initialized");
     }
 
-    return 0;
+#if !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+    pthread_atfork(atfork_prepare, NULL, NULL);
+#endif
+
+    return UMF_RESULT_SUCCESS;
 }
 
-void umfTearDown(void) {
-    if (utils_fetch_and_add64(&umfRefCount, -1) == 1) {
-#if !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+umf_result_t umfTearDown(void) {
+    utils_init_once(&initMutexOnce, initialize_init_mutex);
+
+    utils_mutex_lock(&initMutex);
+    if (umfRefCount == 0) {
+        utils_mutex_unlock(&initMutex);
+        return UMF_RESULT_SUCCESS;
+    }
+
+    if (--umfRefCount == 0) {
+#if !defined(_WIN32)
         umfMemspaceHostAllDestroy();
         umfMemspaceHighestCapacityDestroy();
         umfMemspaceHighestBandwidthDestroy();
@@ -75,12 +139,70 @@ void umfTearDown(void) {
         umfMemoryTrackerDestroy(t);
         LOG_DEBUG("UMF tracker destroyed");
 
+        umfProviderCtlDefaultsDestroy();
+        umfPoolCtlDefaultsDestroy();
+
         umf_ba_destroy_global();
         LOG_DEBUG("UMF base allocator destroyed");
 
     fini_umfTearDown:
+        fini_ze_global_state();
+        fini_cu_global_state();
+        fini_tbb_global_state();
         LOG_DEBUG("UMF library finalized");
     }
+    utils_mutex_unlock(&initMutex);
+    return UMF_RESULT_SUCCESS;
 }
 
 int umfGetCurrentVersion(void) { return UMF_VERSION_CURRENT; }
+
+umf_result_t umfCtlGet(const char *path, void *arg, size_t size, ...) {
+    libumfInit();
+    // ctx can be NULL when getting defaults
+    if (path == NULL || arg == NULL || size == 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    va_list args;
+    va_start(args, size);
+
+    umf_result_t ret = ctl_query(NULL, NULL, CTL_QUERY_PROGRAMMATIC, path,
+                                 CTL_QUERY_READ, arg, size, args);
+    va_end(args);
+    return ret;
+}
+
+umf_result_t umfCtlSet(const char *path, void *arg, size_t size, ...) {
+    libumfInit();
+    // ctx can be NULL when setting defaults
+    if (path == NULL || arg == NULL || size == 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    va_list args;
+    va_start(args, size);
+    umf_result_t ret = ctl_query(NULL, NULL, CTL_QUERY_PROGRAMMATIC, path,
+                                 CTL_QUERY_WRITE, arg, size, args);
+    va_end(args);
+    return ret;
+}
+
+umf_result_t umfCtlExec(const char *path, void *arg, size_t size, ...) {
+    libumfInit();
+    // arg can be NULL when executing a command
+    // ctx can be NULL when executing defaults
+    // size can depends on the arg
+    if (path == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if ((arg == NULL && size != 0) || (arg != NULL && size == 0)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    va_list args;
+    va_start(args, size);
+
+    umf_result_t ret = ctl_query(NULL, NULL, CTL_QUERY_PROGRAMMATIC, path,
+                                 CTL_QUERY_RUNNABLE, arg, size, args);
+    va_end(args);
+    return ret;
+}
diff --git a/src/libumf.def b/src/libumf.def
index 82e32d4a13..c4093292e5 100644
--- a/src/libumf.def
+++ b/src/libumf.def
@@ -1,21 +1,18 @@
 ;;;; Begin Copyright Notice
-; Copyright (C) 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
 ;;;;  End Copyright Notice
 
 LIBRARY UMF
 
-VERSION 0.10
+VERSION 1.1
 
 EXPORTS
     DllMain
     umfInit
     umfTearDown
-    umfGetCurrentVersion
     umfCloseIPCHandle
-    umfCoarseMemoryProviderGetStats
-    umfCoarseMemoryProviderOps
     umfCUDAMemoryProviderOps
     umfCUDAMemoryProviderParamsCreate
     umfCUDAMemoryProviderParamsDestroy
@@ -27,15 +24,17 @@ EXPORTS
     umfDevDaxMemoryProviderParamsDestroy
     umfDevDaxMemoryProviderParamsSetDeviceDax
     umfDevDaxMemoryProviderParamsSetProtection
-    umfFree
     umfFileMemoryProviderOps
     umfFileMemoryProviderParamsCreate
     umfFileMemoryProviderParamsDestroy
     umfFileMemoryProviderParamsSetPath
     umfFileMemoryProviderParamsSetProtection
     umfFileMemoryProviderParamsSetVisibility
+    umfFree
+    umfGetCurrentVersion
     umfGetIPCHandle
     umfGetLastFailedMemoryProvider
+    umfJemallocPoolOps
     umfLevelZeroMemoryProviderOps
     umfLevelZeroMemoryProviderParamsCreate
     umfLevelZeroMemoryProviderParamsDestroy
@@ -61,7 +60,6 @@ EXPORTS
     umfMemoryProviderPurgeForce
     umfMemoryProviderPurgeLazy
     umfMemoryProviderPutIPCHandle
-    umfMemoryTrackerGetAllocInfo
     umfMempolicyCreate
     umfMempolicyDestroy
     umfMempolicySetCustomSplitPartitions
@@ -88,13 +86,13 @@ EXPORTS
     umfOsMemoryProviderOps
     umfOsMemoryProviderParamsCreate
     umfOsMemoryProviderParamsDestroy
-    umfOsMemoryProviderParamsSetProtection
-    umfOsMemoryProviderParamsSetVisibility
-    umfOsMemoryProviderParamsSetShmName
     umfOsMemoryProviderParamsSetNumaList
     umfOsMemoryProviderParamsSetNumaMode
-    umfOsMemoryProviderParamsSetPartSize
     umfOsMemoryProviderParamsSetPartitions
+    umfOsMemoryProviderParamsSetPartSize
+    umfOsMemoryProviderParamsSetProtection
+    umfOsMemoryProviderParamsSetShmName
+    umfOsMemoryProviderParamsSetVisibility
     umfPoolAlignedMalloc
     umfPoolByPtr
     umfPoolCalloc
@@ -105,10 +103,12 @@ EXPORTS
     umfPoolGetIPCHandler
     umfPoolGetIPCHandleSize
     umfPoolGetLastAllocationError
+    umfPoolGetTag
     umfPoolGetMemoryProvider
     umfPoolMalloc
     umfPoolMallocUsableSize
     umfPoolRealloc
+    umfPoolSetTag
     umfProxyPoolOps
     umfPutIPCHandle
     umfScalablePoolOps
@@ -116,3 +116,45 @@ EXPORTS
     umfScalablePoolParamsDestroy
     umfScalablePoolParamsSetGranularity
     umfScalablePoolParamsSetKeepAllMemory
+; Added in UMF_0.11
+    umfCUDAMemoryProviderParamsSetAllocFlags
+    umfDisjointPoolOps
+    umfDisjointPoolParamsCreate
+    umfDisjointPoolParamsDestroy
+    umfDisjointPoolParamsSetCapacity
+    umfDisjointPoolParamsSetMaxPoolableSize
+    umfDisjointPoolParamsSetMinBucketSize
+    umfDisjointPoolParamsSetName
+    umfDisjointPoolParamsSetSharedLimits
+    umfDisjointPoolParamsSetSlabMinSize
+    umfDisjointPoolParamsSetTrace
+    umfDisjointPoolSharedLimitsCreate
+    umfDisjointPoolSharedLimitsDestroy
+    umfFixedMemoryProviderOps
+    umfFixedMemoryProviderParamsCreate
+    umfFixedMemoryProviderParamsDestroy
+    umfFixedMemoryProviderParamsSetMemory
+    umfLevelZeroMemoryProviderParamsSetDeviceOrdinal
+    umfLevelZeroMemoryProviderParamsSetFreePolicy
+; Added in UMF_1.0
+    umfCtlExec
+    umfCtlGet
+    umfCtlSet
+    umfJemallocPoolParamsCreate
+    umfJemallocPoolParamsDestroy
+    umfJemallocPoolParamsSetNumArenas
+    umfPoolGetName
+; Added in UMF_1.1
+    umfCUDAMemoryProviderParamsSetName
+    umfDevDaxMemoryProviderParamsSetName
+    umfFileMemoryProviderParamsSetName
+    umfFixedMemoryProviderParamsSetName
+    umfGetMemoryPropertiesHandle
+    umfGetMemoryProperty
+    umfGetMemoryPropertySize
+    umfJemallocPoolParamsSetName
+    umfLevelZeroMemoryProviderParamsSetName
+    umfLevelZeroMemoryProviderResidentDeviceChange
+    umfOsMemoryProviderParamsSetName
+    umfPoolTrimMemory
+    umfScalablePoolParamsSetName
diff --git a/src/libumf.map b/src/libumf.map
index 4755b6b814..d23c6a2e02 100644
--- a/src/libumf.map
+++ b/src/libumf.map
@@ -1,15 +1,12 @@
-# Copyright (C) 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
 
-UMF_0.10 {
+UMF_1.0 {
     global:
         umfInit;
         umfTearDown;
-        umfGetCurrentVersion;
         umfCloseIPCHandle;
-        umfCoarseMemoryProviderGetStats;
-        umfCoarseMemoryProviderOps;
         umfCUDAMemoryProviderOps;
         umfCUDAMemoryProviderParamsCreate;
         umfCUDAMemoryProviderParamsDestroy;
@@ -21,15 +18,17 @@ UMF_0.10 {
         umfDevDaxMemoryProviderParamsDestroy;
         umfDevDaxMemoryProviderParamsSetDeviceDax;
         umfDevDaxMemoryProviderParamsSetProtection;
-        umfFree;
         umfFileMemoryProviderOps;
         umfFileMemoryProviderParamsCreate;
         umfFileMemoryProviderParamsDestroy;
         umfFileMemoryProviderParamsSetPath;
         umfFileMemoryProviderParamsSetProtection;
         umfFileMemoryProviderParamsSetVisibility;
+        umfFree;
+        umfGetCurrentVersion;
         umfGetIPCHandle;
         umfGetLastFailedMemoryProvider;
+        umfJemallocPoolOps;
         umfLevelZeroMemoryProviderOps;
         umfLevelZeroMemoryProviderParamsCreate;
         umfLevelZeroMemoryProviderParamsDestroy;
@@ -55,7 +54,6 @@ UMF_0.10 {
         umfMemoryProviderPurgeForce;
         umfMemoryProviderPurgeLazy;
         umfMemoryProviderPutIPCHandle;
-        umfMemoryTrackerGetAllocInfo;
         umfMempolicyCreate;
         umfMempolicyDestroy;
         umfMempolicySetCustomSplitPartitions;
@@ -82,13 +80,13 @@ UMF_0.10 {
         umfOsMemoryProviderOps;
         umfOsMemoryProviderParamsCreate;
         umfOsMemoryProviderParamsDestroy;
-        umfOsMemoryProviderParamsSetProtection;
-        umfOsMemoryProviderParamsSetVisibility;
-        umfOsMemoryProviderParamsSetShmName;
         umfOsMemoryProviderParamsSetNumaList;
         umfOsMemoryProviderParamsSetNumaMode;
-        umfOsMemoryProviderParamsSetPartSize;
         umfOsMemoryProviderParamsSetPartitions;
+        umfOsMemoryProviderParamsSetPartSize;
+        umfOsMemoryProviderParamsSetProtection;
+        umfOsMemoryProviderParamsSetShmName;
+        umfOsMemoryProviderParamsSetVisibility;
         umfPoolAlignedMalloc;
         umfPoolByPtr;
         umfPoolCalloc;
@@ -100,9 +98,11 @@ UMF_0.10 {
         umfPoolGetIPCHandleSize;
         umfPoolGetLastAllocationError;
         umfPoolGetMemoryProvider;
+        umfPoolGetTag;
         umfPoolMalloc;
         umfPoolMallocUsableSize;
         umfPoolRealloc;
+        umfPoolSetTag;
         umfProxyPoolOps;
         umfPutIPCHandle;
         umfScalablePoolOps;
@@ -110,6 +110,50 @@ UMF_0.10 {
         umfScalablePoolParamsDestroy;
         umfScalablePoolParamsSetGranularity;
         umfScalablePoolParamsSetKeepAllMemory;
+# Added in UMF_0.11
+        umfCUDAMemoryProviderParamsSetAllocFlags;
+        umfDisjointPoolOps;
+        umfDisjointPoolParamsCreate;
+        umfDisjointPoolParamsDestroy;
+        umfDisjointPoolParamsSetCapacity;
+        umfDisjointPoolParamsSetMaxPoolableSize;
+        umfDisjointPoolParamsSetMinBucketSize;
+        umfDisjointPoolParamsSetName;
+        umfDisjointPoolParamsSetSharedLimits;
+        umfDisjointPoolParamsSetSlabMinSize;
+        umfDisjointPoolParamsSetTrace;
+        umfDisjointPoolSharedLimitsCreate;
+        umfDisjointPoolSharedLimitsDestroy;
+        umfFixedMemoryProviderOps;
+        umfFixedMemoryProviderParamsCreate;
+        umfFixedMemoryProviderParamsDestroy;
+        umfFixedMemoryProviderParamsSetMemory;
+        umfLevelZeroMemoryProviderParamsSetDeviceOrdinal;
+        umfLevelZeroMemoryProviderParamsSetFreePolicy;
+# Added in UMF_1.0
+        umfCtlExec;
+        umfCtlGet;
+        umfCtlSet;
+        umfJemallocPoolParamsCreate;
+        umfJemallocPoolParamsDestroy;
+        umfJemallocPoolParamsSetNumArenas;
+        umfPoolGetName;
     local:
         *;
 };
+
+UMF_1.1 {
+    umfCUDAMemoryProviderParamsSetName;
+    umfDevDaxMemoryProviderParamsSetName;
+    umfFileMemoryProviderParamsSetName;
+    umfFixedMemoryProviderParamsSetName;
+    umfGetMemoryPropertiesHandle;
+    umfGetMemoryProperty;
+    umfGetMemoryPropertySize;
+    umfJemallocPoolParamsSetName;
+    umfLevelZeroMemoryProviderParamsSetName;
+    umfLevelZeroMemoryProviderResidentDeviceChange;
+    umfOsMemoryProviderParamsSetName;
+    umfPoolTrimMemory;
+    umfScalablePoolParamsSetName;
+} UMF_1.0;
diff --git a/src/libumf.rc.in b/src/libumf.rc.in
index 7aba79e7ed..43bed1560f 100644
--- a/src/libumf.rc.in
+++ b/src/libumf.rc.in
@@ -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
@@ -10,6 +10,8 @@
 
 #define UMF_VERNUMBERS @PROJECT_VERSION_MAJOR@,@PROJECT_VERSION_MINOR@,@PROJECT_VERSION_PATCH@,@UMF_VERSION_REVISION@
 #define _UMF_VERSION "@UMF_VERSION@"
+// Store our CMake vars in the "FileDescription" block, as the custom fields require special parsing.
+#define _UMF_CMAKE_VARS "@UMF_ALL_CMAKE_VARIABLES@"
 
 #ifdef _DEBUG
 #define VERSION_DEBUG VS_FF_DEBUG
@@ -49,9 +51,9 @@ BEGIN
         BLOCK "040904b0" // U.S. English, Unicode (0x04b0 == 1200)
         BEGIN
             VALUE "CompanyName", "Intel Corporation\0"
-            VALUE "FileDescription", "Unified Memory Framework (UMF) library\0"
+            VALUE "FileDescription", "Unified Memory Framework (UMF) library (build options: " _UMF_CMAKE_VARS ")\0"
             VALUE "FileVersion", _UMF_VERSION "\0"
-            VALUE "LegalCopyright", "Copyright 2024, Intel Corporation. All rights reserved.\0"
+            VALUE "LegalCopyright", "Copyright 2024-2025, Intel Corporation. All rights reserved.\0"
             VALUE "LegalTrademarks", "\0"
             VALUE "OriginalFilename", "umf.dll\0"
             VALUE "ProductName", "Unified Memory Framework (UMF)\0"
diff --git a/src/libumf_linux.c b/src/libumf_linux.c
index 8832952ead..0bb8a1d4e1 100644
--- a/src/libumf_linux.c
+++ b/src/libumf_linux.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -11,7 +11,7 @@
 
 void __attribute__((constructor)) umfCreate(void) { (void)umfInit(); }
 
-void __attribute__((destructor)) umfDestroy(void) { umfTearDown(); }
+void __attribute__((destructor)) umfDestroy(void) { (void)umfTearDown(); }
 
 void libumfInit(void) {
     // do nothing, additional initialization not needed
diff --git a/src/libumf_windows.c b/src/libumf_windows.c
index 1531a7b8b1..29d2e5bee1 100644
--- a/src/libumf_windows.c
+++ b/src/libumf_windows.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -20,7 +20,7 @@ BOOL APIENTRY DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
     if (fdwReason == DLL_PROCESS_ATTACH) {
         (void)umfInit();
     } else if (fdwReason == DLL_PROCESS_DETACH) {
-        umfTearDown();
+        (void)umfTearDown();
     }
     return TRUE;
 }
@@ -33,15 +33,17 @@ void libumfInit(void) {
 
 INIT_ONCE init_once_flag = INIT_ONCE_STATIC_INIT;
 
+static void umfTearDownWrapper(void) { (void)umfTearDown(); }
+
 BOOL CALLBACK initOnceCb(PINIT_ONCE InitOnce, PVOID Parameter,
                          PVOID *lpContext) {
     (void)InitOnce;  // unused
     (void)Parameter; // unused
     (void)lpContext; // unused
 
-    int ret = umfInit();
-    atexit(umfTearDown);
-    return (ret == 0) ? TRUE : FALSE;
+    umf_result_t ret = umfInit();
+    atexit(umfTearDownWrapper);
+    return (ret == UMF_RESULT_SUCCESS) ? TRUE : FALSE;
 }
 
 void libumfInit(void) {
diff --git a/src/memory_pool.c b/src/memory_pool.c
index 4a85955efa..2161d5d45c 100644
--- a/src/memory_pool.c
+++ b/src/memory_pool.c
@@ -1,51 +1,441 @@
 /*
  *
- * 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 "libumf.h"
-#include "memory_pool_internal.h"
-#include "utils_assert.h"
+#include <assert.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <string.h>
 
+#include <umf/base.h>
 #include <umf/memory_pool.h>
 #include <umf/memory_pool_ops.h>
 
-#include <assert.h>
-#include <stdlib.h>
-
 #include "base_alloc_global.h"
+#include "ctl/ctl_defaults.h"
+#include "ctl/ctl_internal.h"
+#include "libumf.h"
 #include "memory_pool_internal.h"
 #include "memory_provider_internal.h"
 #include "provider_tracking.h"
+#include "utils_assert.h"
+#include "utils_concurrency.h"
+#include "utils_log.h"
+#include "utils_name.h"
+#include "utlist.h"
+
+// Handle UTHash memory allocation failures without aborting the process.
+#define HASH_NONFATAL_OOM 1
+static bool uthash_oom = false;
+#define uthash_nonfatal_oom(obj)                                               \
+    do {                                                                       \
+        (void)(obj);                                                           \
+        uthash_oom = true;                                                     \
+    } while (0)
+
+#include "uthash.h"
+
+static ctl_default_entry_t *pool_default_list = NULL;
+static utils_mutex_t pool_default_mtx;
+static UTIL_ONCE_FLAG mem_pool_ctl_initialized = UTIL_ONCE_FLAG_INIT;
+
+static struct ctl umf_pool_ctl_root;
+
+static void pool_ctl_init(void);
+
+typedef struct pool_name_list_entry_t {
+    umf_memory_pool_handle_t pool;
+    struct pool_name_list_entry_t *next;
+} pool_name_list_entry_t;
+
+typedef struct pool_name_dict_entry_t {
+    char *name; /* key */
+    pool_name_list_entry_t *pools;
+    UT_hash_handle hh;
+} pool_name_dict_entry_t;
+
+static pool_name_dict_entry_t *pools_by_name = NULL;
+static utils_rwlock_t pools_by_name_lock;
+static UTIL_ONCE_FLAG pools_by_name_init_once = UTIL_ONCE_FLAG_INIT;
+
+static void pools_by_name_init(void) { utils_rwlock_init(&pools_by_name_lock); }
+
+static umf_result_t pools_by_name_add(umf_memory_pool_handle_t pool) {
+    const char *name = NULL;
+    umf_result_t ret = pool->ops.get_name(pool->pool_priv, &name);
+    if (ret != UMF_RESULT_SUCCESS || !name) {
+        return ret;
+    }
+
+    if (!utils_name_is_valid(name)) {
+        LOG_ERR("Pool name: %s contains invalid character, ctl by_name is not "
+                "supported for this pool",
+                name);
+        return UMF_RESULT_SUCCESS;
+    }
+
+    utils_init_once(&pools_by_name_init_once, pools_by_name_init);
+    utils_write_lock(&pools_by_name_lock);
+
+    pool_name_dict_entry_t *entry = NULL;
+    HASH_FIND_STR(pools_by_name, name, entry);
+    if (!entry) {
+        entry = umf_ba_global_alloc(sizeof(*entry));
+        if (!entry) {
+            utils_write_unlock(&pools_by_name_lock);
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        }
+        entry->name = umf_ba_global_strdup(name);
+        if (!entry->name) {
+            umf_ba_global_free(entry);
+            utils_write_unlock(&pools_by_name_lock);
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        }
+
+        entry->pools = NULL;
+        uthash_oom = false;
+        HASH_ADD_KEYPTR(hh, pools_by_name, entry->name, strlen(entry->name),
+                        entry);
+        if (uthash_oom) {
+            umf_ba_global_free(entry->name);
+            umf_ba_global_free(entry);
+            utils_write_unlock(&pools_by_name_lock);
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        }
+    }
+
+    pool_name_list_entry_t *node = umf_ba_global_alloc(sizeof(*node));
+    if (!node) {
+        utils_write_unlock(&pools_by_name_lock);
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+    node->pool = pool;
+    node->next = NULL;
+    LL_APPEND(entry->pools, node);
+
+    utils_write_unlock(&pools_by_name_lock);
+    return UMF_RESULT_SUCCESS;
+}
+
+static void pools_by_name_remove(umf_memory_pool_handle_t pool) {
+    const char *name = NULL;
+    if (pool->ops.get_name(pool->pool_priv, &name) != UMF_RESULT_SUCCESS ||
+        !name) {
+        return;
+    }
+
+    utils_init_once(&pools_by_name_init_once, pools_by_name_init);
+    utils_write_lock(&pools_by_name_lock);
+
+    pool_name_dict_entry_t *entry = NULL;
+    HASH_FIND_STR(pools_by_name, name, entry);
+    if (entry) {
+        pool_name_list_entry_t *it = NULL, *tmp = NULL;
+        LL_FOREACH_SAFE(entry->pools, it, tmp) {
+            if (it->pool == pool) {
+                LL_DELETE(entry->pools, it);
+                umf_ba_global_free(it);
+                break;
+            }
+        }
+        if (entry->pools == NULL) {
+            HASH_DEL(pools_by_name, entry);
+            umf_ba_global_free(entry->name);
+            umf_ba_global_free(entry);
+        }
+    }
+
+    utils_write_unlock(&pools_by_name_lock);
+}
+
+static umf_result_t CTL_SUBTREE_HANDLER(CTL_NONAME, by_handle)(
+    void *ctx, umf_ctl_query_source_t source, void *arg, size_t size,
+    umf_ctl_index_utlist_t *indexes, const char *extra_name,
+    umf_ctl_query_type_t queryType, va_list args) {
+    (void)source, (void)ctx;
+
+    umf_memory_pool_handle_t hPool = *(umf_memory_pool_handle_t *)indexes->arg;
+    va_list args2;
+    va_copy(args2, args);
+
+    umf_result_t ret = ctl_query(&umf_pool_ctl_root, hPool, source, extra_name,
+                                 queryType, arg, size, args2);
+    va_end(args2);
+
+    if (ret == UMF_RESULT_ERROR_INVALID_CTL_PATH) {
+        // Node was not found in pool_ctl_root, try to query the specific pool
+        ret = hPool->ops.ext_ctl(hPool->pool_priv, source, extra_name, arg,
+                                 size, queryType, args);
+    }
+
+    return ret;
+}
+
+static umf_result_t CTL_SUBTREE_HANDLER(default)(
+    void *ctx, umf_ctl_query_source_t source, void *arg, size_t size,
+    umf_ctl_index_utlist_t *indexes, const char *extra_name,
+    umf_ctl_query_type_t queryType, va_list args) {
+    (void)indexes;
+    (void)ctx;
+    (void)args;
+    utils_init_once(&mem_pool_ctl_initialized, pool_ctl_init);
+    return ctl_default_subtree(&pool_default_list, &pool_default_mtx, source,
+                               arg, size, extra_name, queryType);
+}
+
+static umf_result_t
+CTL_READ_HANDLER(alloc_count)(void *ctx, umf_ctl_query_source_t source,
+                              void *arg, size_t size,
+                              umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)size, (void)indexes;
 
+    size_t *arg_out = arg;
+    if (ctx == NULL || arg_out == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    assert(size == sizeof(size_t));
+
+    umf_memory_pool_handle_t pool = (umf_memory_pool_handle_t)ctx;
+    utils_atomic_load_acquire_size_t(&pool->stats.alloc_count, arg_out);
+    return UMF_RESULT_SUCCESS;
+}
+
+static const umf_ctl_node_t CTL_NODE(stats)[] = {CTL_LEAF_RO(alloc_count),
+                                                 CTL_NODE_END};
+
+static umf_ctl_node_t CTL_NODE(by_handle)[] = {
+    CTL_LEAF_SUBTREE(CTL_NONAME, by_handle),
+    CTL_NODE_END,
+};
+
+static const struct ctl_argument CTL_ARG(by_handle) = CTL_ARG_PTR;
+
+typedef struct by_name_arg_t {
+    char name[255];
+    size_t index;
+} by_name_arg_t;
+
+// parses optional size_t argument. if arg is not integer then sets out to size_max
+static int by_name_index_parser(const void *arg, void *dest, size_t dest_size) {
+    size_t *out = (size_t *)dest;
+
+    if (arg == NULL) {
+        *out = SIZE_MAX;
+        return 1; // node n
+    }
+
+    int ret = ctl_arg_unsigned(arg, dest, dest_size);
+    if (ret) {
+        *out = SIZE_MAX;
+        return 1;
+    }
+
+    return 0;
+}
+
+static const struct ctl_argument CTL_ARG(by_name) = {
+    sizeof(by_name_arg_t),
+    {CTL_ARG_PARSER_STRUCT(by_name_arg_t, name, CTL_ARG_TYPE_STRING,
+                           ctl_arg_string),
+     CTL_ARG_PARSER_STRUCT(by_name_arg_t, index,
+                           CTL_ARG_TYPE_UNSIGNED_LONG_LONG,
+                           by_name_index_parser),
+     CTL_ARG_PARSER_END}};
+
+static umf_result_t CTL_SUBTREE_HANDLER(CTL_NONAME, by_name)(
+    void *ctx, umf_ctl_query_source_t source, void *arg, size_t size,
+    umf_ctl_index_utlist_t *indexes, const char *extra_name,
+    umf_ctl_query_type_t queryType, va_list args) {
+    (void)ctx;
+
+    utils_init_once(&pools_by_name_init_once, pools_by_name_init);
+
+    by_name_arg_t *name_arg = (by_name_arg_t *)indexes->arg;
+
+    utils_read_lock(&pools_by_name_lock);
+    pool_name_dict_entry_t *entry = NULL;
+    // find pool name in the hashmap
+    HASH_FIND_STR(pools_by_name, name_arg->name, entry);
+    if (!entry) {
+        utils_read_unlock(&pools_by_name_lock);
+        LOG_ERR("Pool %s not found", name_arg->name);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    size_t count = 0;
+    pool_name_list_entry_t *it = NULL;
+    LL_COUNT(entry->pools, it, count);
+    // Special case: if user asked for umf.pool.by_name.name.count, we just return
+    // number of pools sharing the same name.
+    if (strcmp(extra_name, "count") == 0) {
+        if (name_arg->index != SIZE_MAX) {
+            LOG_ERR("count field requires no index argument");
+            utils_read_unlock(&pools_by_name_lock);
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+        if (queryType != CTL_QUERY_READ) {
+            LOG_ERR("count field is read only");
+            utils_read_unlock(&pools_by_name_lock);
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+        size_t *output = (size_t *)arg;
+        *output = count;
+        utils_read_unlock(&pools_by_name_lock);
+        return UMF_RESULT_SUCCESS;
+    }
+
+    if (queryType == CTL_QUERY_READ && count > 1 &&
+        name_arg->index == SIZE_MAX) {
+        LOG_ERR("CTL 'by_name' read operation requires exactly one pool with "
+                "the specified name. "
+                "Actual number of pools with name '%s' is %zu. "
+                "You can add extra index parameter after the name to specify "
+                "exact pool e.g. umf.pool.by_name.pool_name,1.node_name",
+                name_arg->name, count);
+        utils_read_unlock(&pools_by_name_lock);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_result_t ret = UMF_RESULT_SUCCESS;
+    size_t nr = 0;
+
+    if (name_arg->index != SIZE_MAX && name_arg->index >= count) {
+        LOG_ERR(
+            "Invalid index %zu. Actual number of pools with name '%s' is %zu. ",
+            name_arg->index, name_arg->name, count);
+        utils_read_unlock(&pools_by_name_lock);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    LL_FOREACH(entry->pools, it) {
+        if (name_arg->index != SIZE_MAX && nr++ != name_arg->index) {
+            continue;
+        }
+        va_list args2;
+        va_copy(args2, args);
+        umf_result_t r = ctl_query(&umf_pool_ctl_root, it->pool, source,
+                                   extra_name, queryType, arg, size, args2);
+        va_end(args2);
+
+        if (r == UMF_RESULT_ERROR_INVALID_CTL_PATH) {
+            va_copy(args2, args);
+            r = it->pool->ops.ext_ctl(it->pool->pool_priv, source, extra_name,
+                                      arg, size, queryType, args2);
+            va_end(args2);
+        }
+        if (r != UMF_RESULT_SUCCESS && ret == UMF_RESULT_SUCCESS) {
+            ret = r;
+        }
+    }
+    utils_read_unlock(&pools_by_name_lock);
+
+    return ret;
+}
+
+static umf_ctl_node_t CTL_NODE(by_name)[] = {
+    CTL_LEAF_SUBTREE(CTL_NONAME, by_name),
+    CTL_NODE_END,
+};
+
+umf_ctl_node_t CTL_NODE(pool)[] = {CTL_CHILD_WITH_ARG(by_handle),
+                                   CTL_CHILD_WITH_ARG(by_name),
+                                   CTL_LEAF_SUBTREE(default), CTL_NODE_END};
+
+static void pool_ctl_init(void) {
+    utils_mutex_init(&pool_default_mtx);
+    CTL_REGISTER_MODULE(&umf_pool_ctl_root, stats);
+}
+
+static umf_result_t
+umfDefaultCtlPoolHandle(void *hPool, umf_ctl_query_source_t operationType,
+                        const char *name, void *arg, size_t size,
+                        umf_ctl_query_type_t queryType, va_list args) {
+    (void)hPool;
+    (void)operationType;
+    (void)name;
+    (void)arg;
+    (void)size;
+    (void)queryType;
+    (void)args;
+    // if given path is not supported implementation should return UMF_RESULT_ERROR_INVALID_CTL_PATH
+    return UMF_RESULT_ERROR_INVALID_CTL_PATH;
+}
+
+static umf_result_t umfDefaultTrimMemory(void *provider,
+                                         size_t minBytesToKeep) {
+    (void)provider;
+    (void)minBytesToKeep;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+static umf_result_t umfPoolPostInitialize(const umf_memory_pool_ops_t *ops,
+                                          void *pool_priv, ...) {
+    va_list args;
+    va_start(args, pool_priv);
+    umf_result_t ret =
+        ops->ext_ctl(pool_priv, CTL_QUERY_PROGRAMMATIC, "post_initialize", NULL,
+                     0, CTL_QUERY_RUNNABLE, args);
+    va_end(args);
+
+    return ret;
+}
+
+// logical sum (OR) of all umf_pool_create_flags_t flags
+static const umf_pool_create_flags_t UMF_POOL_CREATE_FLAG_ALL =
+    UMF_POOL_CREATE_FLAG_OWN_PROVIDER | UMF_POOL_CREATE_FLAG_DISABLE_TRACKING;
+
+// windows do not allow to use uninitialized va_list so this function help us to initialize it.
 static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
                                           umf_memory_provider_handle_t provider,
-                                          void *params,
+                                          const void *params,
                                           umf_pool_create_flags_t flags,
                                           umf_memory_pool_handle_t *hPool) {
-    if (!ops || !provider || !hPool) {
+    UMF_CHECK((ops != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((provider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((hPool != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // validate flags
+    if (flags & ~UMF_POOL_CREATE_FLAG_ALL) {
+        LOG_ERR("Invalid flags: 0x%x", flags);
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
     umf_result_t ret = UMF_RESULT_SUCCESS;
+    umf_memory_pool_ops_t compatible_ops;
+    if (ops->version != UMF_POOL_OPS_VERSION_CURRENT) {
+        LOG_WARN("Memory Pool ops version \"%d\" is different than the current "
+                 "version \"%d\"",
+                 ops->version, UMF_POOL_OPS_VERSION_CURRENT);
+
+        // Create a new ops compatible structure with the current version
+        memset(&compatible_ops, 0, sizeof(compatible_ops));
+        if (ops->version < UMF_MAKE_VERSION(1, 1)) {
+            LOG_INFO("Detected 1.0 version or below of Memory Pool ops, "
+                     "upgrading to current version");
+            memcpy(&compatible_ops, ops,
+                   offsetof(umf_memory_pool_ops_t, ext_trim_memory));
+        } else {
+            LOG_ERR("Unsupported Memory Pool ops version: %d", ops->version);
+            return UMF_RESULT_ERROR_NOT_SUPPORTED;
+        }
+        ops = &compatible_ops;
+    }
+
     umf_memory_pool_handle_t pool =
         umf_ba_global_alloc(sizeof(umf_memory_pool_t));
     if (!pool) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    assert(ops->version == UMF_VERSION_CURRENT);
-
     if (!(flags & UMF_POOL_CREATE_FLAG_DISABLE_TRACKING)) {
         // Wrap provider with memory tracking provider.
-        // Check if the provider supports the free() operation.
-        bool upstreamDoesNotFree = umfIsFreeOpDefault(provider);
-        ret = umfTrackingMemoryProviderCreate(provider, pool, &pool->provider,
-                                              upstreamDoesNotFree);
+        ret = umfTrackingMemoryProviderCreate(provider, pool, &pool->provider);
         if (ret != UMF_RESULT_SUCCESS) {
             goto err_provider_create;
         }
@@ -53,19 +443,57 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
         pool->provider = provider;
     }
 
+    utils_init_once(&mem_pool_ctl_initialized, pool_ctl_init);
+
     pool->flags = flags;
     pool->ops = *ops;
+    pool->tag = NULL;
+    memset(&pool->stats, 0, sizeof(pool->stats));
+
+    if (NULL == pool->ops.ext_ctl) {
+        pool->ops.ext_ctl = umfDefaultCtlPoolHandle;
+    }
+
+    if (NULL == pool->ops.ext_trim_memory) {
+        pool->ops.ext_trim_memory = umfDefaultTrimMemory;
+    }
 
-    ret = ops->initialize(pool->provider, params, &pool->pool_priv);
+    if (NULL == utils_mutex_init(&pool->lock)) {
+        LOG_ERR("Failed to initialize mutex for pool");
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+        goto err_lock_init;
+    }
+
+    ret = pool->ops.initialize(pool->provider, params, &pool->pool_priv);
+    if (ret != UMF_RESULT_SUCCESS) {
+        goto err_pool_init;
+    }
+
+    const char *pname = NULL;
+    ret = ops->get_name(pool->pool_priv, &pname);
     if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Failed to get pool name");
+        goto err_pool_init;
+    }
+    assert(pname != NULL);
+    utils_warn_invalid_name("Memory pool", pname);
+    ctl_default_apply(pool_default_list, pname, ops->ext_ctl, pool->pool_priv);
+
+    ret = umfPoolPostInitialize(&pool->ops, pool->pool_priv);
+    if (ret != UMF_RESULT_SUCCESS && ret != UMF_RESULT_ERROR_INVALID_CTL_PATH) {
+        LOG_ERR("Failed to post-initialize pool");
         goto err_pool_init;
     }
 
     *hPool = pool;
+    pools_by_name_add(pool);
+
     LOG_INFO("Memory pool created: %p", (void *)pool);
     return UMF_RESULT_SUCCESS;
 
 err_pool_init:
+    utils_mutex_destroy_not_free(&pool->lock);
+err_lock_init:
     if (!(flags & UMF_POOL_CREATE_FLAG_DISABLE_TRACKING)) {
         umfMemoryProviderDestroy(pool->provider);
     }
@@ -74,45 +502,75 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
     return ret;
 }
 
-void umfPoolDestroy(umf_memory_pool_handle_t hPool) {
-    hPool->ops.finalize(hPool->pool_priv);
+umf_result_t umfPoolDestroy(umf_memory_pool_handle_t hPool) {
+    UMF_CHECK((hPool != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    if (umf_ba_global_is_destroyed()) {
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    pools_by_name_remove(hPool);
+
+    umf_result_t ret = hPool->ops.finalize(hPool->pool_priv);
 
     umf_memory_provider_handle_t hUpstreamProvider = NULL;
     umfPoolGetMemoryProvider(hPool, &hUpstreamProvider);
 
     if (!(hPool->flags & UMF_POOL_CREATE_FLAG_DISABLE_TRACKING)) {
         // Destroy tracking provider.
-        umfMemoryProviderDestroy(hPool->provider);
+        umf_result_t ret2 = umfMemoryProviderDestroy(hPool->provider);
+        if (ret == UMF_RESULT_SUCCESS) {
+            ret = ret2;
+        }
     }
 
     if (hPool->flags & UMF_POOL_CREATE_FLAG_OWN_PROVIDER) {
         // Destroy associated memory provider.
-        umfMemoryProviderDestroy(hUpstreamProvider);
+        umf_result_t ret2 = umfMemoryProviderDestroy(hUpstreamProvider);
+        if (ret == UMF_RESULT_SUCCESS) {
+            ret = ret2;
+        }
     }
 
+    utils_mutex_destroy_not_free(&hPool->lock);
+
     LOG_INFO("Memory pool destroyed: %p", (void *)hPool);
 
     // TODO: this free keeps memory in base allocator, so it can lead to OOM in some scenarios (it should be optimized)
     umf_ba_global_free(hPool);
+    return ret;
 }
 
 umf_result_t umfFree(void *ptr) {
-    umf_memory_pool_handle_t hPool = umfPoolByPtr(ptr);
-    if (hPool) {
+    umf_memory_pool_handle_t hPool = NULL;
+    umf_result_t ret = umfPoolByPtr(ptr, &hPool);
+    if (ret == UMF_RESULT_SUCCESS) {
+        LOG_DEBUG("calling umfPoolFree(pool=%p, ptr=%p) ...", (void *)hPool,
+                  ptr);
         return umfPoolFree(hPool, ptr);
     }
-    return UMF_RESULT_SUCCESS;
+    return ret;
 }
 
-umf_memory_pool_handle_t umfPoolByPtr(const void *ptr) {
-    return umfMemoryTrackerGetPool(ptr);
+umf_result_t umfPoolByPtr(const void *ptr, umf_memory_pool_handle_t *pool) {
+    UMF_CHECK(pool != NULL, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK(ptr != NULL, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_memory_properties_handle_t props = NULL;
+    umf_result_t ret = umfGetMemoryPropertiesHandle(ptr, &props);
+    if (ret != UMF_RESULT_SUCCESS || props == NULL || props->pool == NULL) {
+        *pool = NULL;
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    *pool = props->pool;
+    return UMF_RESULT_SUCCESS;
 }
 
 umf_result_t umfPoolGetMemoryProvider(umf_memory_pool_handle_t hPool,
                                       umf_memory_provider_handle_t *hProvider) {
-    if (!hProvider) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    UMF_CHECK((hPool != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     if (hPool->flags & UMF_POOL_CREATE_FLAG_DISABLE_TRACKING) {
         *hProvider = hPool->provider;
@@ -124,9 +582,15 @@ umf_result_t umfPoolGetMemoryProvider(umf_memory_pool_handle_t hPool,
     return UMF_RESULT_SUCCESS;
 }
 
+umf_result_t umfPoolGetName(umf_memory_pool_handle_t pool, const char **name) {
+    UMF_CHECK((pool != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((name != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    return pool->ops.get_name(pool->pool_priv, name);
+}
+
 umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
-                           umf_memory_provider_handle_t provider, void *params,
-                           umf_pool_create_flags_t flags,
+                           umf_memory_provider_handle_t provider,
+                           const void *params, umf_pool_create_flags_t flags,
                            umf_memory_pool_handle_t *hPool) {
     libumfInit();
 
@@ -142,36 +606,102 @@ umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
 
 void *umfPoolMalloc(umf_memory_pool_handle_t hPool, size_t size) {
     UMF_CHECK((hPool != NULL), NULL);
-    return hPool->ops.malloc(hPool->pool_priv, size);
+    void *ret = hPool->ops.malloc(hPool->pool_priv, size);
+    if (!ret) {
+        return NULL;
+    }
+
+    utils_atomic_increment_size_t(&hPool->stats.alloc_count);
+    return ret;
 }
 
 void *umfPoolAlignedMalloc(umf_memory_pool_handle_t hPool, size_t size,
                            size_t alignment) {
     UMF_CHECK((hPool != NULL), NULL);
-    return hPool->ops.aligned_malloc(hPool->pool_priv, size, alignment);
+    void *ret = hPool->ops.aligned_malloc(hPool->pool_priv, size, alignment);
+    if (!ret) {
+        return NULL;
+    }
+
+    utils_atomic_increment_size_t(&hPool->stats.alloc_count);
+    return ret;
 }
 
 void *umfPoolCalloc(umf_memory_pool_handle_t hPool, size_t num, size_t size) {
     UMF_CHECK((hPool != NULL), NULL);
-    return hPool->ops.calloc(hPool->pool_priv, num, size);
+    void *ret = hPool->ops.calloc(hPool->pool_priv, num, size);
+    if (!ret) {
+        return NULL;
+    }
+
+    utils_atomic_increment_size_t(&hPool->stats.alloc_count);
+    return ret;
 }
 
 void *umfPoolRealloc(umf_memory_pool_handle_t hPool, void *ptr, size_t size) {
     UMF_CHECK((hPool != NULL), NULL);
-    return hPool->ops.realloc(hPool->pool_priv, ptr, size);
+    void *ret = hPool->ops.realloc(hPool->pool_priv, ptr, size);
+    if (size == 0 && ret == NULL && ptr != NULL) { // this is free(ptr)
+        utils_atomic_decrement_size_t(&hPool->stats.alloc_count);
+    } else if (ptr == NULL && ret != NULL) { // this is malloc(size)
+        utils_atomic_increment_size_t(&hPool->stats.alloc_count);
+    }
+    return ret;
 }
 
-size_t umfPoolMallocUsableSize(umf_memory_pool_handle_t hPool, void *ptr) {
-    UMF_CHECK((hPool != NULL), 0);
-    return hPool->ops.malloc_usable_size(hPool->pool_priv, ptr);
+umf_result_t umfPoolMallocUsableSize(umf_memory_pool_handle_t hPool,
+                                     const void *ptr, size_t *size) {
+    UMF_CHECK((hPool != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    return hPool->ops.malloc_usable_size(hPool->pool_priv, ptr, size);
 }
 
 umf_result_t umfPoolFree(umf_memory_pool_handle_t hPool, void *ptr) {
     UMF_CHECK((hPool != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
-    return hPool->ops.free(hPool->pool_priv, ptr);
+    umf_result_t ret = hPool->ops.free(hPool->pool_priv, ptr);
+
+    if (ret != UMF_RESULT_SUCCESS) {
+        return ret;
+    }
+    if (ptr != NULL) {
+        utils_atomic_decrement_size_t(&hPool->stats.alloc_count);
+    }
+    return ret;
 }
 
 umf_result_t umfPoolGetLastAllocationError(umf_memory_pool_handle_t hPool) {
     UMF_CHECK((hPool != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     return hPool->ops.get_last_allocation_error(hPool->pool_priv);
 }
+
+umf_result_t umfPoolSetTag(umf_memory_pool_handle_t hPool, void *tag,
+                           void **oldTag) {
+    UMF_CHECK((hPool != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    utils_mutex_lock(&hPool->lock);
+    if (oldTag) {
+        *oldTag = hPool->tag;
+    }
+    hPool->tag = tag;
+    utils_mutex_unlock(&hPool->lock);
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfPoolGetTag(umf_memory_pool_handle_t hPool, void **tag) {
+    UMF_CHECK((hPool != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((tag != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    utils_mutex_lock(&hPool->lock);
+    *tag = hPool->tag;
+    utils_mutex_unlock(&hPool->lock);
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfPoolTrimMemory(umf_memory_pool_handle_t hPool,
+                               size_t minBytesToKeep) {
+    UMF_CHECK((hPool != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    return hPool->ops.ext_trim_memory(hPool->pool_priv, minBytesToKeep);
+}
+
+void umfPoolCtlDefaultsDestroy(void) {
+    utils_init_once(&mem_pool_ctl_initialized, pool_ctl_init);
+    ctl_default_destroy(&pool_default_list, &pool_default_mtx);
+}
diff --git a/src/memory_pool_internal.h b/src/memory_pool_internal.h
index 90f2f16298..8c66cd4e78 100644
--- a/src/memory_pool_internal.h
+++ b/src/memory_pool_internal.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 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
@@ -22,16 +22,33 @@ extern "C" {
 #endif
 
 #include "base_alloc.h"
+#include "ctl/ctl_internal.h"
+#include "utils_concurrency.h"
+
+typedef struct umf_pool_stats {
+    size_t alloc_count;
+} umf_pool_stats_t;
 
 typedef struct umf_memory_pool_t {
     void *pool_priv;
-    umf_memory_pool_ops_t ops;
     umf_pool_create_flags_t flags;
 
     // Memory provider used by the pool.
     umf_memory_provider_handle_t provider;
+
+    utils_mutex_t lock;
+    void *tag;
+    // Memory pool statistics
+    umf_pool_stats_t stats;
+
+    // ops should be the last due to possible change size in the future
+    umf_memory_pool_ops_t ops;
 } umf_memory_pool_t;
 
+extern umf_ctl_node_t CTL_NODE(pool)[];
+
+void umfPoolCtlDefaultsDestroy(void);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/memory_properties.c b/src/memory_properties.c
new file mode 100644
index 0000000000..11d4e5593e
--- /dev/null
+++ b/src/memory_properties.c
@@ -0,0 +1,158 @@
+/*
+ *
+ * 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 <inttypes.h>
+
+#include <umf/experimental/memory_properties.h>
+#include <umf/providers/provider_cuda.h>
+#include <umf/providers/provider_level_zero.h>
+
+#include "memory_properties_internal.h"
+#include "memory_provider_internal.h"
+#include "provider/provider_tracking.h"
+
+umf_result_t
+umfGetMemoryPropertiesHandle(const void *ptr,
+                             umf_memory_properties_handle_t *props_handle) {
+    UMF_CHECK((props_handle != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    tracker_alloc_info_t *info = NULL;
+    umf_result_t ret = umfMemoryTrackerGetAllocInfo(ptr, &info);
+    if (ret == UMF_RESULT_SUCCESS) {
+        *props_handle = &info->props;
+        return UMF_RESULT_SUCCESS;
+    }
+
+    // try to get IPC info
+    umf_ipc_info_t ipc_info;
+    ret = umfMemoryTrackerGetIpcInfo(ptr, &ipc_info);
+    if (ret == UMF_RESULT_SUCCESS) {
+        *props_handle = ipc_info.props;
+        return UMF_RESULT_SUCCESS;
+    }
+
+    LOG_ERR("Failed to get memory properties handle for ptr=%p", ptr);
+    return ret;
+}
+
+umf_result_t
+umfGetMemoryPropertySize(umf_memory_properties_handle_t props_handle,
+                         umf_memory_property_id_t memory_property_id,
+                         size_t *size) {
+    UMF_CHECK((size != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    switch (memory_property_id) {
+    case UMF_MEMORY_PROPERTY_INVALID:
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    case UMF_MEMORY_PROPERTY_PROVIDER_HANDLE:
+        *size = sizeof(umf_memory_provider_handle_t);
+        return UMF_RESULT_SUCCESS;
+    case UMF_MEMORY_PROPERTY_POOL_HANDLE:
+        *size = sizeof(umf_memory_pool_handle_t);
+        return UMF_RESULT_SUCCESS;
+    case UMF_MEMORY_PROPERTY_BASE_ADDRESS:
+        *size = sizeof(uintptr_t);
+        return UMF_RESULT_SUCCESS;
+    case UMF_MEMORY_PROPERTY_BASE_SIZE:
+        *size = sizeof(size_t);
+        return UMF_RESULT_SUCCESS;
+    case UMF_MEMORY_PROPERTY_BUFFER_ID:
+        *size = sizeof(uint64_t);
+        return UMF_RESULT_SUCCESS;
+    case UMF_MEMORY_PROPERTY_POINTER_TYPE:
+        *size = sizeof(umf_usm_memory_type_t);
+        return UMF_RESULT_SUCCESS;
+    default:
+        break;
+    }
+
+    // custom memory properties should be handled by the user provider
+    umf_memory_provider_t *provider = props_handle->provider;
+    if (provider->ops.ext_get_allocation_properties_size) {
+        return provider->ops.ext_get_allocation_properties_size(
+            provider->provider_priv, memory_property_id, size);
+    }
+
+    LOG_ERR("Unknown memory property ID: %d", memory_property_id);
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfGetMemoryProperty(umf_memory_properties_handle_t props_handle,
+                                  umf_memory_property_id_t memory_property_id,
+                                  void *value, size_t max_property_size) {
+    UMF_CHECK((value != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((props_handle != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((max_property_size > 0), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_memory_provider_t *provider = props_handle->provider;
+
+    size_t property_size = 0;
+    umf_result_t ret = umfGetMemoryPropertySize(
+        props_handle, memory_property_id, &property_size);
+    if (UNLIKELY(ret != UMF_RESULT_SUCCESS)) {
+        LOG_ERR("Failed to get memory property size for ID %d",
+                memory_property_id);
+        return ret;
+    }
+
+    if (UNLIKELY(property_size > max_property_size)) {
+        LOG_ERR("Memory property size %zu exceeds max size %zu for ID %d",
+                property_size, max_property_size, memory_property_id);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    switch (memory_property_id) {
+    case UMF_MEMORY_PROPERTY_INVALID:
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+
+    case UMF_MEMORY_PROPERTY_POOL_HANDLE:
+        *(umf_memory_pool_handle_t *)value = props_handle->pool;
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_PROPERTY_PROVIDER_HANDLE:
+        *(umf_memory_provider_handle_t *)value = provider;
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_PROPERTY_BUFFER_ID:
+        *(uint64_t *)value = props_handle->id;
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_PROPERTY_BASE_ADDRESS:
+        *(uintptr_t *)value = (uintptr_t)props_handle->base;
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_PROPERTY_BASE_SIZE:
+        *(size_t *)value = props_handle->base_size;
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_PROPERTY_POINTER_TYPE:
+        // NOTE: this property is "cached" in the props_handle but the value is
+        // determined by the memory provider and set during addition to the
+        // tracker.
+        *(umf_usm_memory_type_t *)value = props_handle->memory_type;
+        return UMF_RESULT_SUCCESS;
+
+    // GPU Memory Provider specific properties - should be handled by the
+    // provider
+    case UMF_MEMORY_PROPERTY_CONTEXT:
+    case UMF_MEMORY_PROPERTY_DEVICE:
+    default:
+        break;
+    };
+
+    // custom memory properties should be handled by the user provider
+    if (provider->ops.ext_get_allocation_properties) {
+        return provider->ops.ext_get_allocation_properties(
+            provider->provider_priv, props_handle->base, memory_property_id,
+            value);
+    }
+
+    LOG_ERR("Unknown memory property ID: %d", memory_property_id);
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
diff --git a/src/memory_properties_internal.h b/src/memory_properties_internal.h
new file mode 100644
index 0000000000..3f2d6ef3aa
--- /dev/null
+++ b/src/memory_properties_internal.h
@@ -0,0 +1,45 @@
+/*
+ *
+ * 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
+ *
+ */
+
+#ifndef UMF_MEMORY_PROPERTIES_INTERNAL_H
+#define UMF_MEMORY_PROPERTIES_INTERNAL_H 1
+
+#include <stdbool.h>
+
+#include <umf/experimental/memory_properties.h>
+#include <umf/memory_pool.h>
+#include <umf/memory_provider.h>
+#include <umf/memory_provider_gpu.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct umf_memory_properties_t {
+    umf_memory_pool_handle_t pool;
+    umf_memory_provider_handle_t provider;
+    uint64_t id;
+    void *base;
+    size_t base_size;
+    umf_usm_memory_type_t memory_type;
+} umf_memory_properties_t;
+
+umf_result_t umfMemoryProviderGetAllocationProperties(
+    umf_memory_provider_handle_t hProvider, const void *ptr,
+    umf_memory_property_id_t propertyId, void *property_value);
+
+umf_result_t umfMemoryProviderGetAllocationPropertiesSize(
+    umf_memory_provider_handle_t hProvider, umf_memory_property_id_t propertyId,
+    size_t *size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // UMF_MEMORY_PROPERTIES_INTERNAL_H
diff --git a/src/memory_provider.c b/src/memory_provider.c
index 883f1be263..413de848fc 100644
--- a/src/memory_provider.c
+++ b/src/memory_provider.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -8,30 +8,66 @@
  */
 
 #include <assert.h>
+#include <stdarg.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
+#include <umf/base.h>
 #include <umf/memory_provider.h>
 
 #include "base_alloc.h"
 #include "base_alloc_global.h"
+#include "ctl/ctl_defaults.h"
+#include "ctl/ctl_internal.h"
 #include "libumf.h"
 #include "memory_provider_internal.h"
 #include "utils_assert.h"
+#include "utils_name.h"
 
-typedef struct umf_memory_provider_t {
-    umf_memory_provider_ops_t ops;
-    void *provider_priv;
-} umf_memory_provider_t;
+static umf_result_t CTL_SUBTREE_HANDLER(CTL_NONAME, by_handle)(
+    void *ctx, umf_ctl_query_source_t source, void *arg, size_t size,
+    umf_ctl_index_utlist_t *indexes, const char *extra_name,
+    umf_ctl_query_type_t queryType, va_list args) {
+    (void)indexes, (void)source, (void)ctx;
 
-static umf_result_t umfDefaultFree(void *provider, void *ptr, size_t size) {
-    (void)provider;
-    (void)ptr;
-    (void)size;
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    umf_memory_provider_handle_t hProvider =
+        *(umf_memory_provider_handle_t *)indexes->arg;
+    hProvider->ops.ext_ctl(hProvider->provider_priv, source, extra_name, arg,
+                           size, queryType, args);
+
+    return UMF_RESULT_SUCCESS;
 }
 
+static umf_ctl_node_t CTL_NODE(by_handle)[] = {
+    CTL_LEAF_SUBTREE(CTL_NONAME, by_handle),
+    CTL_NODE_END,
+};
+
+static const struct ctl_argument CTL_ARG(by_handle) = CTL_ARG_PTR;
+
+static ctl_default_entry_t *provider_default_list = NULL;
+static utils_mutex_t provider_default_mtx;
+static UTIL_ONCE_FLAG mem_provider_ctl_initialized = UTIL_ONCE_FLAG_INIT;
+
+static void provider_ctl_init(void) { utils_mutex_init(&provider_default_mtx); }
+
+static umf_result_t CTL_SUBTREE_HANDLER(default)(
+    void *ctx, umf_ctl_query_source_t source, void *arg, size_t size,
+    umf_ctl_index_utlist_t *indexes, const char *extra_name,
+    umf_ctl_query_type_t queryType, va_list args) {
+    (void)ctx;
+    (void)indexes;
+    (void)args;
+    utils_init_once(&mem_provider_ctl_initialized, provider_ctl_init);
+    return ctl_default_subtree(&provider_default_list, &provider_default_mtx,
+                               source, arg, size, extra_name, queryType);
+}
+
+umf_ctl_node_t CTL_NODE(provider)[] = {CTL_CHILD_WITH_ARG(by_handle),
+                                       CTL_LEAF_SUBTREE(default), CTL_NODE_END};
+
 static umf_result_t umfDefaultPurgeLazy(void *provider, void *ptr,
                                         size_t size) {
     (void)provider;
@@ -105,79 +141,196 @@ static umf_result_t umfDefaultCloseIPCHandle(void *provider, void *ptr,
     return UMF_RESULT_ERROR_NOT_SUPPORTED;
 }
 
+static umf_result_t
+umfDefaultCtlHandle(void *provider, umf_ctl_query_source_t operationType,
+                    const char *name, void *arg, size_t size,
+                    umf_ctl_query_type_t queryType, va_list args) {
+    (void)provider;
+    (void)operationType;
+    (void)name;
+    (void)arg;
+    (void)size;
+    (void)queryType;
+    (void)args;
+    // if given path is not supported implementation should return UMF_RESULT_ERROR_INVALID_CTL_PATH
+    return UMF_RESULT_ERROR_INVALID_CTL_PATH;
+}
+
+static umf_result_t
+umfDefaultGetAllocationProperties(void *provider, const void *ptr,
+                                  umf_memory_property_id_t propertyId,
+                                  void *propertyValue) {
+    (void)provider;
+    (void)ptr;
+    (void)propertyId;
+    (void)propertyValue;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+static umf_result_t umfDefaultGetAllocationPropertiesSize(
+    void *provider, umf_memory_property_id_t propertyId, size_t *size) {
+    (void)provider;
+    (void)propertyId;
+    (void)size;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
 void assignOpsExtDefaults(umf_memory_provider_ops_t *ops) {
-    if (!ops->ext.free) {
-        ops->ext.free = umfDefaultFree;
+    if (!ops->ext_purge_lazy) {
+        ops->ext_purge_lazy = umfDefaultPurgeLazy;
     }
-    if (!ops->ext.purge_lazy) {
-        ops->ext.purge_lazy = umfDefaultPurgeLazy;
+
+    if (!ops->ext_purge_force) {
+        ops->ext_purge_force = umfDefaultPurgeForce;
     }
-    if (!ops->ext.purge_force) {
-        ops->ext.purge_force = umfDefaultPurgeForce;
+
+    if (!ops->ext_allocation_split) {
+        ops->ext_allocation_split = umfDefaultAllocationSplit;
     }
-    if (!ops->ext.allocation_split) {
-        ops->ext.allocation_split = umfDefaultAllocationSplit;
+
+    if (!ops->ext_allocation_merge) {
+        ops->ext_allocation_merge = umfDefaultAllocationMerge;
     }
-    if (!ops->ext.allocation_merge) {
-        ops->ext.allocation_merge = umfDefaultAllocationMerge;
+
+    if (!ops->ext_ctl) {
+        ops->ext_ctl = umfDefaultCtlHandle;
+    }
+
+    if (!ops->ext_get_allocation_properties) {
+        ops->ext_get_allocation_properties = umfDefaultGetAllocationProperties;
+    }
+
+    if (!ops->ext_get_allocation_properties_size) {
+        ops->ext_get_allocation_properties_size =
+            umfDefaultGetAllocationPropertiesSize;
     }
 }
 
 void assignOpsIpcDefaults(umf_memory_provider_ops_t *ops) {
-    if (!ops->ipc.get_ipc_handle_size) {
-        ops->ipc.get_ipc_handle_size = umfDefaultGetIPCHandleSize;
+    if (!ops->ext_get_ipc_handle_size) {
+        ops->ext_get_ipc_handle_size = umfDefaultGetIPCHandleSize;
     }
-    if (!ops->ipc.get_ipc_handle) {
-        ops->ipc.get_ipc_handle = umfDefaultGetIPCHandle;
+
+    if (!ops->ext_get_ipc_handle) {
+        ops->ext_get_ipc_handle = umfDefaultGetIPCHandle;
     }
-    if (!ops->ipc.put_ipc_handle) {
-        ops->ipc.put_ipc_handle = umfDefaultPutIPCHandle;
+
+    if (!ops->ext_put_ipc_handle) {
+        ops->ext_put_ipc_handle = umfDefaultPutIPCHandle;
     }
-    if (!ops->ipc.open_ipc_handle) {
-        ops->ipc.open_ipc_handle = umfDefaultOpenIPCHandle;
+
+    if (!ops->ext_open_ipc_handle) {
+        ops->ext_open_ipc_handle = umfDefaultOpenIPCHandle;
     }
-    if (!ops->ipc.close_ipc_handle) {
-        ops->ipc.close_ipc_handle = umfDefaultCloseIPCHandle;
+
+    if (!ops->ext_close_ipc_handle) {
+        ops->ext_close_ipc_handle = umfDefaultCloseIPCHandle;
     }
 }
 
-static bool validateOpsMandatory(const umf_memory_provider_ops_t *ops) {
-    // Mandatory ops should be non-NULL
-    return ops->alloc && ops->get_recommended_page_size &&
-           ops->get_min_page_size && ops->initialize && ops->finalize &&
-           ops->get_last_native_error && ops->get_name;
-}
+static umf_result_t umfProviderPostInitialize(umf_memory_provider_ops_t *ops,
+                                              void *provider_priv, ...) {
 
-static bool validateOpsExt(const umf_memory_provider_ext_ops_t *ext) {
-    // split and merge functions should be both NULL or both non-NULL
-    return (ext->allocation_split && ext->allocation_merge) ||
-           (!ext->allocation_split && !ext->allocation_merge);
-}
+    // "post_initialize" ctl query is supported since version 1.1
+    if (ops->version < UMF_MAKE_VERSION(1, 1)) {
+        LOG_DEBUG(
+            "\"post_initialize\" ctl query was not required for memory "
+            "provider version %d, but the implementation could not handle "
+            "errors properly in this case",
+            ops->version);
+        return UMF_RESULT_ERROR_INVALID_CTL_PATH;
+    }
+
+    va_list args;
+    va_start(args, provider_priv);
+    umf_result_t ret =
+        ops->ext_ctl(provider_priv, CTL_QUERY_PROGRAMMATIC, "post_initialize",
+                     NULL, 0, CTL_QUERY_RUNNABLE, args);
+    va_end(args);
 
-static bool validateOpsIpc(const umf_memory_provider_ipc_ops_t *ipc) {
-    // valid if all ops->ipc.* are non-NULL or all are NULL
-    return (ipc->get_ipc_handle_size && ipc->get_ipc_handle &&
-            ipc->put_ipc_handle && ipc->open_ipc_handle &&
-            ipc->close_ipc_handle) ||
-           (!ipc->get_ipc_handle_size && !ipc->get_ipc_handle &&
-            !ipc->put_ipc_handle && !ipc->open_ipc_handle &&
-            !ipc->close_ipc_handle);
+    return ret;
 }
 
+#define CHECK_OP(ops, fn)                                                      \
+    if (!(ops)->fn) {                                                          \
+        LOG_ERR("missing function pointer: %s\n", #fn);                        \
+        return false;                                                          \
+    }
+
 static bool validateOps(const umf_memory_provider_ops_t *ops) {
-    return validateOpsMandatory(ops) && validateOpsExt(&(ops->ext)) &&
-           validateOpsIpc(&(ops->ipc));
-}
+    // Validate mandatory operations one by one
+    CHECK_OP(ops, alloc);
+    CHECK_OP(ops, free);
+    CHECK_OP(ops, get_recommended_page_size);
+    CHECK_OP(ops, get_min_page_size);
+    CHECK_OP(ops, initialize);
+    CHECK_OP(ops, finalize);
+    CHECK_OP(ops, get_last_native_error);
+    CHECK_OP(ops, get_name);
+
+    if ((ops->ext_allocation_split == NULL) !=
+        (ops->ext_allocation_merge == NULL)) {
+        LOG_ERR("ext_allocation_split and ext_allocation_merge must be "
+                "both set or both NULL\n");
+        return false;
+    }
 
-bool umfIsFreeOpDefault(umf_memory_provider_handle_t hProvider) {
-    return (hProvider->ops.ext.free == umfDefaultFree);
+    bool ipcAllSet = ops->ext_get_ipc_handle_size && ops->ext_get_ipc_handle &&
+                     ops->ext_put_ipc_handle && ops->ext_open_ipc_handle &&
+                     ops->ext_close_ipc_handle;
+    bool ipcAllNull = !ops->ext_get_ipc_handle_size &&
+                      !ops->ext_get_ipc_handle && !ops->ext_put_ipc_handle &&
+                      !ops->ext_open_ipc_handle && !ops->ext_close_ipc_handle;
+    if (!ipcAllSet && !ipcAllNull) {
+        LOG_ERR("IPC function pointers must be either all set or all "
+                "NULL\n");
+        return false;
+    }
+
+    if ((ops->ext_get_allocation_properties == NULL) !=
+        (ops->ext_get_allocation_properties_size == NULL)) {
+        LOG_ERR("ext_get_allocation_properties and "
+                "ext_get_allocation_properties_size must be "
+                "both set or both NULL\n");
+        return false;
+    }
+
+    return true;
 }
 
 umf_result_t umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops,
-                                     void *params,
+                                     const void *params,
                                      umf_memory_provider_handle_t *hProvider) {
     libumfInit();
-    if (!ops || !hProvider || !validateOps(ops)) {
+    if (!ops || !hProvider) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_memory_provider_ops_t compatible_ops;
+    if (ops->version != UMF_PROVIDER_OPS_VERSION_CURRENT) {
+        LOG_WARN("Memory Provider ops version \"%d\" is different than the "
+                 "current version \"%d\"",
+                 ops->version, UMF_PROVIDER_OPS_VERSION_CURRENT);
+
+        // Create a new ops compatible structure with the current version
+        memset(&compatible_ops, 0, sizeof(compatible_ops));
+
+        if (UMF_MINOR_VERSION(ops->version) == 0) {
+            LOG_INFO("Detected 1.0 version of Memory Provider ops, "
+                     "upgrading to current version");
+            memcpy(&compatible_ops, ops,
+                   offsetof(umf_memory_provider_ops_t,
+                            ext_get_allocation_properties));
+        } else {
+            LOG_ERR("Unsupported Memory Provider ops version: %d",
+                    ops->version);
+            return UMF_RESULT_ERROR_NOT_SUPPORTED;
+        }
+
+        ops = &compatible_ops;
+    }
+
+    if (!validateOps(ops)) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
@@ -187,8 +340,6 @@ umf_result_t umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops,
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    assert(ops->version == UMF_VERSION_CURRENT);
-
     provider->ops = *ops;
 
     assignOpsExtDefaults(&(provider->ops));
@@ -203,16 +354,46 @@ umf_result_t umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops,
 
     provider->provider_priv = provider_priv;
 
+    utils_init_once(&mem_provider_ctl_initialized, provider_ctl_init);
+    const char *pname = NULL;
+
+    ret = provider->ops.get_name(provider->provider_priv, &pname);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Failed to get pool name");
+        umf_ba_global_free(provider);
+        return ret;
+    }
+
+    assert(pname != NULL);
+    utils_warn_invalid_name("Memory provider", pname);
+
+    ctl_default_apply(provider_default_list, pname, provider->ops.ext_ctl,
+                      provider->provider_priv);
+
+    ret = umfProviderPostInitialize(&provider->ops, provider_priv);
+    if (ret != UMF_RESULT_SUCCESS && ret != UMF_RESULT_ERROR_INVALID_CTL_PATH) {
+        LOG_ERR("Failed to post-initialize provider");
+        umf_ba_global_free(provider);
+        return ret;
+    }
+
     *hProvider = provider;
 
     return UMF_RESULT_SUCCESS;
 }
 
-void umfMemoryProviderDestroy(umf_memory_provider_handle_t hProvider) {
-    if (hProvider) {
-        hProvider->ops.finalize(hProvider->provider_priv);
-        umf_ba_global_free(hProvider);
+umf_result_t umfMemoryProviderDestroy(umf_memory_provider_handle_t hProvider) {
+    if (umf_ba_global_is_destroyed()) {
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    if (!hProvider) {
+        return UMF_RESULT_SUCCESS;
     }
+
+    umf_result_t ret = hProvider->ops.finalize(hProvider->provider_priv);
+    umf_ba_global_free(hProvider);
+    return ret;
 }
 
 static void
@@ -227,8 +408,10 @@ umf_result_t umfMemoryProviderAlloc(umf_memory_provider_handle_t hProvider,
                                     size_t size, size_t alignment, void **ptr) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
     umf_result_t res =
         hProvider->ops.alloc(hProvider->provider_priv, size, alignment, ptr);
+
     checkErrorAndSetLastProvider(res, hProvider);
     return res;
 }
@@ -236,22 +419,27 @@ umf_result_t umfMemoryProviderAlloc(umf_memory_provider_handle_t hProvider,
 umf_result_t umfMemoryProviderFree(umf_memory_provider_handle_t hProvider,
                                    void *ptr, size_t size) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
-    umf_result_t res =
-        hProvider->ops.ext.free(hProvider->provider_priv, ptr, size);
+
+    umf_result_t res = hProvider->ops.free(hProvider->provider_priv, ptr, size);
+
     checkErrorAndSetLastProvider(res, hProvider);
     return res;
 }
 
-void umfMemoryProviderGetLastNativeError(umf_memory_provider_handle_t hProvider,
-                                         const char **ppMessage,
-                                         int32_t *pError) {
-    ASSERT(hProvider != NULL);
-    hProvider->ops.get_last_native_error(hProvider->provider_priv, ppMessage,
-                                         pError);
+umf_result_t
+umfMemoryProviderGetLastNativeError(umf_memory_provider_handle_t hProvider,
+                                    const char **ppMessage, int32_t *pError) {
+    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((ppMessage != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((pError != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    return hProvider->ops.get_last_native_error(hProvider->provider_priv,
+                                                ppMessage, pError);
 }
 
 void *umfMemoryProviderGetPriv(umf_memory_provider_handle_t hProvider) {
     UMF_CHECK((hProvider != NULL), NULL);
+
     return hProvider->provider_priv;
 }
 
@@ -260,34 +448,47 @@ umfMemoryProviderGetRecommendedPageSize(umf_memory_provider_handle_t hProvider,
                                         size_t size, size_t *pageSize) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     UMF_CHECK((pageSize != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
     umf_result_t res = hProvider->ops.get_recommended_page_size(
         hProvider->provider_priv, size, pageSize);
+
     checkErrorAndSetLastProvider(res, hProvider);
     return res;
 }
 
 umf_result_t
 umfMemoryProviderGetMinPageSize(umf_memory_provider_handle_t hProvider,
-                                void *ptr, size_t *pageSize) {
+                                const void *ptr, size_t *pageSize) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     UMF_CHECK((pageSize != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
     umf_result_t res = hProvider->ops.get_min_page_size(
         hProvider->provider_priv, ptr, pageSize);
+
     checkErrorAndSetLastProvider(res, hProvider);
     return res;
 }
 
-const char *umfMemoryProviderGetName(umf_memory_provider_handle_t hProvider) {
-    UMF_CHECK((hProvider != NULL), NULL);
-    return hProvider->ops.get_name(hProvider->provider_priv);
+umf_result_t umfMemoryProviderGetName(umf_memory_provider_handle_t hProvider,
+                                      const char **name) {
+    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((name != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result_t res = hProvider->ops.get_name(hProvider->provider_priv, name);
+
+    checkErrorAndSetLastProvider(res, hProvider);
+    return res;
 }
 
 umf_result_t umfMemoryProviderPurgeLazy(umf_memory_provider_handle_t hProvider,
                                         void *ptr, size_t size) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ASSERT(hProvider->ops.ext_purge_lazy);
     umf_result_t res =
-        hProvider->ops.ext.purge_lazy(hProvider->provider_priv, ptr, size);
+        hProvider->ops.ext_purge_lazy(hProvider->provider_priv, ptr, size);
+
     checkErrorAndSetLastProvider(res, hProvider);
     return res;
 }
@@ -296,14 +497,21 @@ umf_result_t umfMemoryProviderPurgeForce(umf_memory_provider_handle_t hProvider,
                                          void *ptr, size_t size) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ASSERT(hProvider->ops.ext_purge_force);
     umf_result_t res =
-        hProvider->ops.ext.purge_force(hProvider->provider_priv, ptr, size);
+        hProvider->ops.ext_purge_force(hProvider->provider_priv, ptr, size);
+
     checkErrorAndSetLastProvider(res, hProvider);
     return res;
 }
 
-umf_memory_provider_handle_t umfGetLastFailedMemoryProvider(void) {
-    return *umfGetLastFailedMemoryProviderPtr();
+umf_result_t
+umfGetLastFailedMemoryProvider(umf_memory_provider_handle_t *provider) {
+    UMF_CHECK((provider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    *provider = *umfGetLastFailedMemoryProviderPtr();
+    return UMF_RESULT_SUCCESS;
 }
 
 umf_result_t
@@ -316,8 +524,10 @@ umfMemoryProviderAllocationSplit(umf_memory_provider_handle_t hProvider,
               UMF_RESULT_ERROR_INVALID_ARGUMENT);
     UMF_CHECK((firstSize < totalSize), UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
-    umf_result_t res = hProvider->ops.ext.allocation_split(
+    ASSERT(hProvider->ops.ext_allocation_split);
+    umf_result_t res = hProvider->ops.ext_allocation_split(
         hProvider->provider_priv, ptr, totalSize, firstSize);
+
     checkErrorAndSetLastProvider(res, hProvider);
     return res;
 }
@@ -334,8 +544,10 @@ umfMemoryProviderAllocationMerge(umf_memory_provider_handle_t hProvider,
     UMF_CHECK(((uintptr_t)highPtr - (uintptr_t)lowPtr < totalSize),
               UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
-    umf_result_t res = hProvider->ops.ext.allocation_merge(
+    ASSERT(hProvider->ops.ext_allocation_merge);
+    umf_result_t res = hProvider->ops.ext_allocation_merge(
         hProvider->provider_priv, lowPtr, highPtr, totalSize);
+
     checkErrorAndSetLastProvider(res, hProvider);
     return res;
 }
@@ -345,8 +557,13 @@ umfMemoryProviderGetIPCHandleSize(umf_memory_provider_handle_t hProvider,
                                   size_t *size) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     UMF_CHECK((size != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
-    return hProvider->ops.ipc.get_ipc_handle_size(hProvider->provider_priv,
-                                                  size);
+
+    ASSERT(hProvider->ops.ext_get_ipc_handle_size);
+    umf_result_t res =
+        hProvider->ops.ext_get_ipc_handle_size(hProvider->provider_priv, size);
+
+    checkErrorAndSetLastProvider(res, hProvider);
+    return res;
 }
 
 umf_result_t
@@ -355,9 +572,15 @@ umfMemoryProviderGetIPCHandle(umf_memory_provider_handle_t hProvider,
                               void *providerIpcData) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((size != 0), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     UMF_CHECK((providerIpcData != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
-    return hProvider->ops.ipc.get_ipc_handle(hProvider->provider_priv, ptr,
-                                             size, providerIpcData);
+
+    ASSERT(hProvider->ops.ext_get_ipc_handle);
+    umf_result_t res = hProvider->ops.ext_get_ipc_handle(
+        hProvider->provider_priv, ptr, size, providerIpcData);
+
+    checkErrorAndSetLastProvider(res, hProvider);
+    return res;
 }
 
 umf_result_t
@@ -365,8 +588,13 @@ umfMemoryProviderPutIPCHandle(umf_memory_provider_handle_t hProvider,
                               void *providerIpcData) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     UMF_CHECK((providerIpcData != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
-    return hProvider->ops.ipc.put_ipc_handle(hProvider->provider_priv,
-                                             providerIpcData);
+
+    ASSERT(hProvider->ops.ext_put_ipc_handle);
+    umf_result_t res = hProvider->ops.ext_put_ipc_handle(
+        hProvider->provider_priv, providerIpcData);
+
+    checkErrorAndSetLastProvider(res, hProvider);
+    return res;
 }
 
 umf_result_t
@@ -375,8 +603,13 @@ umfMemoryProviderOpenIPCHandle(umf_memory_provider_handle_t hProvider,
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     UMF_CHECK((providerIpcData != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
-    return hProvider->ops.ipc.open_ipc_handle(hProvider->provider_priv,
-                                              providerIpcData, ptr);
+
+    ASSERT(hProvider->ops.ext_open_ipc_handle);
+    umf_result_t res = hProvider->ops.ext_open_ipc_handle(
+        hProvider->provider_priv, providerIpcData, ptr);
+
+    checkErrorAndSetLastProvider(res, hProvider);
+    return res;
 }
 
 umf_result_t
@@ -384,6 +617,57 @@ umfMemoryProviderCloseIPCHandle(umf_memory_provider_handle_t hProvider,
                                 void *ptr, size_t size) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
-    return hProvider->ops.ipc.close_ipc_handle(hProvider->provider_priv, ptr,
-                                               size);
+    UMF_CHECK((size != 0), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ASSERT(hProvider->ops.ext_close_ipc_handle);
+    umf_result_t res = hProvider->ops.ext_close_ipc_handle(
+        hProvider->provider_priv, ptr, size);
+
+    checkErrorAndSetLastProvider(res, hProvider);
+    return res;
+}
+
+umf_result_t umfMemoryProviderGetAllocationProperties(
+    umf_memory_provider_handle_t hProvider, const void *ptr,
+    umf_memory_property_id_t propertyId, void *property_value) {
+
+    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((property_value != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((propertyId != UMF_MEMORY_PROPERTY_INVALID),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // NOTE: we do not check if the propertyId is below
+    // UMF_MEMORY_PROPERTY_MAX_RESERVED value, as the user could use a custom
+    // property ID that is above the reserved range
+
+    umf_result_t res = hProvider->ops.ext_get_allocation_properties(
+        hProvider->provider_priv, ptr, propertyId, property_value);
+
+    checkErrorAndSetLastProvider(res, hProvider);
+    return res;
+}
+
+umf_result_t umfMemoryProviderGetAllocationPropertiesSize(
+    umf_memory_provider_handle_t hProvider, umf_memory_property_id_t propertyId,
+    size_t *size) {
+
+    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((size != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((propertyId != UMF_MEMORY_PROPERTY_INVALID),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // NOTE: we do not check if the propertyId is below
+    // UMF_MEMORY_PROPERTY_MAX_RESERVED value, as the user could use a custom
+    // property ID that is above the reserved range
+
+    umf_result_t res = hProvider->ops.ext_get_allocation_properties_size(
+        hProvider->provider_priv, propertyId, size);
+
+    checkErrorAndSetLastProvider(res, hProvider);
+    return res;
+}
+
+void umfProviderCtlDefaultsDestroy(void) {
+    utils_init_once(&mem_provider_ctl_initialized, provider_ctl_init);
+    ctl_default_destroy(&provider_default_list, &provider_default_mtx);
 }
diff --git a/src/memory_provider_get_last_failed.c b/src/memory_provider_get_last_failed.c
index 9434eea976..09bd075e10 100644
--- a/src/memory_provider_get_last_failed.c
+++ b/src/memory_provider_get_last_failed.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 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
diff --git a/src/memory_provider_internal.h b/src/memory_provider_internal.h
index 49b2f2e531..b486377acd 100644
--- a/src/memory_provider_internal.h
+++ b/src/memory_provider_internal.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 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
@@ -14,13 +14,23 @@
 
 #include <umf/memory_provider.h>
 
+#include "ctl/ctl_internal.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+typedef struct umf_memory_provider_t {
+    void *provider_priv;
+    // ops should be the last due to possible change size in the future
+    umf_memory_provider_ops_t ops;
+} umf_memory_provider_t;
+
 void *umfMemoryProviderGetPriv(umf_memory_provider_handle_t hProvider);
 umf_memory_provider_handle_t *umfGetLastFailedMemoryProviderPtr(void);
-bool umfIsFreeOpDefault(umf_memory_provider_handle_t hProvider);
+void umfProviderCtlDefaultsDestroy(void);
+
+extern umf_ctl_node_t CTL_NODE(provider)[];
 
 #ifdef __cplusplus
 }
diff --git a/src/mempolicy.c b/src/mempolicy.c
index 1b78053b25..240f767b05 100644
--- a/src/mempolicy.c
+++ b/src/mempolicy.c
@@ -1,12 +1,12 @@
 /*
  *
- * 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
  *
  */
-#include <umf/mempolicy.h>
+#include <umf/experimental/mempolicy.h>
 
 #include "base_alloc_global.h"
 #include "mempolicy_internal.h"
diff --git a/src/mempolicy_internal.h b/src/mempolicy_internal.h
index 57acaf02d0..58c0fbc79b 100644
--- a/src/mempolicy_internal.h
+++ b/src/mempolicy_internal.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -10,7 +10,7 @@
 #ifndef UMF_MEMPOLICY_INTERNAL_H
 #define UMF_MEMPOLICY_INTERNAL_H 1
 
-#include <umf/mempolicy.h>
+#include <umf/experimental/mempolicy.h>
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/src/memspace.c b/src/memspace.c
index 1cd80e1fac..d473dda9c6 100644
--- a/src/memspace.c
+++ b/src/memspace.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -10,7 +10,7 @@
 #include <assert.h>
 #include <stdlib.h>
 
-#include <umf/memspace.h>
+#include <umf/experimental/memspace.h>
 
 #include "base_alloc_global.h"
 #include "memspace_internal.h"
@@ -130,7 +130,7 @@ umf_result_t umfMemspaceNew(umf_memspace_handle_t *hMemspace) {
     return UMF_RESULT_SUCCESS;
 }
 
-void umfMemspaceDestroy(umf_memspace_handle_t memspace) {
+umf_result_t umfMemspaceDestroy(umf_memspace_handle_t memspace) {
     assert(memspace);
     for (size_t i = 0; i < memspace->size; i++) {
         umfMemtargetDestroy(memspace->nodes[i]);
@@ -138,6 +138,7 @@ void umfMemspaceDestroy(umf_memspace_handle_t memspace) {
 
     umf_ba_global_free(memspace->nodes);
     umf_ba_global_free(memspace);
+    return UMF_RESULT_SUCCESS;
 }
 
 umf_result_t umfMemspaceClone(umf_const_memspace_handle_t hMemspace,
@@ -203,9 +204,8 @@ static int propertyCmp(const void *a, const void *b) {
 
 umf_result_t umfMemspaceSortDesc(umf_memspace_handle_t hMemspace,
                                  umfGetPropertyFn getProperty) {
-    if (!hMemspace || !getProperty) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    assert(hMemspace);
+    assert(getProperty);
 
     struct memtarget_sort_entry *entries = umf_ba_global_alloc(
         sizeof(struct memtarget_sort_entry) * hMemspace->size);
@@ -240,9 +240,8 @@ umf_result_t umfMemspaceSortDesc(umf_memspace_handle_t hMemspace,
 umf_result_t umfMemspaceFilter(umf_const_memspace_handle_t hMemspace,
                                umfGetTargetFn getTarget,
                                umf_memspace_handle_t *filteredMemspace) {
-    if (!hMemspace || !getTarget) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    assert(hMemspace);
+    assert(getTarget);
 
     umf_memtarget_handle_t *uniqueBestNodes =
         umf_ba_global_alloc(hMemspace->size * sizeof(*uniqueBestNodes));
@@ -388,6 +387,7 @@ umfMemspaceMemtargetRemove(umf_memspace_handle_t hMemspace,
     if (!hMemspace || !hMemtarget) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
+
     unsigned i;
     for (i = 0; i < hMemspace->size; i++) {
         int cmp;
@@ -408,10 +408,16 @@ umfMemspaceMemtargetRemove(umf_memspace_handle_t hMemspace,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    umf_memtarget_handle_t *newNodes =
-        umf_ba_global_alloc(sizeof(*newNodes) * (hMemspace->size - 1));
-    if (!newNodes) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    umf_memtarget_handle_t *newNodes = NULL;
+
+    if (hMemspace->size == 1) {
+        LOG_DEBUG("Removing the last memory target from the memspace.");
+    } else {
+        newNodes =
+            umf_ba_global_alloc(sizeof(*newNodes) * (hMemspace->size - 1));
+        if (!newNodes) {
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        }
     }
 
     for (unsigned j = 0, z = 0; j < hMemspace->size; j++) {
@@ -432,10 +438,8 @@ umfMemspaceMemtargetRemove(umf_memspace_handle_t hMemspace,
 static int umfMemspaceFilterHelper(umf_memspace_handle_t memspace,
                                    umf_memspace_filter_func_t filter,
                                    void *args) {
-
-    if (!memspace || !filter) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    assert(memspace);
+    assert(filter);
 
     size_t idx = 0;
     int ret;
diff --git a/src/memspace_internal.h b/src/memspace_internal.h
index e31898e84e..4721470c83 100644
--- a/src/memspace_internal.h
+++ b/src/memspace_internal.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -10,7 +10,7 @@
 #ifndef UMF_MEMSPACE_INTERNAL_H
 #define UMF_MEMSPACE_INTERNAL_H 1
 
-#include <umf/memspace.h>
+#include <umf/experimental/memspace.h>
 
 #include "base_alloc.h"
 #include "memtarget_internal.h"
diff --git a/src/memspaces/memspace_highest_bandwidth.c b/src/memspaces/memspace_highest_bandwidth.c
index 93fede2cd4..7bdc6f9382 100644
--- a/src/memspaces/memspace_highest_bandwidth.c
+++ b/src/memspaces/memspace_highest_bandwidth.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -12,18 +12,17 @@
 #include <stdlib.h>
 
 #include <umf.h>
-#include <umf/memspace.h>
+#include <umf/experimental/memspace.h>
 
-// UMF_MEMSPACE_HIGHEST_BANDWIDTH requires HWLOC
-// Additionally, it is currently unsupported on Win
-#if defined(_WIN32) || defined(UMF_NO_HWLOC)
+// UMF_MEMSPACE_HIGHEST_BANDWIDTH is currently unsupported on Win
+#if defined(_WIN32)
 
 umf_const_memspace_handle_t umfMemspaceHighestBandwidthGet(void) {
     // not supported
     return NULL;
 }
 
-#else // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+#else // !defined(_WIN32)
 
 #include "base_alloc_global.h"
 #include "memspace_internal.h"
@@ -102,10 +101,14 @@ static void umfMemspaceHighestBandwidthInit(void) {
     umf_result_t ret =
         umfMemspaceHighestBandwidthCreate(&UMF_MEMSPACE_HIGHEST_BANDWIDTH);
     if (ret != UMF_RESULT_SUCCESS) {
-        LOG_ERR(
+        LOG_DEBUG(
             "Creating the highest bandwidth memspace failed with the error: %u",
             ret);
-        assert(ret == UMF_RESULT_ERROR_NOT_SUPPORTED);
+        if (ret != UMF_RESULT_ERROR_NOT_SUPPORTED) {
+            LOG_FATAL("Unknown error, expected "
+                      "'UMF_RESULT_ERROR_NOT_SUPPORTED', got: %u",
+                      ret);
+        }
     }
 }
 
@@ -115,4 +118,4 @@ umf_const_memspace_handle_t umfMemspaceHighestBandwidthGet(void) {
     return UMF_MEMSPACE_HIGHEST_BANDWIDTH;
 }
 
-#endif // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+#endif // !defined(_WIN32)
diff --git a/src/memspaces/memspace_highest_capacity.c b/src/memspaces/memspace_highest_capacity.c
index 4a195316af..31d4ced518 100644
--- a/src/memspaces/memspace_highest_capacity.c
+++ b/src/memspaces/memspace_highest_capacity.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -11,18 +11,17 @@
 #include <stdlib.h>
 
 #include <umf.h>
-#include <umf/memspace.h>
+#include <umf/experimental/memspace.h>
 
-// UMF_MEMSPACE_HIGHEST_CAPACITY requires HWLOC
-// Additionally, it is currently unsupported on Win
-#if defined(_WIN32) || defined(UMF_NO_HWLOC)
+// UMF_MEMSPACE_HIGHEST_CAPACITY is currently unsupported on Win
+#if defined(_WIN32)
 
 umf_const_memspace_handle_t umfMemspaceHighestCapacityGet(void) {
     // not supported
     return NULL;
 }
 
-#else // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+#else // !defined(_WIN32)
 
 #include "base_alloc_global.h"
 #include "memspace_internal.h"
@@ -87,4 +86,4 @@ umf_const_memspace_handle_t umfMemspaceHighestCapacityGet(void) {
     return UMF_MEMSPACE_HIGHEST_CAPACITY;
 }
 
-#endif // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+#endif // !defined(_WIN32)
diff --git a/src/memspaces/memspace_host_all.c b/src/memspaces/memspace_host_all.c
index 4b7db69d4b..5ff9e8edd1 100644
--- a/src/memspaces/memspace_host_all.c
+++ b/src/memspaces/memspace_host_all.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -11,18 +11,16 @@
 #include <stdlib.h>
 
 #include <umf.h>
-#include <umf/memspace.h>
+#include <umf/experimental/memspace.h>
 
-// UMF_MEMSPACE_HOST_ALL requires HWLOC
-// Additionally, it is currently unsupported on Win
-
-#if defined(_WIN32) || defined(UMF_NO_HWLOC)
+// UMF_MEMSPACE_HOST_ALL is currently unsupported on Win
+#if defined(_WIN32)
 umf_const_memspace_handle_t umfMemspaceHostAllGet(void) {
     // not supported
     return NULL;
 }
 
-#else // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+#else // !defined(_WIN32)
 
 #include "base_alloc_global.h"
 #include "memspace_internal.h"
@@ -37,7 +35,7 @@ static umf_result_t umfMemspaceHostAllCreate(umf_memspace_handle_t *hMemspace) {
 
     umf_result_t umf_ret = UMF_RESULT_SUCCESS;
 
-    hwloc_topology_t topology = umfGetTopology();
+    hwloc_topology_t topology = umfGetTopologyReduced();
     if (!topology) {
         // TODO: What would be an approrpiate err?
         return UMF_RESULT_ERROR_UNKNOWN;
@@ -108,4 +106,4 @@ umf_const_memspace_handle_t umfMemspaceHostAllGet(void) {
     return UMF_MEMSPACE_HOST_ALL;
 }
 
-#endif // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+#endif // !defined(_WIN32)
diff --git a/src/memspaces/memspace_lowest_latency.c b/src/memspaces/memspace_lowest_latency.c
index 5ca369fee3..6e1780f2a3 100644
--- a/src/memspaces/memspace_lowest_latency.c
+++ b/src/memspaces/memspace_lowest_latency.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -12,18 +12,17 @@
 #include <stdlib.h>
 
 #include <umf.h>
-#include <umf/memspace.h>
+#include <umf/experimental/memspace.h>
 
-// UMF_MEMSPACE_LOWEST_LATENCY requires HWLOC
-// Additionally, it is currently unsupported on Win
-#if defined(_WIN32) || defined(UMF_NO_HWLOC)
+// UMF_MEMSPACE_LOWEST_LATENCY is currently unsupported on Win
+#if defined(_WIN32)
 
 umf_const_memspace_handle_t umfMemspaceLowestLatencyGet(void) {
     // not supported
     return NULL;
 }
 
-#else // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+#else // !defined(_WIN32)
 
 #include "base_alloc_global.h"
 #include "memspace_internal.h"
@@ -98,10 +97,14 @@ static void umfMemspaceLowestLatencyInit(void) {
     umf_result_t ret =
         umfMemspaceLowestLatencyCreate(&UMF_MEMSPACE_LOWEST_LATENCY);
     if (ret != UMF_RESULT_SUCCESS) {
-        LOG_ERR(
+        LOG_DEBUG(
             "Creating the lowest latency memspace failed with the error: %u",
             ret);
-        assert(ret == UMF_RESULT_ERROR_NOT_SUPPORTED);
+        if (ret != UMF_RESULT_ERROR_NOT_SUPPORTED) {
+            LOG_FATAL("Unknown error, expected "
+                      "'UMF_RESULT_ERROR_NOT_SUPPORTED', got: %u",
+                      ret);
+        }
     }
 
 #if defined(_WIN32) && !defined(UMF_SHARED_LIBRARY)
@@ -115,4 +118,4 @@ umf_const_memspace_handle_t umfMemspaceLowestLatencyGet(void) {
     return UMF_MEMSPACE_LOWEST_LATENCY;
 }
 
-#endif // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+#endif // !defined(_WIN32)
diff --git a/src/memspaces/memspace_numa.c b/src/memspaces/memspace_numa.c
index 0028e394dc..421d50fafa 100644
--- a/src/memspaces/memspace_numa.c
+++ b/src/memspaces/memspace_numa.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 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
@@ -10,11 +10,10 @@
 #include <stdlib.h>
 
 #include <umf.h>
-#include <umf/memspace.h>
+#include <umf/experimental/memspace.h>
 
-// umfMemspaceCreateFromNumaArray requires HWLOC
-// Additionally, it is currently unsupported on Win
-#if defined(_WIN32) || defined(UMF_NO_HWLOC)
+// umfMemspaceCreateFromNumaArray is currently unsupported on Win
+#if defined(_WIN32)
 umf_result_t umfMemspaceCreateFromNumaArray(unsigned *nodeIds, size_t numIds,
                                             umf_memspace_handle_t *hMemspace) {
     (void)nodeIds;
@@ -25,7 +24,7 @@ umf_result_t umfMemspaceCreateFromNumaArray(unsigned *nodeIds, size_t numIds,
     return UMF_RESULT_ERROR_NOT_SUPPORTED;
 }
 
-#else // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+#else // !defined(_WIN32)
 
 #include "../memspace_internal.h"
 #include "../memtargets/memtarget_numa.h"
@@ -76,4 +75,4 @@ umf_result_t umfMemspaceCreateFromNumaArray(unsigned *nodeIds, size_t numIds,
     return ret;
 }
 
-#endif // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+#endif // !defined(_WIN32)
diff --git a/src/memtarget.c b/src/memtarget.c
index a897084608..b0fa316cb2 100644
--- a/src/memtarget.c
+++ b/src/memtarget.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -15,13 +15,13 @@
 #include "memtarget_internal.h"
 #include "memtarget_ops.h"
 #include "utils_concurrency.h"
+#include "utils_log.h"
 
 umf_result_t umfMemtargetCreate(const umf_memtarget_ops_t *ops, void *params,
                                 umf_memtarget_handle_t *memoryTarget) {
     libumfInit();
-    if (!ops || !memoryTarget) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    assert(ops);
+    assert(memoryTarget);
 
     umf_memtarget_handle_t target =
         umf_ba_global_alloc(sizeof(umf_memtarget_t));
@@ -29,7 +29,11 @@ umf_result_t umfMemtargetCreate(const umf_memtarget_ops_t *ops, void *params,
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    assert(ops->version == UMF_VERSION_CURRENT);
+    if (ops->version != UMF_MEMTARGET_OPS_VERSION_CURRENT) {
+        LOG_WARN("Memtarget ops version \"%d\" is different than the current "
+                 "version \"%d\"",
+                 ops->version, UMF_MEMTARGET_OPS_VERSION_CURRENT);
+    }
 
     target->ops = ops;
 
@@ -88,9 +92,9 @@ umf_result_t umfMemtargetGetCapacity(umf_const_memtarget_handle_t memoryTarget,
 umf_result_t umfMemtargetGetBandwidth(umf_memtarget_handle_t srcMemoryTarget,
                                       umf_memtarget_handle_t dstMemoryTarget,
                                       size_t *bandwidth) {
-    if (!srcMemoryTarget || !dstMemoryTarget || !bandwidth) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    assert(srcMemoryTarget);
+    assert(dstMemoryTarget);
+    assert(bandwidth);
 
     return srcMemoryTarget->ops->get_bandwidth(
         srcMemoryTarget->priv, dstMemoryTarget->priv, bandwidth);
@@ -99,9 +103,9 @@ umf_result_t umfMemtargetGetBandwidth(umf_memtarget_handle_t srcMemoryTarget,
 umf_result_t umfMemtargetGetLatency(umf_memtarget_handle_t srcMemoryTarget,
                                     umf_memtarget_handle_t dstMemoryTarget,
                                     size_t *latency) {
-    if (!srcMemoryTarget || !dstMemoryTarget || !latency) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    assert(srcMemoryTarget);
+    assert(dstMemoryTarget);
+    assert(latency);
 
     return srcMemoryTarget->ops->get_latency(srcMemoryTarget->priv,
                                              dstMemoryTarget->priv, latency);
diff --git a/src/memtarget_internal.h b/src/memtarget_internal.h
index c5b9a61c5c..f2eef4f3d0 100644
--- a/src/memtarget_internal.h
+++ b/src/memtarget_internal.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -11,12 +11,11 @@
 #define UMF_MEMTARGET_INTERNAL_H 1
 
 #include <umf/base.h>
-#include <umf/memtarget.h>
+#include <umf/experimental/memtarget.h>
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-struct umf_memtarget_ops_t;
 typedef struct umf_memtarget_ops_t umf_memtarget_ops_t;
 
 typedef struct umf_memtarget_t {
diff --git a/src/memtarget_ops.h b/src/memtarget_ops.h
index 75e16447e3..1abb473894 100644
--- a/src/memtarget_ops.h
+++ b/src/memtarget_ops.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -11,16 +11,21 @@
 #define UMF_MEMTARGET_OPS_H 1
 
 #include <umf/base.h>
-#include <umf/memspace.h>
-#include <umf/memtarget.h>
+#include <umf/experimental/memspace.h>
+#include <umf/experimental/memtarget.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+// Version of the Memtarget ops structure.
+// NOTE: This is equal to the latest UMF version, in which the ops structure
+// has been modified.
+#define UMF_MEMTARGET_OPS_VERSION_CURRENT UMF_MAKE_VERSION(0, 11)
+
 typedef struct umf_memtarget_ops_t {
     /// Version of the ops structure.
-    /// Should be initialized using UMF_VERSION_CURRENT
+    /// Should be initialized using UMF_MEMTARGET_OPS_VERSION_CURRENT
     uint32_t version;
 
     umf_result_t (*initialize)(void *params, void **memoryTarget);
diff --git a/src/memtargets/memtarget_numa.c b/src/memtargets/memtarget_numa.c
index f32774ebbc..d6431ef9ff 100644
--- a/src/memtargets/memtarget_numa.c
+++ b/src/memtargets/memtarget_numa.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -218,7 +218,7 @@ static umf_result_t numa_get_capacity(void *memTarget, size_t *capacity) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    hwloc_topology_t topology = umfGetTopology();
+    hwloc_topology_t topology = umfGetTopologyReduced();
     if (!topology) {
         return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
@@ -263,17 +263,15 @@ static umf_result_t query_attribute_value(void *srcMemoryTarget,
         return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
 
-    hwloc_obj_t srcNumaNode = hwloc_get_obj_by_type(
-        topology, HWLOC_OBJ_NUMANODE,
-        ((struct numa_memtarget_t *)srcMemoryTarget)->physical_id);
+    hwloc_obj_t srcNumaNode = hwloc_get_numanode_obj_by_os_index(
+        topology, ((struct numa_memtarget_t *)srcMemoryTarget)->physical_id);
     if (!srcNumaNode) {
         LOG_PERR("Getting HWLOC object by type failed");
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    hwloc_obj_t dstNumaNode = hwloc_get_obj_by_type(
-        topology, HWLOC_OBJ_NUMANODE,
-        ((struct numa_memtarget_t *)dstMemoryTarget)->physical_id);
+    hwloc_obj_t dstNumaNode = hwloc_get_numanode_obj_by_os_index(
+        topology, ((struct numa_memtarget_t *)dstMemoryTarget)->physical_id);
     if (!dstNumaNode) {
         LOG_PERR("Getting HWLOC object by type failed");
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
@@ -309,8 +307,8 @@ static umf_result_t query_attribute_value(void *srcMemoryTarget,
     int ret = hwloc_memattr_get_value(topology, hwlocMemAttrType, dstNumaNode,
                                       &initiator, 0, &memAttrValue);
     if (ret) {
-        LOG_PERR("Getting an attribute value for a specific target NUMA node "
-                 "failed");
+        LOG_PDEBUG("Getting an attribute value for a specific target NUMA node "
+                   "failed");
         return (errno == EINVAL) ? UMF_RESULT_ERROR_NOT_SUPPORTED
                                  : UMF_RESULT_ERROR_UNKNOWN;
     }
@@ -330,9 +328,10 @@ static umf_result_t numa_get_bandwidth(void *srcMemoryTarget,
     umf_result_t ret = query_attribute_value(srcMemoryTarget, dstMemoryTarget,
                                              bandwidth, MEMATTR_TYPE_BANDWIDTH);
     if (ret) {
-        LOG_ERR("Retrieving bandwidth for initiator node %u to node %u failed.",
-                ((struct numa_memtarget_t *)srcMemoryTarget)->physical_id,
-                ((struct numa_memtarget_t *)dstMemoryTarget)->physical_id);
+        LOG_DEBUG(
+            "Retrieving bandwidth for initiator node %u to node %u failed.",
+            ((struct numa_memtarget_t *)srcMemoryTarget)->physical_id,
+            ((struct numa_memtarget_t *)dstMemoryTarget)->physical_id);
         return ret;
     }
 
@@ -348,9 +347,9 @@ static umf_result_t numa_get_latency(void *srcMemoryTarget,
     umf_result_t ret = query_attribute_value(srcMemoryTarget, dstMemoryTarget,
                                              latency, MEMATTR_TYPE_LATENCY);
     if (ret) {
-        LOG_ERR("Retrieving latency for initiator node %u to node %u failed.",
-                ((struct numa_memtarget_t *)srcMemoryTarget)->physical_id,
-                ((struct numa_memtarget_t *)dstMemoryTarget)->physical_id);
+        LOG_DEBUG("Retrieving latency for initiator node %u to node %u failed.",
+                  ((struct numa_memtarget_t *)srcMemoryTarget)->physical_id,
+                  ((struct numa_memtarget_t *)dstMemoryTarget)->physical_id);
         return ret;
     }
 
@@ -390,7 +389,7 @@ static umf_result_t numa_compare(void *memTarget, void *otherMemTarget,
 }
 
 struct umf_memtarget_ops_t UMF_MEMTARGET_NUMA_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_MEMTARGET_OPS_VERSION_CURRENT,
     .initialize = numa_initialize,
     .finalize = numa_finalize,
     .pool_create_from_memspace = numa_pool_create_from_memspace,
diff --git a/src/memtargets/memtarget_numa.h b/src/memtargets/memtarget_numa.h
index 2d3e3fd704..188ac4ce73 100644
--- a/src/memtargets/memtarget_numa.h
+++ b/src/memtargets/memtarget_numa.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 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
@@ -11,7 +11,7 @@
 #define UMF_MEMTARGET_NUMA_H 1
 
 #include <umf.h>
-#include <umf/memspace.h>
+#include <umf/experimental/memspace.h>
 
 #include "../memtarget_internal.h"
 #include "../memtarget_ops.h"
diff --git a/src/pool/CMakeLists.txt b/src/pool/CMakeLists.txt
deleted file mode 100644
index bdd196b041..0000000000
--- a/src/pool/CMakeLists.txt
+++ /dev/null
@@ -1,54 +0,0 @@
-# Copyright (C) 2023 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})
-
-# libumf_pool_disjoint
-if(UMF_BUILD_LIBUMF_POOL_DISJOINT)
-    add_umf_library(
-        NAME disjoint_pool
-        TYPE STATIC
-        SRCS pool_disjoint.cpp ${POOL_EXTRA_SRCS}
-        LIBS ${POOL_EXTRA_LIBS})
-
-    target_compile_definitions(disjoint_pool
-                               PRIVATE ${POOL_COMPILE_DEFINITIONS})
-
-    if(WINDOWS)
-        target_compile_options(disjoint_pool PRIVATE /DWIN32_LEAN_AND_MEAN
-                                                     /DNOMINMAX)
-    endif()
-
-    add_library(${PROJECT_NAME}::disjoint_pool ALIAS disjoint_pool)
-
-    add_dependencies(disjoint_pool umf)
-
-    target_link_libraries(disjoint_pool PRIVATE umf)
-
-    target_include_directories(
-        disjoint_pool
-        PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include/umf/pools>
-               $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
-
-    install(TARGETS disjoint_pool EXPORT ${PROJECT_NAME}-targets)
-endif()
-
-# libumf_pool_jemalloc
-if(UMF_BUILD_LIBUMF_POOL_JEMALLOC)
-    add_umf_library(
-        NAME jemalloc_pool
-        TYPE STATIC
-        SRCS pool_jemalloc.c ${POOL_EXTRA_SRCS}
-        LIBS jemalloc ${POOL_EXTRA_LIBS})
-    target_include_directories(jemalloc_pool PRIVATE ${JEMALLOC_INCLUDE_DIRS})
-    target_compile_definitions(jemalloc_pool
-                               PRIVATE ${POOL_COMPILE_DEFINITIONS})
-    add_library(${PROJECT_NAME}::jemalloc_pool ALIAS jemalloc_pool)
-    install(TARGETS jemalloc_pool EXPORT ${PROJECT_NAME}-targets)
-endif()
diff --git a/src/pool/pool_disjoint.c b/src/pool/pool_disjoint.c
new file mode 100644
index 0000000000..e059bba455
--- /dev/null
+++ b/src/pool/pool_disjoint.c
@@ -0,0 +1,1774 @@
+/*
+ * Copyright (C) 2022-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 <assert.h>
+#include <ctype.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <umf/base.h>
+#include <umf/memory_pool.h>
+#include <umf/memory_pool_ops.h>
+#include <umf/memory_provider.h>
+
+#include "base_alloc_global.h"
+#include "ctl/ctl_internal.h"
+#include "pool_disjoint_internal.h"
+#include "provider/provider_tracking.h"
+#include "uthash/utlist.h"
+#include "utils_common.h"
+#include "utils_concurrency.h"
+#include "utils_log.h"
+#include "utils_math.h"
+
+static const char *DEFAULT_NAME = "disjoint";
+
+/* Disjoint pool CTL implementation */
+struct ctl disjoint_ctl_root;
+static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT;
+
+umf_result_t disjoint_pool_post_initialize(void *ppPool);
+static umf_result_t
+CTL_RUNNABLE_HANDLER(post_initialize)(void *ctx, umf_ctl_query_source_t source,
+                                      void *arg, size_t size,
+                                      umf_ctl_index_utlist_t *indexes) {
+    (void)source;
+    (void)arg;
+    (void)size;
+    (void)indexes;
+    return disjoint_pool_post_initialize(ctx);
+}
+
+// Disable name ctl for 1.0 release
+#if 0
+static umf_result_t CTL_READ_HANDLER(name)(void *ctx,
+                                           umf_ctl_query_source_t source,
+                                           void *arg, size_t size,
+                                           umf_ctl_index_utlist_t *indexes) {
+    (void)source, (void)indexes;
+
+    disjoint_pool_t *pool = (disjoint_pool_t *)ctx;
+
+    if (arg == NULL) {
+        LOG_ERR("arg is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (size > 0) {
+        strncpy((char *)arg, pool->params.name, size - 1);
+        ((char *)arg)[size - 1] = '\0';
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static const struct ctl_argument CTL_ARG(name) = CTL_ARG_STRING(255);
+
+static umf_result_t CTL_WRITE_HANDLER(name)(void *ctx,
+                                            umf_ctl_query_source_t source,
+                                            void *arg, size_t size,
+                                            umf_ctl_index_utlist_t *indexes) {
+    (void)source, (void)indexes, (void)size;
+    disjoint_pool_t *pool = (disjoint_pool_t *)ctx;
+    if (arg == NULL) {
+        LOG_ERR("arg is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    strncpy(pool->params.name, (char *)arg, sizeof(pool->params.name) - 1);
+    pool->params.name[sizeof(pool->params.name) - 1] = '\0';
+
+    return UMF_RESULT_SUCCESS;
+}
+#endif
+
+static const struct ctl_argument
+    CTL_ARG(slab_min_size) = CTL_ARG_UNSIGNED_LONG_LONG;
+static const struct ctl_argument
+    CTL_ARG(max_poolable_size) = CTL_ARG_UNSIGNED_LONG_LONG;
+static const struct ctl_argument CTL_ARG(capacity) = CTL_ARG_UNSIGNED_LONG_LONG;
+static const struct ctl_argument
+    CTL_ARG(min_bucket_size) = CTL_ARG_UNSIGNED_LONG_LONG;
+static const struct ctl_argument CTL_ARG(pool_trace) = CTL_ARG_INT;
+
+static umf_result_t
+CTL_READ_HANDLER(slab_min_size)(void *ctx, umf_ctl_query_source_t source,
+                                void *arg, size_t size,
+                                umf_ctl_index_utlist_t *indexes) {
+    (void)source, (void)indexes;
+    disjoint_pool_t *pool = (disjoint_pool_t *)ctx;
+    if (arg == NULL || size != sizeof(size_t)) {
+        LOG_ERR("arg is NULL or size is not sizeof(size_t)");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    *(size_t *)arg = pool->params.slab_min_size;
+    return UMF_RESULT_SUCCESS;
+}
+
+// indicates that param was overridden by CTL
+enum {
+    DP_OVERRIDE_SLAB_MIN_SIZE = 1 << 0,
+    DP_OVERRIDE_MAX_POOLABLE_SIZE = 1 << 1,
+    DP_OVERRIDE_CAPACITY = 1 << 2,
+    DP_OVERRIDE_MIN_BUCKET_SIZE = 1 << 3,
+    DP_OVERRIDE_POOL_TRACE = 1 << 4,
+};
+
+static umf_result_t
+CTL_WRITE_HANDLER(slab_min_size)(void *ctx, umf_ctl_query_source_t source,
+                                 void *arg, size_t size,
+                                 umf_ctl_index_utlist_t *indexes) {
+    (void)source, (void)indexes;
+    disjoint_pool_t *pool = (disjoint_pool_t *)ctx;
+    if (pool->post_initialized) {
+        LOG_ERR("writing parameter after post_initialize is not allowed");
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+    if (arg == NULL || size != sizeof(size_t)) {
+        LOG_ERR("arg is NULL or size is not sizeof(size_t)");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    size_t value = *(size_t *)arg;
+    umf_result_t ret =
+        umfDisjointPoolParamsSetSlabMinSize(&pool->params, value);
+    if (ret == UMF_RESULT_SUCCESS) {
+        pool->params_overridden |= DP_OVERRIDE_SLAB_MIN_SIZE;
+    }
+    return ret;
+}
+
+static umf_result_t
+CTL_READ_HANDLER(max_poolable_size)(void *ctx, umf_ctl_query_source_t source,
+                                    void *arg, size_t size,
+                                    umf_ctl_index_utlist_t *indexes) {
+    (void)source, (void)indexes;
+    disjoint_pool_t *pool = (disjoint_pool_t *)ctx;
+    if (arg == NULL || size != sizeof(size_t)) {
+        LOG_ERR("arg is NULL or size is not sizeof(size_t)");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    *(size_t *)arg = pool->params.max_poolable_size;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t
+CTL_WRITE_HANDLER(max_poolable_size)(void *ctx, umf_ctl_query_source_t source,
+                                     void *arg, size_t size,
+                                     umf_ctl_index_utlist_t *indexes) {
+    (void)source, (void)indexes;
+    disjoint_pool_t *pool = (disjoint_pool_t *)ctx;
+    if (pool->post_initialized) {
+        LOG_ERR("writing parameter after post_initialize is not allowed");
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+    if (arg == NULL || size != sizeof(size_t)) {
+        LOG_ERR("arg is NULL or size is not sizeof(size_t)");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    size_t value = *(size_t *)arg;
+    umf_result_t ret =
+        umfDisjointPoolParamsSetMaxPoolableSize(&pool->params, value);
+    if (ret == UMF_RESULT_SUCCESS) {
+        pool->params_overridden |= DP_OVERRIDE_MAX_POOLABLE_SIZE;
+    }
+    return ret;
+}
+
+static umf_result_t
+CTL_READ_HANDLER(capacity)(void *ctx, umf_ctl_query_source_t source, void *arg,
+                           size_t size, umf_ctl_index_utlist_t *indexes) {
+    (void)source, (void)indexes;
+    disjoint_pool_t *pool = (disjoint_pool_t *)ctx;
+    if (arg == NULL || size != sizeof(size_t)) {
+        LOG_ERR("arg is NULL or size is not sizeof(size_t)");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    *(size_t *)arg = pool->params.capacity;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t
+CTL_WRITE_HANDLER(capacity)(void *ctx, umf_ctl_query_source_t source, void *arg,
+                            size_t size, umf_ctl_index_utlist_t *indexes) {
+    (void)source, (void)indexes;
+    disjoint_pool_t *pool = (disjoint_pool_t *)ctx;
+    if (pool->post_initialized) {
+        LOG_ERR("writing parameter after post_initialize is not allowed");
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+    if (arg == NULL || size != sizeof(size_t)) {
+        LOG_ERR("arg is NULL or size is not sizeof(size_t)");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    size_t value = *(size_t *)arg;
+    umf_result_t ret = umfDisjointPoolParamsSetCapacity(&pool->params, value);
+    if (ret == UMF_RESULT_SUCCESS) {
+        pool->params_overridden |= DP_OVERRIDE_CAPACITY;
+    }
+    return ret;
+}
+
+static umf_result_t
+CTL_READ_HANDLER(min_bucket_size)(void *ctx, umf_ctl_query_source_t source,
+                                  void *arg, size_t size,
+                                  umf_ctl_index_utlist_t *indexes) {
+    (void)source, (void)indexes;
+    disjoint_pool_t *pool = (disjoint_pool_t *)ctx;
+    if (arg == NULL || size != sizeof(size_t)) {
+        LOG_ERR("arg is NULL or size is not sizeof(size_t)");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    *(size_t *)arg = pool->params.min_bucket_size;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t
+CTL_WRITE_HANDLER(min_bucket_size)(void *ctx, umf_ctl_query_source_t source,
+                                   void *arg, size_t size,
+                                   umf_ctl_index_utlist_t *indexes) {
+    (void)source, (void)indexes;
+    disjoint_pool_t *pool = (disjoint_pool_t *)ctx;
+    if (pool->post_initialized) {
+        LOG_ERR("writing parameter after post_initialize is not allowed");
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+    if (arg == NULL || size != sizeof(size_t)) {
+        LOG_ERR("arg is NULL or size is not sizeof(size_t)");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    size_t value = *(size_t *)arg;
+    umf_result_t ret =
+        umfDisjointPoolParamsSetMinBucketSize(&pool->params, value);
+    if (ret == UMF_RESULT_SUCCESS) {
+        pool->params_overridden |= DP_OVERRIDE_MIN_BUCKET_SIZE;
+    }
+    return ret;
+}
+
+static umf_result_t
+CTL_READ_HANDLER(pool_trace)(void *ctx, umf_ctl_query_source_t source,
+                             void *arg, size_t size,
+                             umf_ctl_index_utlist_t *indexes) {
+    (void)source, (void)indexes;
+    disjoint_pool_t *pool = (disjoint_pool_t *)ctx;
+    if (arg == NULL || size != sizeof(int)) {
+        LOG_ERR("arg is NULL or size is not sizeof(int)");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    *(int *)arg = pool->params.pool_trace;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t
+CTL_WRITE_HANDLER(pool_trace)(void *ctx, umf_ctl_query_source_t source,
+                              void *arg, size_t size,
+                              umf_ctl_index_utlist_t *indexes) {
+    (void)source, (void)indexes;
+    disjoint_pool_t *pool = (disjoint_pool_t *)ctx;
+    if (pool->post_initialized) {
+        LOG_ERR("writing parameter after post_initialize is not allowed");
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+    if (arg == NULL || size != sizeof(int)) {
+        LOG_ERR("arg is NULL or size is not sizeof(int)");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    int value = *(int *)arg;
+    umf_result_t ret = umfDisjointPoolParamsSetTrace(&pool->params, value);
+    if (ret == UMF_RESULT_SUCCESS) {
+        pool->params_overridden |= DP_OVERRIDE_POOL_TRACE;
+    }
+    return ret;
+}
+
+static const umf_ctl_node_t CTL_NODE(params)[] = {
+    CTL_LEAF_RW(slab_min_size), CTL_LEAF_RW(max_poolable_size),
+    CTL_LEAF_RW(capacity),      CTL_LEAF_RW(min_bucket_size),
+    CTL_LEAF_RW(pool_trace),    CTL_NODE_END,
+};
+static umf_result_t
+CTL_READ_HANDLER(used_memory)(void *ctx, umf_ctl_query_source_t source,
+                              void *arg, size_t size,
+                              umf_ctl_index_utlist_t *indexes) {
+    (void)source, (void)indexes;
+    disjoint_pool_t *pool = (disjoint_pool_t *)ctx;
+
+    if (arg == NULL || size != sizeof(size_t)) {
+        LOG_ERR("arg is NULL or size is not sizeof(size_t)");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    size_t used_memory = 0;
+
+    // Calculate used memory across all buckets
+    for (size_t i = 0; i < pool->buckets_num; i++) {
+        bucket_t *bucket = pool->buckets[i];
+        utils_mutex_lock(&bucket->bucket_lock);
+
+        // Count allocated chunks in available slabs
+        slab_list_item_t *it;
+        for (it = bucket->available_slabs; it != NULL; it = it->next) {
+            slab_t *slab = it->val;
+            used_memory += slab->num_chunks_allocated * bucket->size;
+        }
+
+        // Count allocated chunks in unavailable slabs (all chunks allocated)
+        for (it = bucket->unavailable_slabs; it != NULL; it = it->next) {
+            slab_t *slab = it->val;
+            used_memory += slab->num_chunks_allocated * bucket->size;
+        }
+
+        utils_mutex_unlock(&bucket->bucket_lock);
+    }
+
+    *(size_t *)arg = used_memory;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t
+CTL_READ_HANDLER(reserved_memory)(void *ctx, umf_ctl_query_source_t source,
+                                  void *arg, size_t size,
+                                  umf_ctl_index_utlist_t *indexes) {
+    (void)source, (void)indexes;
+    disjoint_pool_t *pool = (disjoint_pool_t *)ctx;
+
+    if (arg == NULL || size != sizeof(size_t)) {
+        LOG_ERR("arg is NULL or size is not sizeof(size_t)");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    size_t reserved_memory = 0;
+
+    // Calculate reserved memory across all buckets
+    for (size_t i = 0; i < pool->buckets_num; i++) {
+        bucket_t *bucket = pool->buckets[i];
+        utils_mutex_lock(&bucket->bucket_lock);
+
+        // Count all slabs (both available and unavailable)
+        slab_list_item_t *it;
+        for (it = bucket->available_slabs; it != NULL; it = it->next) {
+            slab_t *slab = it->val;
+            reserved_memory += slab->slab_size;
+        }
+
+        for (it = bucket->unavailable_slabs; it != NULL; it = it->next) {
+            slab_t *slab = it->val;
+            reserved_memory += slab->slab_size;
+        }
+
+        utils_mutex_unlock(&bucket->bucket_lock);
+    }
+
+    *(size_t *)arg = reserved_memory;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t CTL_READ_HANDLER(count)(void *ctx,
+                                            umf_ctl_query_source_t source,
+                                            void *arg, size_t size,
+                                            umf_ctl_index_utlist_t *indexes) {
+    (void)source;
+
+    disjoint_pool_t *pool = (disjoint_pool_t *)ctx;
+    if (arg == NULL || size != sizeof(size_t)) {
+        LOG_ERR("arg is NULL or size is not sizeof(size_t)");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (*(size_t *)indexes->arg != SIZE_MAX) {
+        LOG_ERR("to read buckets' count, you must call it without bucket id");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    assert(pool);
+    *(size_t *)arg = pool->buckets_num;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+#define DEFINE_STATS_HANDLER(NAME, MEMBER)                                     \
+    static umf_result_t CTL_READ_HANDLER(NAME)(                                \
+        void *ctx, umf_ctl_query_source_t source, void *arg, size_t size,      \
+        umf_ctl_index_utlist_t *indexes) {                                     \
+        (void)source;                                                          \
+        (void)indexes;                                                         \
+        disjoint_pool_t *pool = (disjoint_pool_t *)ctx;                        \
+                                                                               \
+        if (arg == NULL || size != sizeof(size_t)) {                           \
+            LOG_ERR("arg is NULL or size is not sizeof(size_t)");              \
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;                          \
+        }                                                                      \
+                                                                               \
+        if (!pool->params.pool_trace) {                                        \
+            LOG_ERR("pool trace is disabled, cannot read " #NAME);             \
+            return UMF_RESULT_ERROR_NOT_SUPPORTED;                             \
+        }                                                                      \
+                                                                               \
+        size_t total = 0;                                                      \
+        for (size_t i = 0; i < pool->buckets_num; ++i) {                       \
+            bucket_t *bucket = pool->buckets[i];                               \
+            utils_mutex_lock(&bucket->bucket_lock);                            \
+            total += bucket->MEMBER;                                           \
+            utils_mutex_unlock(&bucket->bucket_lock);                          \
+        }                                                                      \
+                                                                               \
+        *(size_t *)arg = total;                                                \
+        return UMF_RESULT_SUCCESS;                                             \
+    }
+
+DEFINE_STATS_HANDLER(alloc_num, alloc_count)
+DEFINE_STATS_HANDLER(alloc_pool_num, alloc_pool_count)
+DEFINE_STATS_HANDLER(free_num, free_count)
+DEFINE_STATS_HANDLER(curr_slabs_in_use, curr_slabs_in_use)
+DEFINE_STATS_HANDLER(curr_slabs_in_pool, curr_slabs_in_pool)
+DEFINE_STATS_HANDLER(max_slabs_in_use, max_slabs_in_use)
+DEFINE_STATS_HANDLER(max_slabs_in_pool, max_slabs_in_pool)
+
+static const umf_ctl_node_t CTL_NODE(stats)[] = {
+    CTL_LEAF_RO(used_memory),        CTL_LEAF_RO(reserved_memory),
+    CTL_LEAF_RO(alloc_num),          CTL_LEAF_RO(alloc_pool_num),
+    CTL_LEAF_RO(free_num),           CTL_LEAF_RO(curr_slabs_in_use),
+    CTL_LEAF_RO(curr_slabs_in_pool), CTL_LEAF_RO(max_slabs_in_use),
+    CTL_LEAF_RO(max_slabs_in_pool),  CTL_NODE_END,
+};
+
+#undef DEFINE_STATS_HANDLER
+
+#ifdef UMF_DEVELOPER_MODE
+#define VALIDATE_BUCKETS_NAME(indexes)                                         \
+    if (strcmp("buckets", indexes->name) != 0) {                               \
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;                              \
+    }
+#else
+#define VALIDATE_BUCKETS_NAME(indexes)                                         \
+    do {                                                                       \
+    } while (0);
+#endif
+
+#define DEFINE_BUCKET_STATS_HANDLER(NAME, MEMBER)                              \
+    static umf_result_t CTL_READ_HANDLER(NAME, perBucket)(                     \
+        void *ctx, umf_ctl_query_source_t source, void *arg, size_t size,      \
+        umf_ctl_index_utlist_t *indexes) {                                     \
+        (void)source;                                                          \
+                                                                               \
+        disjoint_pool_t *pool = (disjoint_pool_t *)ctx;                        \
+        if (arg == NULL || size != sizeof(size_t)) {                           \
+            LOG_ERR("arg is NULL or size is not sizeof(size_t)");              \
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;                          \
+        }                                                                      \
+                                                                               \
+        VALIDATE_BUCKETS_NAME(indexes);                                        \
+        if (strcmp(#MEMBER, "size") != 0 && !pool->params.pool_trace) {        \
+            LOG_ERR("pool trace is disabled, cannot read " #NAME);             \
+            return UMF_RESULT_ERROR_NOT_SUPPORTED;                             \
+        }                                                                      \
+                                                                               \
+        size_t idx;                                                            \
+        idx = *(size_t *)indexes->arg;                                         \
+                                                                               \
+        if (idx >= pool->buckets_num) {                                        \
+            LOG_ERR("bucket id %zu is out of range [0, %zu)", idx,             \
+                    pool->buckets_num);                                        \
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;                          \
+        }                                                                      \
+                                                                               \
+        bucket_t *bucket = pool->buckets[idx];                                 \
+        utils_mutex_lock(&bucket->bucket_lock);                                \
+        *(size_t *)arg = bucket->MEMBER;                                       \
+        utils_mutex_unlock(&bucket->bucket_lock);                              \
+                                                                               \
+        return UMF_RESULT_SUCCESS;                                             \
+    }
+
+DEFINE_BUCKET_STATS_HANDLER(alloc_num, alloc_count)
+DEFINE_BUCKET_STATS_HANDLER(alloc_pool_num, alloc_pool_count)
+DEFINE_BUCKET_STATS_HANDLER(free_num, free_count)
+DEFINE_BUCKET_STATS_HANDLER(curr_slabs_in_use, curr_slabs_in_use)
+DEFINE_BUCKET_STATS_HANDLER(curr_slabs_in_pool, curr_slabs_in_pool)
+DEFINE_BUCKET_STATS_HANDLER(max_slabs_in_use, max_slabs_in_use)
+DEFINE_BUCKET_STATS_HANDLER(max_slabs_in_pool, max_slabs_in_pool)
+
+static const umf_ctl_node_t CTL_NODE(stats, perBucket)[] = {
+    CTL_LEAF_RO(alloc_num, perBucket),
+    CTL_LEAF_RO(alloc_pool_num, perBucket),
+    CTL_LEAF_RO(free_num, perBucket),
+    CTL_LEAF_RO(curr_slabs_in_use, perBucket),
+    CTL_LEAF_RO(curr_slabs_in_pool, perBucket),
+    CTL_LEAF_RO(max_slabs_in_use, perBucket),
+    CTL_LEAF_RO(max_slabs_in_pool, perBucket),
+    CTL_NODE_END,
+};
+
+// Not a counter; but it is read exactly like other per-bucket stats, so we can use macro.
+DEFINE_BUCKET_STATS_HANDLER(size, size)
+
+#undef DEFINE_BUCKET_STATS_HANDLER
+
+static const umf_ctl_node_t CTL_NODE(buckets)[] = {
+    CTL_LEAF_RO(count), CTL_LEAF_RO(size, perBucket),
+    CTL_CHILD(stats, perBucket), CTL_NODE_END};
+
+static int bucket_id_parser(const void *arg, void *dest, size_t dest_size) {
+    size_t *out = (size_t *)dest;
+    assert(out);
+
+    if (arg == NULL) {
+        *out = SIZE_MAX;
+        return 1; // node n
+    }
+
+    int ret = ctl_arg_unsigned(arg, dest, dest_size);
+    if (ret) {
+        *out = SIZE_MAX;
+        return 1;
+    }
+
+    return 0;
+}
+
+static const struct ctl_argument CTL_ARG(buckets) = {
+    sizeof(size_t),
+    {{0, sizeof(size_t), CTL_ARG_TYPE_UNSIGNED_LONG_LONG, bucket_id_parser},
+     CTL_ARG_PARSER_END}};
+
+static void initialize_disjoint_ctl(void) {
+    CTL_REGISTER_MODULE(&disjoint_ctl_root, params);
+    CTL_REGISTER_MODULE(&disjoint_ctl_root, stats);
+    CTL_REGISTER_MODULE(&disjoint_ctl_root, buckets);
+    // TODO: this is hack. Need some way to register module as node with argument
+    disjoint_ctl_root.root[disjoint_ctl_root.first_free - 1].arg =
+        &CTL_ARG(buckets);
+    disjoint_ctl_root.root[disjoint_ctl_root.first_free++] = (umf_ctl_node_t){
+        .name = "post_initialize",
+        .type = CTL_NODE_LEAF,
+        .runnable_cb = CTL_RUNNABLE_HANDLER(post_initialize),
+    };
+}
+
+umf_result_t disjoint_pool_ctl(void *hPool,
+                               umf_ctl_query_source_t operationType,
+                               const char *name, void *arg, size_t size,
+                               umf_ctl_query_type_t queryType, va_list args) {
+    utils_init_once(&ctl_initialized, initialize_disjoint_ctl);
+
+    return ctl_query(&disjoint_ctl_root, hPool, operationType, name, queryType,
+                     arg, size, args);
+}
+
+// Temporary solution for disabling memory poisoning. This is needed because
+// AddressSanitizer does not support memory poisoning for GPU allocations.
+// More info: https://github.com/oneapi-src/unified-memory-framework/issues/634
+#ifndef POISON_MEMORY
+#undef __SANITIZE_ADDRESS__
+#endif
+#include "utils_sanitizers.h"
+
+// Forward declarations
+static void bucket_update_stats(bucket_t *bucket, int in_use, int in_pool);
+static bool bucket_can_pool(bucket_t *bucket);
+static slab_list_item_t *bucket_get_avail_slab(bucket_t *bucket,
+                                               bool *from_pool);
+
+static __TLS umf_result_t TLS_last_allocation_error;
+
+// Allocations are a minimum of 4KB/64KB/2MB even when a smaller size is
+// requested. The implementation distinguishes between allocations of size
+// ChunkCutOff = (minimum-alloc-size / 2) and those that are larger.
+// Allocation requests smaller than ChunkCutoff use chunks taken from a single
+// coarse-grain allocation. Thus, for example, for a 64KB minimum allocation
+// size, and 8-byte allocations, only 1 in ~8000 requests results in a new
+// coarse-grain allocation. Freeing results only in a chunk of a larger
+// allocation to be marked as available and no real return to the system. An
+// allocation is returned to the system only when all chunks in the larger
+// allocation are freed by the program. Allocations larger than ChunkCutOff use
+// a separate coarse-grain allocation for each request. These are subject to
+// "pooling". That is, when such an allocation is freed by the program it is
+// retained in a pool. The pool is available for future allocations, which means
+// there are fewer actual coarse-grain allocations/deallocations.
+
+// The largest size which is allocated via the allocator.
+// Allocations with size > CutOff bypass the pool and
+// go directly to the provider.
+static const size_t CutOff = (size_t)1 << 31; // 2GB
+
+static size_t bucket_slab_min_size(bucket_t *bucket) {
+    return bucket->pool->params.slab_min_size;
+}
+
+static size_t bucket_slab_alloc_size(bucket_t *bucket) {
+    return utils_max(bucket->size, bucket_slab_min_size(bucket));
+}
+
+static slab_t *create_slab(bucket_t *bucket) {
+    assert(bucket);
+
+    umf_result_t res = UMF_RESULT_SUCCESS;
+    umf_memory_provider_handle_t provider = bucket->pool->provider;
+
+    size_t num_chunks_total =
+        utils_max(bucket_slab_min_size(bucket) / bucket->size, 1);
+
+    // Calculate the number of 64-bit words needed.
+    size_t num_words =
+        (num_chunks_total + CHUNK_BITMAP_SIZE - 1) / CHUNK_BITMAP_SIZE;
+
+    slab_t *slab = umf_ba_global_alloc(sizeof(*slab) +
+                                       num_words * sizeof(slab->chunks[0]));
+    if (slab == NULL) {
+        LOG_ERR("allocation of new slab failed!");
+        return NULL;
+    }
+
+    slab->num_chunks_allocated = 0;
+    slab->bucket = bucket;
+
+    slab->iter.val = slab;
+    slab->iter.prev = slab->iter.next = NULL;
+
+    slab->num_chunks_total = num_chunks_total;
+    slab->num_words = num_words;
+
+    // set all chunks as free
+    memset(slab->chunks, ~0, num_words * sizeof(slab->chunks[0]));
+    if (num_chunks_total % CHUNK_BITMAP_SIZE) {
+        // clear remaining bits
+        slab->chunks[num_words - 1] =
+            ((1ULL << (num_chunks_total % CHUNK_BITMAP_SIZE)) - 1);
+    }
+
+    // if slab_min_size is not a multiple of bucket size, we would have some
+    // padding at the end of the slab
+    slab->slab_size = bucket_slab_alloc_size(bucket);
+
+    // TODO not true
+    // NOTE: originally slabs memory were allocated without alignment
+    // with this registering a slab is simpler and doesn't require multimap
+    res = umfMemoryProviderAlloc(provider, slab->slab_size, 0, &slab->mem_ptr);
+    if (res != UMF_RESULT_SUCCESS) {
+        LOG_ERR("allocation of slab data failed!");
+        goto free_slab;
+    }
+
+    // raw allocation is not available for user so mark it as inaccessible
+    utils_annotate_memory_inaccessible(slab->mem_ptr, slab->slab_size);
+
+    LOG_DEBUG("bucket: %p, slab_size: %zu", (void *)bucket, slab->slab_size);
+    return slab;
+
+free_slab:
+    umf_ba_global_free(slab);
+    return NULL;
+}
+
+static void destroy_slab(slab_t *slab) {
+    LOG_DEBUG("bucket: %p, slab_size: %zu", (void *)slab->bucket,
+              slab->slab_size);
+
+    umf_memory_provider_handle_t provider = slab->bucket->pool->provider;
+    umf_result_t res =
+        umfMemoryProviderFree(provider, slab->mem_ptr, slab->slab_size);
+    if (res != UMF_RESULT_SUCCESS) {
+        LOG_ERR("deallocation of slab data failed!");
+    }
+}
+
+static size_t slab_find_first_available_chunk_idx(const slab_t *slab) {
+    for (size_t i = 0; i < slab->num_words; i++) {
+        // NOTE: free chunks are represented as set bits
+        uint64_t word = slab->chunks[i];
+        if (word != 0) {
+            size_t bit_index = utils_lsb64(word);
+            size_t free_chunk = i * CHUNK_BITMAP_SIZE + bit_index;
+            return free_chunk;
+        }
+    }
+
+    // No free chunk was found.
+    return SIZE_MAX;
+}
+
+static void *slab_get_chunk(slab_t *slab) {
+    // free chunk must exist, otherwise we would have allocated another slab
+    const size_t chunk_idx = slab_find_first_available_chunk_idx(slab);
+    assert(chunk_idx != SIZE_MAX);
+
+    void *free_chunk =
+        (void *)((uintptr_t)slab->mem_ptr + chunk_idx * slab->bucket->size);
+
+    // mark chunk as used
+    slab_set_chunk_bit(slab, chunk_idx, false);
+    slab->num_chunks_allocated += 1;
+
+    return free_chunk;
+}
+
+static void *slab_get(const slab_t *slab) { return slab->mem_ptr; }
+static void *slab_get_end(const slab_t *slab) {
+    return (void *)((uintptr_t)slab->mem_ptr +
+                    bucket_slab_min_size(slab->bucket));
+}
+
+static void slab_free_chunk(slab_t *slab, void *ptr) {
+    // This method should be called through bucket (since we might remove the
+    // slab as a result), therefore all locks are done on bucket level.
+
+    // Make sure that we're in the right slab
+    assert(ptr >= slab_get(slab) && ptr < slab_get_end(slab));
+
+    // Get the chunk index
+    uintptr_t ptr_diff = (uintptr_t)ptr - (uintptr_t)slab->mem_ptr;
+    assert((ptr_diff % slab->bucket->size) == 0);
+    size_t chunk_idx = ptr_diff / slab->bucket->size;
+
+    // Make sure that the chunk was allocated
+    assert(slab_read_chunk_bit(slab, chunk_idx) == 0 && "double free detected");
+    slab_set_chunk_bit(slab, chunk_idx, true);
+    slab->num_chunks_allocated -= 1;
+}
+
+static bool slab_has_avail(const slab_t *slab) {
+    return slab->num_chunks_allocated < slab->num_chunks_total;
+}
+
+static umf_result_t pool_register_slab(disjoint_pool_t *pool, slab_t *slab) {
+    critnib *slabs = pool->known_slabs;
+
+    // NOTE: changed vs original DisjointPool implementation - currently slab
+    // is already aligned to bucket size.
+    void *slab_addr = slab_get(slab);
+    // TODO ASSERT_IS_ALIGNED((uintptr_t)slab_addr, bucket->size);
+    LOG_DEBUG("slab: %p, start: %p", (void *)slab, slab_addr);
+
+    // NOTE: we don't need to lock the slabs map as the critnib already has a
+    // lock inside it
+    int ret = critnib_insert(slabs, (uintptr_t)slab_addr, slab, 0);
+    umf_result_t res = UMF_RESULT_SUCCESS;
+    if (ret == ENOMEM) {
+        LOG_ERR("register failed because of out of memory!");
+        res = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    } else if (ret == EEXIST) {
+        LOG_ERR("register failed because the address is already registered!");
+        res = UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    return res;
+}
+
+static umf_result_t pool_unregister_slab(disjoint_pool_t *pool, slab_t *slab) {
+    critnib *slabs = pool->known_slabs;
+
+    void *slab_addr = slab_get(slab);
+    // TODO ASSERT_IS_ALIGNED((uintptr_t)slab_addr, bucket->size);
+    LOG_DEBUG("slab: %p, start: %p", (void *)slab, slab_addr);
+
+    critnib_remove_release(slabs, (uintptr_t)slab_addr);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static bucket_t *
+create_bucket(size_t sz, disjoint_pool_t *pool,
+              umf_disjoint_pool_shared_limits_handle_t shared_limits) {
+
+    bucket_t *bucket = umf_ba_global_alloc(sizeof(*bucket));
+    if (bucket == NULL) {
+        LOG_ERR("allocation of new bucket failed!");
+        return NULL;
+    }
+
+    memset(bucket, 0, sizeof(*bucket));
+    bucket->size = sz;
+    bucket->pool = pool;
+    bucket->shared_limits = shared_limits;
+
+    utils_mutex_init(&bucket->bucket_lock);
+    return bucket;
+}
+
+static void destroy_bucket(bucket_t *bucket) {
+    // use an extra tmp to store the next iterator before destroying the slab
+    slab_list_item_t *it = NULL, *tmp = NULL;
+    LL_FOREACH_SAFE(bucket->available_slabs, it, tmp) {
+        LL_DELETE(bucket->available_slabs, it);
+        destroy_slab(it->val);
+    }
+
+    LL_FOREACH_SAFE(bucket->unavailable_slabs, it, tmp) {
+        LL_DELETE(bucket->unavailable_slabs, it);
+        destroy_slab(it->val);
+    }
+
+    utils_mutex_destroy_not_free(&bucket->bucket_lock);
+    umf_ba_global_free(bucket);
+}
+
+static size_t slab_get_num_free_chunks(const slab_t *slab) {
+    return slab->num_chunks_total - slab->num_chunks_allocated;
+}
+
+// NOTE: this function must be called under bucket->bucket_lock
+static void bucket_free_chunk(bucket_t *bucket, void *ptr, slab_t *slab,
+                              bool *to_pool) {
+    slab_free_chunk(slab, ptr);
+
+    // in case if the slab was previously full and now has single available
+    // chunk, it should be moved to the list of available slabs
+    if (slab_get_num_free_chunks(slab) == 1) {
+        slab_list_item_t *slab_it = &slab->iter;
+        assert(slab_it->val != NULL);
+        DL_DELETE(bucket->unavailable_slabs, slab_it);
+        DL_PREPEND(bucket->available_slabs, slab_it);
+        bucket->available_slabs_num++;
+    }
+
+    // check if slab is empty, and pool it if we can
+    if (slab->num_chunks_allocated == 0) {
+        // The slab is now empty.
+        // If the pool has capacity then put the slab in the pool.
+        // The to_pool parameter indicates whether the slab will be put in the
+        // pool or freed.
+        *to_pool = bucket_can_pool(bucket);
+        if (*to_pool == false) {
+            // remove slab
+            slab_list_item_t *slab_it = &slab->iter;
+            assert(slab_it->val != NULL);
+            pool_unregister_slab(bucket->pool, slab_it->val);
+            DL_DELETE(bucket->available_slabs, slab_it);
+            assert(bucket->available_slabs_num > 0);
+            bucket->available_slabs_num--;
+            destroy_slab(slab_it->val);
+        }
+    } else {
+        // return this chunk to the pool
+        *to_pool = true;
+    }
+}
+
+// NOTE: this function must be called under bucket->bucket_lock
+static void *bucket_get_free_chunk(bucket_t *bucket, bool *from_pool) {
+    slab_list_item_t *slab_it = bucket_get_avail_slab(bucket, from_pool);
+    if (slab_it == NULL) {
+        return NULL;
+    }
+
+    void *free_chunk = slab_get_chunk(slab_it->val);
+
+    // if we allocated last free chunk from the slab and now it is full, move
+    // it to unavailable slabs and update its iterator
+    if (!(slab_has_avail(slab_it->val))) {
+        DL_DELETE(bucket->available_slabs, slab_it);
+        bucket->available_slabs_num--;
+        slab_it->prev = NULL;
+        DL_PREPEND(bucket->unavailable_slabs, slab_it);
+    }
+
+    return free_chunk;
+}
+
+static size_t bucket_chunk_cut_off(bucket_t *bucket) {
+    return bucket_slab_min_size(bucket) / 2;
+}
+
+static slab_t *bucket_create_slab(bucket_t *bucket) {
+    slab_t *slab = create_slab(bucket);
+    if (slab == NULL) {
+        LOG_ERR("create_slab failed!")
+        return NULL;
+    }
+
+    umf_result_t res = pool_register_slab(bucket->pool, slab);
+    if (res != UMF_RESULT_SUCCESS) {
+        LOG_ERR("slab_reg failed!")
+        destroy_slab(slab);
+        return NULL;
+    }
+
+    DL_PREPEND(bucket->available_slabs, &slab->iter);
+    bucket->available_slabs_num++;
+    bucket_update_stats(bucket, 1, 0);
+
+    return slab;
+}
+
+static slab_list_item_t *bucket_get_avail_slab(bucket_t *bucket,
+                                               bool *from_pool) {
+    if (bucket->available_slabs == NULL) {
+        bucket_create_slab(bucket);
+        *from_pool = false;
+    } else {
+        slab_t *slab = bucket->available_slabs->val;
+        // Allocation from existing slab is treated as from pool for statistics.
+        *from_pool = true;
+        if (slab->num_chunks_allocated == 0) {
+            assert(bucket->chunked_slabs_in_pool > 0);
+            // If this was an empty slab, it was in the pool.
+            // Now it is no longer in the pool, so update count.
+            --bucket->chunked_slabs_in_pool;
+            uint64_t size_to_sub = bucket_slab_alloc_size(bucket);
+            uint64_t old_size = utils_fetch_and_sub_u64(
+                &bucket->shared_limits->total_size, size_to_sub);
+            (void)old_size;
+            assert(old_size >= size_to_sub);
+            bucket_update_stats(bucket, 1, -1);
+        }
+    }
+
+    return bucket->available_slabs;
+}
+
+static size_t bucket_max_pooled_slabs(bucket_t *bucket) {
+    // For small buckets where slabs are split to chunks, just one pooled slab is sufficient.
+    // For larger buckets, the capacity could be more and is adjustable.
+    if (bucket->size <= bucket_chunk_cut_off(bucket)) {
+        return 1;
+    } else {
+        return bucket->pool->params.capacity;
+    }
+}
+
+static void bucket_update_stats(bucket_t *bucket, int in_use, int in_pool) {
+    if (bucket->pool->params.pool_trace == 0) {
+        return;
+    }
+
+    bucket->curr_slabs_in_use += in_use;
+    bucket->max_slabs_in_use =
+        utils_max(bucket->curr_slabs_in_use, bucket->max_slabs_in_use);
+
+    bucket->curr_slabs_in_pool += in_pool;
+    bucket->max_slabs_in_pool =
+        utils_max(bucket->curr_slabs_in_pool, bucket->max_slabs_in_pool);
+
+    // Increment or decrement current pool sizes based on whether
+    // slab was added to or removed from pool.
+    bucket->pool->params.cur_pool_size +=
+        in_pool * bucket_slab_alloc_size(bucket);
+}
+
+static bool bucket_can_pool(bucket_t *bucket) {
+    size_t new_free_slabs_in_bucket;
+
+    new_free_slabs_in_bucket = bucket->chunked_slabs_in_pool + 1;
+
+    // we keep at most params.capacity slabs in the pool
+    if (bucket_max_pooled_slabs(bucket) >= new_free_slabs_in_bucket) {
+
+        uint64_t size_to_add = bucket_slab_alloc_size(bucket);
+        size_t previous_size = utils_fetch_and_add_u64(
+            &bucket->shared_limits->total_size, size_to_add);
+
+        if (previous_size + size_to_add <= bucket->shared_limits->max_size) {
+            ++bucket->chunked_slabs_in_pool;
+            bucket_update_stats(bucket, -1, 1);
+            return true;
+        } else {
+            uint64_t old = utils_fetch_and_sub_u64(
+                &bucket->shared_limits->total_size, size_to_add);
+            (void)old;
+            assert(old >= size_to_add);
+        }
+    }
+
+    bucket_update_stats(bucket, -1, 0);
+    return false;
+}
+
+static size_t size_to_idx(disjoint_pool_t *pool, size_t size) {
+    assert(size <= CutOff && "Unexpected size");
+    assert(size > 0 && "Unexpected size");
+
+    size_t min_bucket_size = (size_t)1 << pool->min_bucket_size_exp;
+    if (size < min_bucket_size) {
+        return 0;
+    }
+
+    // get the position of the leftmost set bit
+    size_t position = utils_msb64(size);
+
+    bool is_power_of_2 = IS_POWER_OF_2(size);
+    bool larger_than_halfway_between_powers_of_2 =
+        !is_power_of_2 &&
+        (bool)((size - 1) & ((uint64_t)(1) << (position - 1)));
+    size_t index = (position - pool->min_bucket_size_exp) * 2 +
+                   (int)(!is_power_of_2) +
+                   (int)larger_than_halfway_between_powers_of_2;
+
+    return index;
+}
+
+static umf_disjoint_pool_shared_limits_t *
+disjoint_pool_get_limits(disjoint_pool_t *pool) {
+    if (pool->params.shared_limits) {
+        return pool->params.shared_limits;
+    } else {
+        return pool->default_shared_limits;
+    }
+}
+
+static bucket_t *disjoint_pool_find_bucket(disjoint_pool_t *pool, size_t size) {
+    size_t calculated_idx = size_to_idx(pool, size);
+    return pool->buckets[calculated_idx];
+}
+
+static void disjoint_pool_print_stats(disjoint_pool_t *pool) {
+    size_t high_bucket_size = 0;
+    size_t high_peak_slabs_in_use = 0;
+    const char *name = pool->params.name;
+
+    LOG_DEBUG("\"%s\" pool memory statistics", name);
+    LOG_DEBUG("%14s %12s %12s %18s %20s %21s", "Bucket Size", "Allocs", "Frees",
+              "Allocs from Pool", "Peak Slabs in Use", "Peak Slabs in Pool");
+
+    for (size_t i = 0; i < pool->buckets_num; i++) {
+        bucket_t *bucket = pool->buckets[i];
+        // lock bucket before accessing its stats
+        utils_mutex_lock(&bucket->bucket_lock);
+
+        if (bucket->alloc_count) {
+            LOG_DEBUG("%14zu %12zu %12zu %18zu %20zu %21zu", bucket->size,
+                      bucket->alloc_count, bucket->free_count,
+                      bucket->alloc_pool_count, bucket->max_slabs_in_use,
+                      bucket->max_slabs_in_pool);
+            high_bucket_size =
+                utils_max(bucket_slab_alloc_size(bucket), high_bucket_size);
+        }
+
+        high_peak_slabs_in_use =
+            utils_max(bucket->max_slabs_in_use, high_peak_slabs_in_use);
+
+        utils_mutex_unlock(&bucket->bucket_lock);
+    }
+
+    LOG_DEBUG("current pool size: %" PRIu64,
+              disjoint_pool_get_limits(pool)->total_size);
+    LOG_DEBUG("suggested setting=;%c%s:%zu,%zu,64K", (char)tolower(name[0]),
+              (name + 1), high_bucket_size, high_peak_slabs_in_use);
+}
+
+static void *disjoint_pool_allocate(disjoint_pool_t *pool, size_t size) {
+    if (size == 0) {
+        return NULL;
+    }
+
+    void *ptr = NULL;
+
+    if (size > pool->params.max_poolable_size) {
+        umf_result_t ret =
+            umfMemoryProviderAlloc(pool->provider, size, 0, &ptr);
+        if (ret != UMF_RESULT_SUCCESS) {
+            TLS_last_allocation_error = ret;
+            LOG_ERR("allocation from the memory provider failed");
+            return NULL;
+        }
+
+        utils_annotate_memory_undefined(ptr, size);
+        return ptr;
+    }
+
+    bucket_t *bucket = disjoint_pool_find_bucket(pool, size);
+
+    utils_mutex_lock(&bucket->bucket_lock);
+
+    bool from_pool = false;
+    ptr = bucket_get_free_chunk(bucket, &from_pool);
+
+    if (ptr == NULL) {
+        TLS_last_allocation_error = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        utils_mutex_unlock(&bucket->bucket_lock);
+        return NULL;
+    }
+
+    if (pool->params.pool_trace > 1) {
+        // update stats
+        ++bucket->alloc_count;
+        if (from_pool) {
+            ++bucket->alloc_pool_count;
+        }
+    }
+
+    utils_mutex_unlock(&bucket->bucket_lock);
+
+    if (pool->params.pool_trace > 2) {
+        LOG_DEBUG("Allocated %8zu %s bytes from %s -> %p", size,
+                  pool->params.name, (from_pool ? "pool" : "provider"), ptr);
+    }
+
+    VALGRIND_DO_MEMPOOL_ALLOC(pool, ptr, size);
+    utils_annotate_memory_undefined(ptr, bucket->size);
+    return ptr;
+}
+
+/*
+ * free_slab - callback for freeing the slab.
+ *             It is called by critnib when the slab
+ *             is removed from the critnib.
+ */
+static void free_slab(void *unused, void *slab) {
+    (void)unused;
+    if (slab) {
+        umf_ba_global_free(slab);
+    }
+}
+
+static const umf_disjoint_pool_params_t default_params = {
+    .slab_min_size = 64 * 1024,           // 64KB default
+    .max_poolable_size = 2 * 1024 * 1024, // 2MB default
+    .capacity = 4,                        // default
+    .min_bucket_size = 8,                 // default
+    .cur_pool_size = 0,
+    .pool_trace = 0,
+    .shared_limits = NULL,
+    .name = "disjoint"};
+
+umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
+                                      const void *params, void **ppPool) {
+    if (!provider || !ppPool) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    const umf_disjoint_pool_params_t *dp_params;
+
+    // If params is NULL, use default values
+    if (!params) {
+        dp_params = &default_params;
+    } else {
+        dp_params = params;
+    }
+
+    disjoint_pool_t *disjoint_pool =
+        umf_ba_global_alloc(sizeof(*disjoint_pool));
+    if (disjoint_pool == NULL) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    VALGRIND_DO_CREATE_MEMPOOL(disjoint_pool, 0, 0);
+
+    disjoint_pool->provider = provider;
+    disjoint_pool->params = *dp_params;
+    disjoint_pool->post_initialized = false;
+    disjoint_pool->params_overridden = 0;
+
+    *ppPool = (void *)disjoint_pool;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t disjoint_pool_post_initialize(void *ppPool) {
+    disjoint_pool_t *disjoint_pool = (disjoint_pool_t *)ppPool;
+
+    disjoint_pool->post_initialized = true;
+
+    if (disjoint_pool->params_overridden) {
+        if (disjoint_pool->params_overridden & DP_OVERRIDE_SLAB_MIN_SIZE) {
+            LOG_INFO("CTL override: slab_min_size=%zu",
+                     disjoint_pool->params.slab_min_size);
+        }
+        if (disjoint_pool->params_overridden & DP_OVERRIDE_MAX_POOLABLE_SIZE) {
+            LOG_INFO("CTL override: max_poolable_size=%zu",
+                     disjoint_pool->params.max_poolable_size);
+        }
+        if (disjoint_pool->params_overridden & DP_OVERRIDE_CAPACITY) {
+            LOG_INFO("CTL override: capacity=%zu",
+                     disjoint_pool->params.capacity);
+        }
+        if (disjoint_pool->params_overridden & DP_OVERRIDE_MIN_BUCKET_SIZE) {
+            LOG_INFO("CTL override: min_bucket_size=%zu",
+                     disjoint_pool->params.min_bucket_size);
+        }
+        if (disjoint_pool->params_overridden & DP_OVERRIDE_POOL_TRACE) {
+            LOG_INFO("CTL override: pool_trace=%d",
+                     disjoint_pool->params.pool_trace);
+        }
+    }
+
+    disjoint_pool->known_slabs = critnib_new(free_slab, NULL);
+    if (disjoint_pool->known_slabs == NULL) {
+        goto err_free_disjoint_pool;
+    }
+
+    // Generate buckets sized such as: 64, 96, 128, 192, ..., CutOff.
+    // Powers of 2 and the value halfway between the powers of 2.
+    size_t Size1 = disjoint_pool->params.min_bucket_size;
+
+    // min_bucket_size cannot be larger than CutOff.
+    Size1 = utils_min(Size1, CutOff);
+
+    // Buckets sized smaller than the bucket default size- 8 aren't needed.
+    Size1 = utils_max(Size1, UMF_DISJOINT_POOL_MIN_BUCKET_DEFAULT_SIZE);
+
+    // Calculate the exponent for min_bucket_size used for finding buckets.
+    disjoint_pool->min_bucket_size_exp = (size_t)utils_msb64(Size1);
+    if (umfDisjointPoolSharedLimitsCreate(
+            SIZE_MAX, &disjoint_pool->default_shared_limits) !=
+        UMF_RESULT_SUCCESS) {
+        goto err_free_known_slabs;
+    }
+
+    // count number of buckets, start from 1
+    disjoint_pool->buckets_num = 1;
+    size_t Size2 = Size1 + Size1 / 2;
+    size_t ts2 = Size2, ts1 = Size1;
+    while (Size2 < CutOff) {
+        disjoint_pool->buckets_num += 2;
+        Size2 *= 2;
+    }
+
+    disjoint_pool->buckets = umf_ba_global_alloc(
+        sizeof(*disjoint_pool->buckets) * disjoint_pool->buckets_num);
+    if (disjoint_pool->buckets == NULL) {
+        goto err_free_shared_limits;
+    }
+
+    size_t i = 0;
+    Size1 = ts1;
+    Size2 = ts2;
+    for (; Size2 < CutOff; Size1 *= 2, Size2 *= 2, i += 2) {
+        disjoint_pool->buckets[i] = create_bucket(
+            Size1, disjoint_pool, disjoint_pool_get_limits(disjoint_pool));
+        disjoint_pool->buckets[i + 1] = create_bucket(
+            Size2, disjoint_pool, disjoint_pool_get_limits(disjoint_pool));
+    }
+    disjoint_pool->buckets[i] = create_bucket(
+        CutOff, disjoint_pool, disjoint_pool_get_limits(disjoint_pool));
+
+    // check if all buckets were created successfully
+    for (i = 0; i < disjoint_pool->buckets_num; i++) {
+        if (disjoint_pool->buckets[i] == NULL) {
+            goto err_free_buckets;
+        }
+    }
+
+    umf_result_t ret = umfMemoryProviderGetMinPageSize(
+        disjoint_pool->provider, NULL, &disjoint_pool->provider_min_page_size);
+    if (ret != UMF_RESULT_SUCCESS) {
+        disjoint_pool->provider_min_page_size = 0;
+    }
+
+    return UMF_RESULT_SUCCESS;
+
+err_free_buckets:
+    for (i = 0; i < disjoint_pool->buckets_num; i++) {
+        if (disjoint_pool->buckets[i] != NULL) {
+            destroy_bucket(disjoint_pool->buckets[i]);
+        }
+    }
+    umf_ba_global_free(disjoint_pool->buckets);
+
+err_free_shared_limits:
+    umfDisjointPoolSharedLimitsDestroy(disjoint_pool->default_shared_limits);
+
+err_free_known_slabs:
+    critnib_delete(disjoint_pool->known_slabs);
+
+err_free_disjoint_pool:
+    umf_ba_global_free(disjoint_pool);
+    return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+}
+
+void *disjoint_pool_malloc(void *pool, size_t size) {
+    disjoint_pool_t *hPool = (disjoint_pool_t *)pool;
+    void *ptr = disjoint_pool_allocate(hPool, size);
+
+    return ptr;
+}
+
+void *disjoint_pool_calloc(void *pool, size_t num, size_t size) {
+    (void)pool;
+    (void)num;
+    (void)size;
+
+    // Not supported
+    TLS_last_allocation_error = UMF_RESULT_ERROR_NOT_SUPPORTED;
+    return NULL;
+}
+
+void *disjoint_pool_realloc(void *pool, void *ptr, size_t size) {
+    (void)pool;
+    (void)ptr;
+    (void)size;
+
+    // Not supported
+    TLS_last_allocation_error = UMF_RESULT_ERROR_NOT_SUPPORTED;
+    return NULL;
+}
+
+void *disjoint_pool_aligned_malloc(void *pool, size_t size, size_t alignment) {
+    disjoint_pool_t *disjoint_pool = (disjoint_pool_t *)pool;
+
+    void *ptr = NULL;
+
+    if (size == 0) {
+        return NULL;
+    }
+
+    if (alignment <= 1) {
+        return disjoint_pool_allocate(pool, size);
+    }
+
+    size_t aligned_size;
+    if (alignment <= disjoint_pool->provider_min_page_size) {
+        // This allocation will be served from a Bucket which size is multiple
+        // of Alignment and Slab address is aligned to provider_min_page_size
+        // so the address will be properly aligned.
+        aligned_size = (size > 1) ? ALIGN_UP_SAFE(size, alignment) : alignment;
+    } else {
+        // Slabs are only aligned to provider_min_page_size, we need to compensate
+        // for that in case the allocation is within pooling limit.
+        // TODO: consider creating properly-aligned Slabs on demand
+        aligned_size = size + alignment - 1;
+    }
+
+    // Check if requested allocation size is within pooling limit.
+    // If not, just request aligned pointer from the system.
+    if (aligned_size > disjoint_pool->params.max_poolable_size) {
+
+        umf_result_t ret = umfMemoryProviderAlloc(disjoint_pool->provider, size,
+                                                  alignment, &ptr);
+        if (ret != UMF_RESULT_SUCCESS) {
+            TLS_last_allocation_error = ret;
+            LOG_ERR("allocation from the memory provider failed");
+            return NULL;
+        }
+
+        assert(ptr);
+        utils_annotate_memory_undefined(ptr, size);
+        return ptr;
+    }
+
+    bool from_pool = false;
+    bucket_t *bucket = disjoint_pool_find_bucket(pool, aligned_size);
+
+    utils_mutex_lock(&bucket->bucket_lock);
+
+    ptr = bucket_get_free_chunk(bucket, &from_pool);
+
+    if (ptr == NULL) {
+        TLS_last_allocation_error = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        utils_mutex_unlock(&bucket->bucket_lock);
+        return NULL;
+    }
+
+    if (disjoint_pool->params.pool_trace > 1) {
+        // update stats
+        ++bucket->alloc_count;
+        if (from_pool) {
+            ++bucket->alloc_pool_count;
+        }
+    }
+
+    void *aligned_ptr = (void *)ALIGN_UP_SAFE((size_t)ptr, alignment);
+    size_t diff = (ptrdiff_t)aligned_ptr - (ptrdiff_t)ptr;
+    size_t real_size = bucket->size - diff;
+    VALGRIND_DO_MEMPOOL_ALLOC(disjoint_pool, aligned_ptr, real_size);
+    utils_annotate_memory_undefined(aligned_ptr, real_size);
+
+    utils_mutex_unlock(&bucket->bucket_lock);
+
+    if (disjoint_pool->params.pool_trace > 2) {
+        LOG_DEBUG("Allocated %8zu %s bytes aligned at %zu from %s -> %p", size,
+                  disjoint_pool->params.name, alignment,
+                  (from_pool ? "pool" : "provider"), ptr);
+    }
+
+    return aligned_ptr;
+}
+
+static size_t get_chunk_idx(const void *ptr, slab_t *slab) {
+    return (((uintptr_t)ptr - (uintptr_t)slab->mem_ptr) / slab->bucket->size);
+}
+
+static void *get_unaligned_ptr(size_t chunk_idx, slab_t *slab) {
+    return (void *)((uintptr_t)slab->mem_ptr + chunk_idx * slab->bucket->size);
+}
+
+umf_result_t disjoint_pool_malloc_usable_size(void *pool, const void *ptr,
+                                              size_t *size) {
+    disjoint_pool_t *disjoint_pool = (disjoint_pool_t *)pool;
+    if (!size || !disjoint_pool) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    if (ptr == NULL) {
+        *size = 0;
+        return UMF_RESULT_SUCCESS;
+    }
+
+    // check if given pointer is allocated inside any Disjoint Pool slab
+    void *ref_slab = NULL;
+    slab_t *slab = (slab_t *)critnib_find_le(disjoint_pool->known_slabs,
+                                             (uintptr_t)ptr, &ref_slab);
+    if (slab == NULL || ptr >= slab_get_end(slab)) {
+        // memory comes directly from the provider
+        if (ref_slab) {
+            critnib_release(disjoint_pool->known_slabs, ref_slab);
+        }
+
+        umf_memory_properties_handle_t props = NULL;
+        umf_result_t umf_result = umfGetMemoryPropertiesHandle(ptr, &props);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            return umf_result;
+        }
+
+        if (props == NULL) {
+            TLS_last_allocation_error = UMF_RESULT_ERROR_UNKNOWN;
+            LOG_ERR("failed to get allocation info from the memory tracker");
+            return UMF_RESULT_ERROR_UNKNOWN;
+        }
+
+        *size = props->base_size;
+        return UMF_RESULT_SUCCESS;
+    }
+
+    // Get the unaligned pointer
+    // NOTE: the base pointer slab->mem_ptr needn't to be aligned to bucket size
+    size_t chunk_idx = get_chunk_idx(ptr, slab);
+    void *unaligned_ptr = get_unaligned_ptr(chunk_idx, slab);
+
+    ptrdiff_t diff = (ptrdiff_t)ptr - (ptrdiff_t)unaligned_ptr;
+
+    *size = slab->bucket->size - diff;
+
+    assert(ref_slab);
+    critnib_release(disjoint_pool->known_slabs, ref_slab);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t disjoint_pool_free(void *pool, void *ptr) {
+    disjoint_pool_t *disjoint_pool = (disjoint_pool_t *)pool;
+    if (ptr == NULL) {
+        return UMF_RESULT_SUCCESS;
+    }
+
+    // check if given pointer is allocated inside any Disjoint Pool slab
+    void *ref_slab = NULL;
+    slab_t *slab = (slab_t *)critnib_find_le(disjoint_pool->known_slabs,
+                                             (uintptr_t)ptr, &ref_slab);
+
+    if (slab == NULL || ptr >= slab_get_end(slab)) {
+        // regular free
+        if (ref_slab) {
+            critnib_release(disjoint_pool->known_slabs, ref_slab);
+        }
+
+        umf_memory_properties_handle_t props = NULL;
+        umf_result_t ret = umfGetMemoryPropertiesHandle(ptr, &props);
+        if (ret != UMF_RESULT_SUCCESS) {
+            TLS_last_allocation_error = ret;
+            LOG_ERR("failed to get allocation info from the memory tracker");
+            return ret;
+        }
+
+        if (props == NULL) {
+            TLS_last_allocation_error = UMF_RESULT_ERROR_UNKNOWN;
+            LOG_ERR("failed to get allocation info from the memory tracker");
+            return UMF_RESULT_ERROR_UNKNOWN;
+        }
+
+        size_t size = props->base_size;
+        umf_memory_provider_handle_t provider = disjoint_pool->provider;
+        ret = umfMemoryProviderFree(provider, ptr, size);
+        if (ret != UMF_RESULT_SUCCESS) {
+            TLS_last_allocation_error = ret;
+            LOG_ERR("deallocation from the memory provider failed");
+        }
+
+        return ret;
+    }
+
+    bool to_pool = false;
+
+    if (ptr < slab_get(slab) || ptr >= slab_get_end(slab)) {
+        assert(0);
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    // The slab object won't be deleted until it's removed from the map which is
+    // protected by the lock, so it's safe to access it here.
+
+    bucket_t *bucket = slab->bucket;
+
+    utils_mutex_lock(&bucket->bucket_lock);
+    VALGRIND_DO_MEMPOOL_FREE(pool, ptr);
+
+    // Get the unaligned pointer
+    // NOTE: the base pointer slab->mem_ptr needn't to be aligned to bucket size
+    size_t chunk_idx = get_chunk_idx(ptr, slab);
+    void *unaligned_ptr = get_unaligned_ptr(chunk_idx, slab);
+
+    utils_annotate_memory_inaccessible(unaligned_ptr, bucket->size);
+    bucket_free_chunk(bucket, unaligned_ptr, slab, &to_pool);
+
+    assert(ref_slab);
+    critnib_release(disjoint_pool->known_slabs, ref_slab);
+
+    if (disjoint_pool->params.pool_trace > 1) {
+        bucket->free_count++;
+    }
+
+    utils_mutex_unlock(&bucket->bucket_lock);
+
+    if (disjoint_pool->params.pool_trace > 2) {
+        const char *name = disjoint_pool->params.name;
+        LOG_DEBUG("freed %s %p to %s, current total pool size: %" PRIu64
+                  ", current "
+                  "pool size for %s: %zu",
+                  name, ptr, (to_pool ? "pool" : "provider"),
+                  disjoint_pool_get_limits(disjoint_pool)->total_size, name,
+                  disjoint_pool->params.cur_pool_size);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t disjoint_pool_get_last_allocation_error(void *pool) {
+    (void)pool;
+    return TLS_last_allocation_error;
+}
+
+// Define destructor for use with unique_ptr
+umf_result_t disjoint_pool_finalize(void *pool) {
+    disjoint_pool_t *hPool = (disjoint_pool_t *)pool;
+    umf_result_t ret = UMF_RESULT_SUCCESS;
+    if (hPool->params.pool_trace > 1) {
+        disjoint_pool_print_stats(hPool);
+    }
+
+    for (size_t i = 0; i < hPool->buckets_num; i++) {
+        destroy_bucket(hPool->buckets[i]);
+    }
+
+    umf_ba_global_free(hPool->buckets);
+    VALGRIND_DO_DESTROY_MEMPOOL(hPool);
+    ret = umfDisjointPoolSharedLimitsDestroy(hPool->default_shared_limits);
+    if (ret != UMF_RESULT_SUCCESS) {
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+        LOG_ERR("umfDisjointPoolSharedLimitsDestroy failed");
+    }
+
+    critnib_delete(hPool->known_slabs);
+
+    umf_ba_global_free(hPool);
+    return ret;
+}
+
+static umf_result_t disjoint_pool_get_name(void *pool, const char **name) {
+    if (!name) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    disjoint_pool_t *hPool = (disjoint_pool_t *)pool;
+    if (pool == NULL) {
+        *name = DEFAULT_NAME;
+        return UMF_RESULT_SUCCESS;
+    }
+    *name = hPool->params.name;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t disjoint_pool_trim_memory(void *pool, size_t minBytesToKeep) {
+    assert(pool != NULL);
+    disjoint_pool_t *hPool = (disjoint_pool_t *)pool;
+
+    for (size_t i = 0; i < hPool->buckets_num; i++) {
+        bucket_t *bucket = hPool->buckets[i];
+        utils_mutex_lock(&bucket->bucket_lock);
+
+        // remove empty slabs from the pool
+        slab_list_item_t *it = NULL, *tmp = NULL;
+        LL_FOREACH_SAFE(bucket->available_slabs, it, tmp) {
+            slab_t *slab = it->val;
+            if (slab->num_chunks_allocated == 0) {
+                if (minBytesToKeep > 0) {
+                    // if we still have bytes to keep, do not remove slab
+                    if (minBytesToKeep > slab->slab_size) {
+                        minBytesToKeep -= slab->slab_size;
+                    } else {
+                        minBytesToKeep = 0;
+                    }
+                    continue;
+                }
+
+                // remove slab
+                destroy_slab(slab);
+                DL_DELETE(bucket->available_slabs, it);
+                assert(bucket->available_slabs_num > 0);
+                bucket->available_slabs_num--;
+                pool_unregister_slab(hPool, slab);
+
+                // update stats
+                bucket_update_stats(bucket, 0, -1);
+            }
+        }
+
+        utils_mutex_unlock(&bucket->bucket_lock);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_memory_pool_ops_t UMF_DISJOINT_POOL_OPS = {
+    .version = UMF_POOL_OPS_VERSION_CURRENT,
+    .initialize = disjoint_pool_initialize,
+    .finalize = disjoint_pool_finalize,
+    .malloc = disjoint_pool_malloc,
+    .calloc = disjoint_pool_calloc,
+    .realloc = disjoint_pool_realloc,
+    .aligned_malloc = disjoint_pool_aligned_malloc,
+    .malloc_usable_size = disjoint_pool_malloc_usable_size,
+    .free = disjoint_pool_free,
+    .get_last_allocation_error = disjoint_pool_get_last_allocation_error,
+    .get_name = disjoint_pool_get_name,
+    .ext_ctl = disjoint_pool_ctl,
+    .ext_trim_memory = disjoint_pool_trim_memory,
+};
+
+const umf_memory_pool_ops_t *umfDisjointPoolOps(void) {
+    return &UMF_DISJOINT_POOL_OPS;
+}
+
+umf_result_t umfDisjointPoolSharedLimitsCreate(
+    size_t max_size, umf_disjoint_pool_shared_limits_t **hSharedLimits) {
+    if (!hSharedLimits) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_disjoint_pool_shared_limits_t *ptr = umf_ba_global_alloc(sizeof(*ptr));
+    if (ptr == NULL) {
+        LOG_ERR("cannot allocate memory for disjoint pool shared limits");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+    ptr->max_size = max_size;
+    ptr->total_size = 0;
+    *hSharedLimits = ptr;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolSharedLimitsDestroy(umf_disjoint_pool_shared_limits_t *limits) {
+    umf_ba_global_free(limits);
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsCreate(umf_disjoint_pool_params_handle_t *hParams) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_disjoint_pool_params_handle_t params =
+        umf_ba_global_alloc(sizeof(*params));
+    if (params == NULL) {
+        LOG_ERR("cannot allocate memory for disjoint pool params");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    *params = default_params;
+
+    *hParams = params;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsDestroy(umf_disjoint_pool_params_handle_t hParams) {
+    // NOTE: dereferencing hParams when BA is already destroyed leads to crash
+    if (hParams && !umf_ba_global_is_destroyed()) {
+        umf_ba_global_free(hParams);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsSetSlabMinSize(umf_disjoint_pool_params_handle_t hParams,
+                                    size_t slabMinSize) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->slab_min_size = slabMinSize;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfDisjointPoolParamsSetMaxPoolableSize(
+    umf_disjoint_pool_params_handle_t hParams, size_t maxPoolableSize) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->max_poolable_size = maxPoolableSize;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsSetCapacity(umf_disjoint_pool_params_handle_t hParams,
+                                 size_t maxCapacity) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->capacity = maxCapacity;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsSetMinBucketSize(umf_disjoint_pool_params_handle_t hParams,
+                                      size_t minBucketSize) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    // minBucketSize parameter must be a power of 2 and greater than 0.
+    if (minBucketSize == 0 || (minBucketSize & (minBucketSize - 1))) {
+        LOG_ERR("minBucketSize must be a power of 2 and greater than 0");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->min_bucket_size = minBucketSize;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsSetTrace(umf_disjoint_pool_params_handle_t hParams,
+                              int poolTrace) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->pool_trace = poolTrace;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfDisjointPoolParamsSetSharedLimits(
+    umf_disjoint_pool_params_handle_t hParams,
+    umf_disjoint_pool_shared_limits_handle_t hSharedLimits) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->shared_limits = hSharedLimits;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsSetName(umf_disjoint_pool_params_handle_t hParams,
+                             const char *name) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    strncpy(hParams->name, name, sizeof(hParams->name) - 1);
+    hParams->name[sizeof(hParams->name) - 1] = '\0';
+    return UMF_RESULT_SUCCESS;
+}
diff --git a/src/pool/pool_disjoint.cpp b/src/pool/pool_disjoint.cpp
deleted file mode 100644
index e0298b43df..0000000000
--- a/src/pool/pool_disjoint.cpp
+++ /dev/null
@@ -1,1313 +0,0 @@
-// Copyright (C) 2023 Intel Corporation
-// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-#include <algorithm>
-#include <array>
-#include <atomic>
-#include <bitset>
-#include <cassert>
-#include <cctype>
-#include <cstring>
-#include <iomanip>
-#include <limits>
-#include <list>
-#include <memory>
-#include <mutex>
-#include <shared_mutex>
-#include <string>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-// TODO: replace with logger?
-#include <iostream>
-
-#include "provider/provider_tracking.h"
-
-#include "../cpp_helpers.hpp"
-#include "pool_disjoint.h"
-#include "umf.h"
-#include "utils_log.h"
-#include "utils_math.h"
-#include "utils_sanitizers.h"
-
-// Temporary solution for disabling memory poisoning. This is needed because
-// AddressSanitizer does not support memory poisoning for GPU allocations.
-// More info: https://github.com/oneapi-src/unified-memory-framework/issues/634
-#ifndef POISON_MEMORY
-#define POISON_MEMORY 0
-#endif
-
-static inline void annotate_memory_inaccessible([[maybe_unused]] void *ptr,
-                                                [[maybe_unused]] size_t size) {
-#if (POISON_MEMORY != 0)
-    utils_annotate_memory_inaccessible(ptr, size);
-#endif
-}
-
-static inline void annotate_memory_undefined([[maybe_unused]] void *ptr,
-                                             [[maybe_unused]] size_t size) {
-#if (POISON_MEMORY != 0)
-    utils_annotate_memory_undefined(ptr, size);
-#endif
-}
-
-typedef struct umf_disjoint_pool_shared_limits_t {
-    size_t MaxSize;
-    std::atomic<size_t> TotalSize;
-} umf_disjoint_pool_shared_limits_t;
-
-// Configuration of Disjoint Pool
-typedef struct umf_disjoint_pool_params_t {
-    // Minimum allocation size that will be requested from the memory provider.
-    size_t SlabMinSize;
-
-    // Allocations up to this limit will be subject to chunking/pooling
-    size_t MaxPoolableSize;
-
-    // When pooling, each bucket will hold a max of 'Capacity' unfreed slabs
-    size_t Capacity;
-
-    // Holds the minimum bucket size valid for allocation of a memory type.
-    // This value must be a power of 2.
-    size_t MinBucketSize;
-
-    // Holds size of the pool managed by the allocator.
-    size_t CurPoolSize;
-
-    // Whether to print pool usage statistics
-    int PoolTrace;
-
-    // Memory limits that can be shared between multitple pool instances,
-    // i.e. if multiple pools use the same SharedLimits sum of those pools'
-    // sizes cannot exceed MaxSize.
-    umf_disjoint_pool_shared_limits_handle_t SharedLimits;
-
-    // Name used in traces
-    char *Name;
-} umf_disjoint_pool_params_t;
-
-class DisjointPool {
-  public:
-    class AllocImpl;
-    using Config = umf_disjoint_pool_params_t;
-
-    umf_result_t initialize(umf_memory_provider_handle_t provider,
-                            umf_disjoint_pool_params_handle_t parameters);
-    void *malloc(size_t size);
-    void *calloc(size_t, size_t);
-    void *realloc(void *, size_t);
-    void *aligned_malloc(size_t size, size_t alignment);
-    size_t malloc_usable_size(void *);
-    umf_result_t free(void *ptr);
-    umf_result_t get_last_allocation_error();
-
-    DisjointPool();
-    ~DisjointPool();
-
-  private:
-    std::unique_ptr<AllocImpl> impl;
-};
-
-umf_disjoint_pool_shared_limits_t *
-umfDisjointPoolSharedLimitsCreate(size_t MaxSize) {
-    return new umf_disjoint_pool_shared_limits_t{MaxSize, 0};
-}
-
-void umfDisjointPoolSharedLimitsDestroy(
-    umf_disjoint_pool_shared_limits_handle_t hSharedLimits) {
-    delete hSharedLimits;
-}
-
-umf_result_t
-umfDisjointPoolParamsCreate(umf_disjoint_pool_params_handle_t *hParams) {
-    static const char *DEFAULT_NAME = "disjoint_pool";
-
-    if (!hParams) {
-        LOG_ERR("disjoint pool params handle is NULL");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    umf_disjoint_pool_params_handle_t params = new umf_disjoint_pool_params_t{};
-    if (params == nullptr) {
-        LOG_ERR("cannot allocate memory for disjoint pool params");
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    params->SlabMinSize = 0;
-    params->MaxPoolableSize = 0;
-    params->Capacity = 0;
-    params->MinBucketSize = UMF_DISJOINT_POOL_MIN_BUCKET_DEFAULT_SIZE;
-    params->CurPoolSize = 0;
-    params->PoolTrace = 0;
-    params->SharedLimits = nullptr;
-    params->Name = nullptr;
-
-    umf_result_t ret = umfDisjointPoolParamsSetName(params, DEFAULT_NAME);
-    if (ret != UMF_RESULT_SUCCESS) {
-        delete params;
-        return ret;
-    }
-
-    *hParams = params;
-
-    return UMF_RESULT_SUCCESS;
-}
-
-umf_result_t
-umfDisjointPoolParamsDestroy(umf_disjoint_pool_params_handle_t hParams) {
-    if (hParams) {
-        delete[] hParams->Name;
-        delete hParams;
-    }
-
-    return UMF_RESULT_SUCCESS;
-}
-
-umf_result_t
-umfDisjointPoolParamsSetSlabMinSize(umf_disjoint_pool_params_handle_t hParams,
-                                    size_t slabMinSize) {
-    if (!hParams) {
-        LOG_ERR("disjoint pool params handle is NULL");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    hParams->SlabMinSize = slabMinSize;
-    return UMF_RESULT_SUCCESS;
-}
-
-umf_result_t umfDisjointPoolParamsSetMaxPoolableSize(
-    umf_disjoint_pool_params_handle_t hParams, size_t maxPoolableSize) {
-    if (!hParams) {
-        LOG_ERR("disjoint pool params handle is NULL");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    hParams->MaxPoolableSize = maxPoolableSize;
-    return UMF_RESULT_SUCCESS;
-}
-
-umf_result_t
-umfDisjointPoolParamsSetCapacity(umf_disjoint_pool_params_handle_t hParams,
-                                 size_t maxCapacity) {
-    if (!hParams) {
-        LOG_ERR("disjoint pool params handle is NULL");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    hParams->Capacity = maxCapacity;
-    return UMF_RESULT_SUCCESS;
-}
-
-umf_result_t
-umfDisjointPoolParamsSetMinBucketSize(umf_disjoint_pool_params_handle_t hParams,
-                                      size_t minBucketSize) {
-    if (!hParams) {
-        LOG_ERR("disjoint pool params handle is NULL");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    // minBucketSize parameter must be a power of 2 and greater than 0.
-    if (minBucketSize == 0 || (minBucketSize & (minBucketSize - 1))) {
-        LOG_ERR("minBucketSize must be a power of 2 and greater than 0");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    hParams->MinBucketSize = minBucketSize;
-    return UMF_RESULT_SUCCESS;
-}
-
-umf_result_t
-umfDisjointPoolParamsSetTrace(umf_disjoint_pool_params_handle_t hParams,
-                              int poolTrace) {
-    if (!hParams) {
-        LOG_ERR("disjoint pool params handle is NULL");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    hParams->PoolTrace = poolTrace;
-    return UMF_RESULT_SUCCESS;
-}
-
-umf_result_t umfDisjointPoolParamsSetSharedLimits(
-    umf_disjoint_pool_params_handle_t hParams,
-    umf_disjoint_pool_shared_limits_handle_t hSharedLimits) {
-    if (!hParams) {
-        LOG_ERR("disjoint pool params handle is NULL");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    hParams->SharedLimits = hSharedLimits;
-    return UMF_RESULT_SUCCESS;
-}
-
-umf_result_t
-umfDisjointPoolParamsSetName(umf_disjoint_pool_params_handle_t hParams,
-                             const char *name) {
-    if (!hParams) {
-        LOG_ERR("disjoint pool params handle is NULL");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    char *newName = new char[std::strlen(name) + 1];
-    if (newName == nullptr) {
-        LOG_ERR("cannot allocate memory for disjoint pool name");
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    delete[] hParams->Name;
-    hParams->Name = newName;
-    std::strcpy(hParams->Name, name);
-
-    return UMF_RESULT_SUCCESS;
-}
-
-// Allocations are a minimum of 4KB/64KB/2MB even when a smaller size is
-// requested. The implementation distinguishes between allocations of size
-// ChunkCutOff = (minimum-alloc-size / 2) and those that are larger.
-// Allocation requests smaller than ChunkCutoff use chunks taken from a single
-// coarse-grain allocation. Thus, for example, for a 64KB minimum allocation
-// size, and 8-byte allocations, only 1 in ~8000 requests results in a new
-// coarse-grain allocation. Freeing results only in a chunk of a larger
-// allocation to be marked as available and no real return to the system. An
-// allocation is returned to the system only when all chunks in the larger
-// allocation are freed by the program. Allocations larger than ChunkCutOff use
-// a separate coarse-grain allocation for each request. These are subject to
-// "pooling". That is, when such an allocation is freed by the program it is
-// retained in a pool. The pool is available for future allocations, which means
-// there are fewer actual coarse-grain allocations/deallocations.
-
-// The largest size which is allocated via the allocator.
-// Allocations with size > CutOff bypass the pool and
-// go directly to the provider.
-static constexpr size_t CutOff = (size_t)1 << 31; // 2GB
-
-// Aligns the pointer down to the specified alignment
-// (e.g. returns 8 for Size = 13, Alignment = 8)
-static void *AlignPtrDown(void *Ptr, const size_t Alignment) {
-    return reinterpret_cast<void *>((reinterpret_cast<size_t>(Ptr)) &
-                                    (~(Alignment - 1)));
-}
-
-// Aligns the pointer up to the specified alignment
-// (e.g. returns 16 for Size = 13, Alignment = 8)
-static void *AlignPtrUp(void *Ptr, const size_t Alignment) {
-    void *AlignedPtr = AlignPtrDown(Ptr, Alignment);
-    // Special case when the pointer is already aligned
-    if (Ptr == AlignedPtr) {
-        return Ptr;
-    }
-    return static_cast<char *>(AlignedPtr) + Alignment;
-}
-
-// Aligns the value up to the specified alignment
-// (e.g. returns 16 for Size = 13, Alignment = 8)
-static size_t AlignUp(size_t Val, size_t Alignment) {
-    assert(Alignment > 0);
-    return (Val + Alignment - 1) & (~(Alignment - 1));
-}
-
-typedef struct MemoryProviderError {
-    umf_result_t code;
-} MemoryProviderError_t;
-
-class Bucket;
-
-// Represents the allocated memory block of size 'SlabMinSize'
-// Internally, it splits the memory block into chunks. The number of
-// chunks depends of the size of a Bucket which created the Slab.
-// Note: Bucket's methods are responsible for thread safety of Slab access,
-// so no locking happens here.
-class Slab {
-
-    // Pointer to the allocated memory of SlabMinSize bytes
-    void *MemPtr;
-
-    // Represents the current state of each chunk:
-    // if the bit is set then the chunk is allocated
-    // the chunk is free for allocation otherwise
-    std::vector<bool> Chunks;
-
-    // Total number of allocated chunks at the moment.
-    size_t NumAllocated = 0;
-
-    // The bucket which the slab belongs to
-    Bucket &bucket;
-
-    using ListIter = std::list<std::unique_ptr<Slab>>::iterator;
-
-    // Store iterator to the corresponding node in avail/unavail list
-    // to achieve O(1) removal
-    ListIter SlabListIter;
-
-    // Hints where to start search for free chunk in a slab
-    size_t FirstFreeChunkIdx = 0;
-
-    // Return the index of the first available chunk, SIZE_MAX otherwise
-    size_t FindFirstAvailableChunkIdx() const;
-
-    // Register/Unregister the slab in the global slab address map.
-    void regSlab(Slab &);
-    void unregSlab(Slab &);
-    static void regSlabByAddr(void *, Slab &);
-    static void unregSlabByAddr(void *, Slab &);
-
-  public:
-    Slab(Bucket &);
-    ~Slab();
-
-    void setIterator(ListIter It) { SlabListIter = It; }
-    ListIter getIterator() const { return SlabListIter; }
-
-    size_t getNumAllocated() const { return NumAllocated; }
-
-    // Get pointer to allocation that is one piece of this slab.
-    void *getChunk();
-
-    // Get pointer to allocation that is this entire slab.
-    void *getSlab();
-
-    void *getPtr() const { return MemPtr; }
-    void *getEnd() const;
-
-    size_t getChunkSize() const;
-    size_t getNumChunks() const { return Chunks.size(); }
-
-    bool hasAvail();
-
-    Bucket &getBucket();
-    const Bucket &getBucket() const;
-
-    void freeChunk(void *Ptr);
-};
-
-class Bucket {
-    const size_t Size;
-
-    // List of slabs which have at least 1 available chunk.
-    std::list<std::unique_ptr<Slab>> AvailableSlabs;
-
-    // List of slabs with 0 available chunk.
-    std::list<std::unique_ptr<Slab>> UnavailableSlabs;
-
-    // Protects the bucket and all the corresponding slabs
-    std::mutex BucketLock;
-
-    // Reference to the allocator context, used access memory allocation
-    // routines, slab map and etc.
-    DisjointPool::AllocImpl &OwnAllocCtx;
-
-    // For buckets used in chunked mode, a counter of slabs in the pool.
-    // For allocations that use an entire slab each, the entries in the Available
-    // list are entries in the pool.Each slab is available for a new
-    // allocation.The size of the Available list is the size of the pool.
-    // For allocations that use slabs in chunked mode, slabs will be in the
-    // Available list if any one or more of their chunks is free.The entire slab
-    // is not necessarily free, just some chunks in the slab are free. To
-    // implement pooling we will allow one slab in the Available list to be
-    // entirely empty. Normally such a slab would have been freed. But
-    // now we don't, and treat this slab as "in the pool".
-    // When a slab becomes entirely free we have to decide whether to return it
-    // to the provider or keep it allocated. A simple check for size of the
-    // Available list is not sufficient to check whether any slab has been
-    // pooled yet. We would have to traverse the entire Available list and check
-    // if any of them is entirely free. Instead we keep a counter of entirely
-    // empty slabs within the Available list to speed up the process of checking
-    // if a slab in this bucket is already pooled.
-    size_t chunkedSlabsInPool;
-
-    // Statistics
-    size_t allocPoolCount;
-    size_t freeCount;
-    size_t currSlabsInUse;
-    size_t currSlabsInPool;
-    size_t maxSlabsInPool;
-
-  public:
-    // Statistics
-    size_t allocCount;
-    size_t maxSlabsInUse;
-
-    Bucket(size_t Sz, DisjointPool::AllocImpl &AllocCtx)
-        : Size{Sz}, OwnAllocCtx{AllocCtx}, chunkedSlabsInPool(0),
-          allocPoolCount(0), freeCount(0), currSlabsInUse(0),
-          currSlabsInPool(0), maxSlabsInPool(0), allocCount(0),
-          maxSlabsInUse(0) {}
-
-    // Get pointer to allocation that is one piece of an available slab in this
-    // bucket.
-    void *getChunk(bool &FromPool);
-
-    // Get pointer to allocation that is a full slab in this bucket.
-    void *getSlab(bool &FromPool);
-
-    // Return the allocation size of this bucket.
-    size_t getSize() const { return Size; }
-
-    // Free an allocation that is one piece of a slab in this bucket.
-    void freeChunk(void *Ptr, Slab &Slab, bool &ToPool);
-
-    // Free an allocation that is a full slab in this bucket.
-    void freeSlab(Slab &Slab, bool &ToPool);
-
-    umf_memory_provider_handle_t getMemHandle();
-
-    DisjointPool::AllocImpl &getAllocCtx() { return OwnAllocCtx; }
-
-    // Check whether an allocation to be freed can be placed in the pool.
-    bool CanPool(bool &ToPool);
-
-    // The minimum allocation size for any slab.
-    size_t SlabMinSize();
-
-    // The allocation size for a slab in this bucket.
-    size_t SlabAllocSize();
-
-    // The minimum size of a chunk from this bucket's slabs.
-    size_t ChunkCutOff();
-
-    // The number of slabs in this bucket that can be in the pool.
-    size_t Capacity();
-
-    // The maximum allocation size subject to pooling.
-    size_t MaxPoolableSize();
-
-    // Update allocation count
-    void countAlloc(bool FromPool);
-
-    // Update free count
-    void countFree();
-
-    // Update statistics of Available/Unavailable
-    void updateStats(int InUse, int InPool);
-
-    // Print bucket statistics
-    void printStats(bool &TitlePrinted, const std::string &Label);
-
-  private:
-    void onFreeChunk(Slab &, bool &ToPool);
-
-    // Update statistics of pool usage, and indicate that an allocation was made
-    // from the pool.
-    void decrementPool(bool &FromPool);
-
-    // Get a slab to be used for chunked allocations.
-    decltype(AvailableSlabs.begin()) getAvailSlab(bool &FromPool);
-
-    // Get a slab that will be used as a whole for a single allocation.
-    decltype(AvailableSlabs.begin()) getAvailFullSlab(bool &FromPool);
-};
-
-class DisjointPool::AllocImpl {
-    // It's important for the map to be destroyed last after buckets and their
-    // slabs This is because slab's destructor removes the object from the map.
-    std::unordered_multimap<void *, Slab &> KnownSlabs;
-    std::shared_timed_mutex KnownSlabsMapLock;
-
-    // Handle to the memory provider
-    umf_memory_provider_handle_t MemHandle;
-
-    // Store as unique_ptrs since Bucket is not Movable(because of std::mutex)
-    std::vector<std::unique_ptr<Bucket>> Buckets;
-
-    // Configuration for this instance
-    umf_disjoint_pool_params_t params;
-
-    umf_disjoint_pool_shared_limits_t DefaultSharedLimits = {
-        (std::numeric_limits<size_t>::max)(), 0};
-
-    // Used in algorithm for finding buckets
-    std::size_t MinBucketSizeExp;
-
-    // Coarse-grain allocation min alignment
-    size_t ProviderMinPageSize;
-
-  public:
-    AllocImpl(umf_memory_provider_handle_t hProvider,
-              umf_disjoint_pool_params_handle_t params)
-        : MemHandle{hProvider}, params(*params) {
-
-        VALGRIND_DO_CREATE_MEMPOOL(this, 0, 0);
-
-        // deep copy of the Name
-        this->params.Name = new char[std::strlen(params->Name) + 1];
-        std::strcpy(this->params.Name, params->Name);
-
-        // Generate buckets sized such as: 64, 96, 128, 192, ..., CutOff.
-        // Powers of 2 and the value halfway between the powers of 2.
-        auto Size1 = this->params.MinBucketSize;
-        // MinBucketSize cannot be larger than CutOff.
-        Size1 = std::min(Size1, CutOff);
-        // Buckets sized smaller than the bucket default size- 8 aren't needed.
-        Size1 = std::max(Size1, UMF_DISJOINT_POOL_MIN_BUCKET_DEFAULT_SIZE);
-        // Calculate the exponent for MinBucketSize used for finding buckets.
-        MinBucketSizeExp = (size_t)log2Utils(Size1);
-        auto Size2 = Size1 + Size1 / 2;
-        for (; Size2 < CutOff; Size1 *= 2, Size2 *= 2) {
-            Buckets.push_back(std::make_unique<Bucket>(Size1, *this));
-            Buckets.push_back(std::make_unique<Bucket>(Size2, *this));
-        }
-        Buckets.push_back(std::make_unique<Bucket>(CutOff, *this));
-
-        auto ret = umfMemoryProviderGetMinPageSize(hProvider, nullptr,
-                                                   &ProviderMinPageSize);
-        if (ret != UMF_RESULT_SUCCESS) {
-            ProviderMinPageSize = 0;
-        }
-    }
-
-    ~AllocImpl() {
-        VALGRIND_DO_DESTROY_MEMPOOL(this);
-        delete[] this->params.Name;
-    }
-
-    void *allocate(size_t Size, size_t Alignment, bool &FromPool);
-    void *allocate(size_t Size, bool &FromPool);
-    void deallocate(void *Ptr, bool &ToPool);
-
-    umf_memory_provider_handle_t getMemHandle() { return MemHandle; }
-
-    std::shared_timed_mutex &getKnownSlabsMapLock() {
-        return KnownSlabsMapLock;
-    }
-    std::unordered_multimap<void *, Slab &> &getKnownSlabs() {
-        return KnownSlabs;
-    }
-
-    size_t SlabMinSize() { return params.SlabMinSize; };
-
-    umf_disjoint_pool_params_t &getParams() { return params; }
-
-    umf_disjoint_pool_shared_limits_t *getLimits() {
-        if (params.SharedLimits) {
-            return params.SharedLimits;
-        } else {
-            return &DefaultSharedLimits;
-        }
-    };
-
-    void printStats(bool &TitlePrinted, size_t &HighBucketSize,
-                    size_t &HighPeakSlabsInUse, const std::string &Label);
-
-  private:
-    Bucket &findBucket(size_t Size);
-    std::size_t sizeToIdx(size_t Size);
-};
-
-static void *memoryProviderAlloc(umf_memory_provider_handle_t hProvider,
-                                 size_t size, size_t alignment = 0) {
-    void *ptr;
-    auto ret = umfMemoryProviderAlloc(hProvider, size, alignment, &ptr);
-    if (ret != UMF_RESULT_SUCCESS) {
-        throw MemoryProviderError{ret};
-    }
-    annotate_memory_inaccessible(ptr, size);
-    return ptr;
-}
-
-static void memoryProviderFree(umf_memory_provider_handle_t hProvider,
-                               void *ptr) {
-    size_t size = 0;
-
-    if (ptr) {
-        umf_alloc_info_t allocInfo = {NULL, 0, NULL};
-        umf_result_t umf_result = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
-        if (umf_result == UMF_RESULT_SUCCESS) {
-            size = allocInfo.baseSize;
-        }
-    }
-
-    auto ret = umfMemoryProviderFree(hProvider, ptr, size);
-    if (ret != UMF_RESULT_SUCCESS) {
-        throw MemoryProviderError{ret};
-    }
-}
-
-bool operator==(const Slab &Lhs, const Slab &Rhs) {
-    return Lhs.getPtr() == Rhs.getPtr();
-}
-
-std::ostream &operator<<(std::ostream &Os, const Slab &Slab) {
-    Os << "Slab<" << Slab.getPtr() << ", " << Slab.getEnd() << ", "
-       << Slab.getBucket().getSize() << ">";
-    return Os;
-}
-
-Slab::Slab(Bucket &Bkt)
-    : // In case bucket size is not a multiple of SlabMinSize, we would have
-      // some padding at the end of the slab.
-      Chunks(Bkt.SlabMinSize() / Bkt.getSize()), NumAllocated{0},
-      bucket(Bkt), SlabListIter{}, FirstFreeChunkIdx{0} {
-    auto SlabSize = Bkt.SlabAllocSize();
-    MemPtr = memoryProviderAlloc(Bkt.getMemHandle(), SlabSize);
-    regSlab(*this);
-}
-
-Slab::~Slab() {
-    try {
-        unregSlab(*this);
-    } catch (std::exception &e) {
-        LOG_ERR("DisjointPool: unexpected error: %s", e.what());
-    }
-
-    try {
-        memoryProviderFree(bucket.getMemHandle(), MemPtr);
-    } catch (MemoryProviderError &e) {
-        LOG_ERR("DisjointPool: error from memory provider: %d", e.code);
-
-        if (e.code == UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC) {
-            const char *message = "";
-            int error = 0;
-
-            try {
-                umfMemoryProviderGetLastNativeError(
-                    umfGetLastFailedMemoryProvider(), &message, &error);
-                LOG_ERR("Native error msg: %s, native error code: %d", message,
-                        error);
-            } catch (...) {
-                // ignore any additional errors from logger
-            }
-        }
-    }
-}
-
-// Return the index of the first available chunk, SIZE_MAX otherwise
-size_t Slab::FindFirstAvailableChunkIdx() const {
-    // Use the first free chunk index as a hint for the search.
-    auto It = std::find_if(Chunks.begin() + FirstFreeChunkIdx, Chunks.end(),
-                           [](auto x) { return !x; });
-    if (It != Chunks.end()) {
-        return It - Chunks.begin();
-    }
-
-    return std::numeric_limits<size_t>::max();
-}
-
-void *Slab::getChunk() {
-    // assert(NumAllocated != Chunks.size());
-
-    const size_t ChunkIdx = FindFirstAvailableChunkIdx();
-    // Free chunk must exist, otherwise we would have allocated another slab
-    assert(ChunkIdx != (std::numeric_limits<size_t>::max()));
-
-    void *const FreeChunk =
-        (static_cast<uint8_t *>(getPtr())) + ChunkIdx * getChunkSize();
-    Chunks[ChunkIdx] = true;
-    NumAllocated += 1;
-
-    // Use the found index as the next hint
-    FirstFreeChunkIdx = ChunkIdx;
-
-    return FreeChunk;
-}
-
-void *Slab::getSlab() { return getPtr(); }
-
-Bucket &Slab::getBucket() { return bucket; }
-const Bucket &Slab::getBucket() const { return bucket; }
-
-size_t Slab::getChunkSize() const { return bucket.getSize(); }
-
-void Slab::regSlabByAddr(void *Addr, Slab &Slab) {
-    auto &Lock = Slab.getBucket().getAllocCtx().getKnownSlabsMapLock();
-    auto &Map = Slab.getBucket().getAllocCtx().getKnownSlabs();
-
-    std::lock_guard<std::shared_timed_mutex> Lg(Lock);
-    Map.insert({Addr, Slab});
-}
-
-void Slab::unregSlabByAddr(void *Addr, Slab &Slab) {
-    auto &Lock = Slab.getBucket().getAllocCtx().getKnownSlabsMapLock();
-    auto &Map = Slab.getBucket().getAllocCtx().getKnownSlabs();
-
-    std::lock_guard<std::shared_timed_mutex> Lg(Lock);
-
-    auto Slabs = Map.equal_range(Addr);
-    // At least the must get the current slab from the map.
-    assert(Slabs.first != Slabs.second && "Slab is not found");
-
-    for (auto It = Slabs.first; It != Slabs.second; ++It) {
-        if (It->second == Slab) {
-            Map.erase(It);
-            return;
-        }
-    }
-
-    assert(false && "Slab is not found");
-}
-
-void Slab::regSlab(Slab &Slab) {
-    void *StartAddr = AlignPtrDown(Slab.getPtr(), bucket.SlabMinSize());
-    void *EndAddr = static_cast<char *>(StartAddr) + bucket.SlabMinSize();
-
-    regSlabByAddr(StartAddr, Slab);
-    regSlabByAddr(EndAddr, Slab);
-}
-
-void Slab::unregSlab(Slab &Slab) {
-    void *StartAddr = AlignPtrDown(Slab.getPtr(), bucket.SlabMinSize());
-    void *EndAddr = static_cast<char *>(StartAddr) + bucket.SlabMinSize();
-
-    unregSlabByAddr(StartAddr, Slab);
-    unregSlabByAddr(EndAddr, Slab);
-}
-
-void Slab::freeChunk(void *Ptr) {
-    // This method should be called through bucket(since we might remove the slab
-    // as a result), therefore all locks are done on that level.
-
-    // Make sure that we're in the right slab
-    assert(Ptr >= getPtr() && Ptr < getEnd());
-
-    // Even if the pointer p was previously aligned, it's still inside the
-    // corresponding chunk, so we get the correct index here.
-    auto ChunkIdx = (static_cast<char *>(Ptr) - static_cast<char *>(MemPtr)) /
-                    getChunkSize();
-
-    // Make sure that the chunk was allocated
-    assert(Chunks[ChunkIdx] && "double free detected");
-
-    Chunks[ChunkIdx] = false;
-    NumAllocated -= 1;
-
-    if (ChunkIdx < FirstFreeChunkIdx) {
-        FirstFreeChunkIdx = ChunkIdx;
-    }
-}
-
-void *Slab::getEnd() const {
-    return static_cast<char *>(getPtr()) + bucket.SlabMinSize();
-}
-
-bool Slab::hasAvail() { return NumAllocated != getNumChunks(); }
-
-// If a slab was available in the pool then note that the current pooled
-// size has reduced by the size of a slab in this bucket.
-void Bucket::decrementPool(bool &FromPool) {
-    FromPool = true;
-    updateStats(1, -1);
-    OwnAllocCtx.getLimits()->TotalSize -= SlabAllocSize();
-}
-
-auto Bucket::getAvailFullSlab(bool &FromPool)
-    -> decltype(AvailableSlabs.begin()) {
-    // Return a slab that will be used for a single allocation.
-    if (AvailableSlabs.size() == 0) {
-        auto It = AvailableSlabs.insert(AvailableSlabs.begin(),
-                                        std::make_unique<Slab>(*this));
-        (*It)->setIterator(It);
-        FromPool = false;
-        updateStats(1, 0);
-    } else {
-        decrementPool(FromPool);
-    }
-
-    return AvailableSlabs.begin();
-}
-
-void *Bucket::getSlab(bool &FromPool) {
-    std::lock_guard<std::mutex> Lg(BucketLock);
-
-    auto SlabIt = getAvailFullSlab(FromPool);
-    auto *FreeSlab = (*SlabIt)->getSlab();
-    auto It =
-        UnavailableSlabs.insert(UnavailableSlabs.begin(), std::move(*SlabIt));
-    AvailableSlabs.erase(SlabIt);
-    (*It)->setIterator(It);
-    return FreeSlab;
-}
-
-void Bucket::freeSlab(Slab &Slab, bool &ToPool) {
-    std::lock_guard<std::mutex> Lg(BucketLock);
-    auto SlabIter = Slab.getIterator();
-    assert(SlabIter != UnavailableSlabs.end());
-    if (CanPool(ToPool)) {
-        auto It =
-            AvailableSlabs.insert(AvailableSlabs.begin(), std::move(*SlabIter));
-        UnavailableSlabs.erase(SlabIter);
-        (*It)->setIterator(It);
-    } else {
-        UnavailableSlabs.erase(SlabIter);
-    }
-}
-
-auto Bucket::getAvailSlab(bool &FromPool) -> decltype(AvailableSlabs.begin()) {
-
-    if (AvailableSlabs.size() == 0) {
-        auto It = AvailableSlabs.insert(AvailableSlabs.begin(),
-                                        std::make_unique<Slab>(*this));
-        (*It)->setIterator(It);
-
-        updateStats(1, 0);
-        FromPool = false;
-    } else {
-        if ((*(AvailableSlabs.begin()))->getNumAllocated() == 0) {
-            // If this was an empty slab, it was in the pool.
-            // Now it is no longer in the pool, so update count.
-            --chunkedSlabsInPool;
-            decrementPool(FromPool);
-        } else {
-            // Allocation from existing slab is treated as from pool for statistics.
-            FromPool = true;
-        }
-    }
-
-    return AvailableSlabs.begin();
-}
-
-void *Bucket::getChunk(bool &FromPool) {
-    std::lock_guard<std::mutex> Lg(BucketLock);
-
-    auto SlabIt = getAvailSlab(FromPool);
-    auto *FreeChunk = (*SlabIt)->getChunk();
-
-    // If the slab is full, move it to unavailable slabs and update its iterator
-    if (!((*SlabIt)->hasAvail())) {
-        auto It = UnavailableSlabs.insert(UnavailableSlabs.begin(),
-                                          std::move(*SlabIt));
-        AvailableSlabs.erase(SlabIt);
-        (*It)->setIterator(It);
-    }
-
-    return FreeChunk;
-}
-
-void Bucket::freeChunk(void *Ptr, Slab &Slab, bool &ToPool) {
-    std::lock_guard<std::mutex> Lg(BucketLock);
-
-    Slab.freeChunk(Ptr);
-
-    onFreeChunk(Slab, ToPool);
-}
-
-// The lock must be acquired before calling this method
-void Bucket::onFreeChunk(Slab &Slab, bool &ToPool) {
-    ToPool = true;
-
-    // In case if the slab was previously full and now has 1 available
-    // chunk, it should be moved to the list of available slabs
-    if (Slab.getNumAllocated() == (Slab.getNumChunks() - 1)) {
-        auto SlabIter = Slab.getIterator();
-        assert(SlabIter != UnavailableSlabs.end());
-
-        auto It =
-            AvailableSlabs.insert(AvailableSlabs.begin(), std::move(*SlabIter));
-        UnavailableSlabs.erase(SlabIter);
-
-        (*It)->setIterator(It);
-    }
-
-    // Check if slab is empty, and pool it if we can.
-    if (Slab.getNumAllocated() == 0) {
-        // The slab is now empty.
-        // If pool has capacity then put the slab in the pool.
-        // The ToPool parameter indicates whether the Slab will be put in the
-        // pool or freed.
-        if (!CanPool(ToPool)) {
-            // Note: since the slab is stored as unique_ptr, just remove it from
-            // the list to destroy the object.
-            auto It = Slab.getIterator();
-            assert(It != AvailableSlabs.end());
-            AvailableSlabs.erase(It);
-        }
-    }
-}
-
-bool Bucket::CanPool(bool &ToPool) {
-    size_t NewFreeSlabsInBucket;
-    // Check if this bucket is used in chunked form or as full slabs.
-    bool chunkedBucket = getSize() <= ChunkCutOff();
-    if (chunkedBucket) {
-        NewFreeSlabsInBucket = chunkedSlabsInPool + 1;
-    } else {
-        NewFreeSlabsInBucket = AvailableSlabs.size() + 1;
-    }
-    if (Capacity() >= NewFreeSlabsInBucket) {
-        size_t PoolSize = OwnAllocCtx.getLimits()->TotalSize;
-        while (true) {
-            size_t NewPoolSize = PoolSize + SlabAllocSize();
-
-            if (OwnAllocCtx.getLimits()->MaxSize < NewPoolSize) {
-                break;
-            }
-
-            if (OwnAllocCtx.getLimits()->TotalSize.compare_exchange_strong(
-                    PoolSize, NewPoolSize)) {
-                if (chunkedBucket) {
-                    ++chunkedSlabsInPool;
-                }
-
-                updateStats(-1, 1);
-                ToPool = true;
-                return true;
-            }
-        }
-    }
-
-    updateStats(-1, 0);
-    ToPool = false;
-    return false;
-}
-
-umf_memory_provider_handle_t Bucket::getMemHandle() {
-    return OwnAllocCtx.getMemHandle();
-}
-
-size_t Bucket::SlabMinSize() { return OwnAllocCtx.getParams().SlabMinSize; }
-
-size_t Bucket::SlabAllocSize() { return std::max(getSize(), SlabMinSize()); }
-
-size_t Bucket::Capacity() {
-    // For buckets used in chunked mode, just one slab in pool is sufficient.
-    // For larger buckets, the capacity could be more and is adjustable.
-    if (getSize() <= ChunkCutOff()) {
-        return 1;
-    } else {
-        return OwnAllocCtx.getParams().Capacity;
-    }
-}
-
-size_t Bucket::MaxPoolableSize() {
-    return OwnAllocCtx.getParams().MaxPoolableSize;
-}
-
-size_t Bucket::ChunkCutOff() { return SlabMinSize() / 2; }
-
-void Bucket::countAlloc(bool FromPool) {
-    ++allocCount;
-    if (FromPool) {
-        ++allocPoolCount;
-    }
-}
-
-void Bucket::countFree() { ++freeCount; }
-
-void Bucket::updateStats(int InUse, int InPool) {
-    if (OwnAllocCtx.getParams().PoolTrace == 0) {
-        return;
-    }
-    currSlabsInUse += InUse;
-    maxSlabsInUse = std::max(currSlabsInUse, maxSlabsInUse);
-    currSlabsInPool += InPool;
-    maxSlabsInPool = std::max(currSlabsInPool, maxSlabsInPool);
-    // Increment or decrement current pool sizes based on whether
-    // slab was added to or removed from pool.
-    OwnAllocCtx.getParams().CurPoolSize += InPool * SlabAllocSize();
-}
-
-void Bucket::printStats(bool &TitlePrinted, const std::string &Label) {
-    if (allocCount) {
-        if (!TitlePrinted) {
-            std::cout << Label << " memory statistics\n";
-            std::cout << std::setw(14) << "Bucket Size" << std::setw(12)
-                      << "Allocs" << std::setw(12) << "Frees" << std::setw(18)
-                      << "Allocs from Pool" << std::setw(20)
-                      << "Peak Slabs in Use" << std::setw(21)
-                      << "Peak Slabs in Pool" << std::endl;
-            TitlePrinted = true;
-        }
-        std::cout << std::setw(14) << getSize() << std::setw(12) << allocCount
-                  << std::setw(12) << freeCount << std::setw(18)
-                  << allocPoolCount << std::setw(20) << maxSlabsInUse
-                  << std::setw(21) << maxSlabsInPool << std::endl;
-    }
-}
-
-void *DisjointPool::AllocImpl::allocate(size_t Size, bool &FromPool) try {
-    void *Ptr;
-
-    if (Size == 0) {
-        return nullptr;
-    }
-
-    FromPool = false;
-    if (Size > getParams().MaxPoolableSize) {
-        Ptr = memoryProviderAlloc(getMemHandle(), Size);
-        annotate_memory_undefined(Ptr, Size);
-        return Ptr;
-    }
-
-    auto &Bucket = findBucket(Size);
-
-    if (Size > Bucket.ChunkCutOff()) {
-        Ptr = Bucket.getSlab(FromPool);
-    } else {
-        Ptr = Bucket.getChunk(FromPool);
-    }
-
-    if (getParams().PoolTrace > 1) {
-        Bucket.countAlloc(FromPool);
-    }
-
-    VALGRIND_DO_MEMPOOL_ALLOC(this, Ptr, Size);
-    annotate_memory_undefined(Ptr, Bucket.getSize());
-
-    return Ptr;
-} catch (MemoryProviderError &e) {
-    umf::getPoolLastStatusRef<DisjointPool>() = e.code;
-    return nullptr;
-}
-
-void *DisjointPool::AllocImpl::allocate(size_t Size, size_t Alignment,
-                                        bool &FromPool) try {
-    void *Ptr;
-
-    if (Size == 0) {
-        return nullptr;
-    }
-
-    if (Alignment <= 1) {
-        return allocate(Size, FromPool);
-    }
-
-    size_t AlignedSize;
-    if (Alignment <= ProviderMinPageSize) {
-        // This allocation will be served from a Bucket which size is multiple
-        // of Alignment and Slab address is aligned to ProviderMinPageSize
-        // so the address will be properly aligned.
-        AlignedSize = (Size > 1) ? AlignUp(Size, Alignment) : Alignment;
-    } else {
-        // Slabs are only aligned to ProviderMinPageSize, we need to compensate
-        // for that in case the allocation is within pooling limit.
-        // TODO: consider creating properly-aligned Slabs on demand
-        AlignedSize = Size + Alignment - 1;
-    }
-
-    // Check if requested allocation size is within pooling limit.
-    // If not, just request aligned pointer from the system.
-    FromPool = false;
-    if (AlignedSize > getParams().MaxPoolableSize) {
-        Ptr = memoryProviderAlloc(getMemHandle(), Size, Alignment);
-        annotate_memory_undefined(Ptr, Size);
-        return Ptr;
-    }
-
-    auto &Bucket = findBucket(AlignedSize);
-
-    if (AlignedSize > Bucket.ChunkCutOff()) {
-        Ptr = Bucket.getSlab(FromPool);
-    } else {
-        Ptr = Bucket.getChunk(FromPool);
-    }
-
-    if (getParams().PoolTrace > 1) {
-        Bucket.countAlloc(FromPool);
-    }
-
-    VALGRIND_DO_MEMPOOL_ALLOC(this, AlignPtrUp(Ptr, Alignment), Size);
-    annotate_memory_undefined(AlignPtrUp(Ptr, Alignment), Size);
-    return AlignPtrUp(Ptr, Alignment);
-} catch (MemoryProviderError &e) {
-    umf::getPoolLastStatusRef<DisjointPool>() = e.code;
-    return nullptr;
-}
-
-std::size_t DisjointPool::AllocImpl::sizeToIdx(size_t Size) {
-    assert(Size <= CutOff && "Unexpected size");
-    assert(Size > 0 && "Unexpected size");
-
-    size_t MinBucketSize = (size_t)1 << MinBucketSizeExp;
-    if (Size < MinBucketSize) {
-        return 0;
-    }
-
-    // Get the position of the leftmost set bit.
-    size_t position = getLeftmostSetBitPos(Size);
-
-    auto isPowerOf2 = 0 == (Size & (Size - 1));
-    auto largerThanHalfwayBetweenPowersOf2 =
-        !isPowerOf2 && bool((Size - 1) & (uint64_t(1) << (position - 1)));
-    auto index = (position - MinBucketSizeExp) * 2 + (int)(!isPowerOf2) +
-                 (int)largerThanHalfwayBetweenPowersOf2;
-
-    return index;
-}
-
-Bucket &DisjointPool::AllocImpl::findBucket(size_t Size) {
-    auto calculatedIdx = sizeToIdx(Size);
-    assert((*(Buckets[calculatedIdx])).getSize() >= Size);
-    if (calculatedIdx > 0) {
-        assert((*(Buckets[calculatedIdx - 1])).getSize() < Size);
-    }
-
-    return *(Buckets[calculatedIdx]);
-}
-
-void DisjointPool::AllocImpl::deallocate(void *Ptr, bool &ToPool) {
-    auto *SlabPtr = AlignPtrDown(Ptr, SlabMinSize());
-
-    // Lock the map on read
-    std::shared_lock<std::shared_timed_mutex> Lk(getKnownSlabsMapLock());
-
-    ToPool = false;
-    auto Slabs = getKnownSlabs().equal_range(SlabPtr);
-    if (Slabs.first == Slabs.second) {
-        Lk.unlock();
-        memoryProviderFree(getMemHandle(), Ptr);
-        return;
-    }
-
-    for (auto It = Slabs.first; It != Slabs.second; ++It) {
-        // The slab object won't be deleted until it's removed from the map which is
-        // protected by the lock, so it's safe to access it here.
-        auto &Slab = It->second;
-        if (Ptr >= Slab.getPtr() && Ptr < Slab.getEnd()) {
-            // Unlock the map before freeing the chunk, it may be locked on write
-            // there
-            Lk.unlock();
-            auto &Bucket = Slab.getBucket();
-
-            if (getParams().PoolTrace > 1) {
-                Bucket.countFree();
-            }
-
-            VALGRIND_DO_MEMPOOL_FREE(this, Ptr);
-            annotate_memory_inaccessible(Ptr, Bucket.getSize());
-            if (Bucket.getSize() <= Bucket.ChunkCutOff()) {
-                Bucket.freeChunk(Ptr, Slab, ToPool);
-            } else {
-                Bucket.freeSlab(Slab, ToPool);
-            }
-
-            return;
-        }
-    }
-
-    Lk.unlock();
-    // There is a rare case when we have a pointer from system allocation next
-    // to some slab with an entry in the map. So we find a slab
-    // but the range checks fail.
-    memoryProviderFree(getMemHandle(), Ptr);
-}
-
-void DisjointPool::AllocImpl::printStats(bool &TitlePrinted,
-                                         size_t &HighBucketSize,
-                                         size_t &HighPeakSlabsInUse,
-                                         const std::string &MTName) {
-    HighBucketSize = 0;
-    HighPeakSlabsInUse = 0;
-    for (auto &B : Buckets) {
-        (*B).printStats(TitlePrinted, MTName);
-        HighPeakSlabsInUse = std::max((*B).maxSlabsInUse, HighPeakSlabsInUse);
-        if ((*B).allocCount) {
-            HighBucketSize = std::max((*B).SlabAllocSize(), HighBucketSize);
-        }
-    }
-}
-
-umf_result_t
-DisjointPool::initialize(umf_memory_provider_handle_t provider,
-                         umf_disjoint_pool_params_handle_t parameters) {
-    if (!provider) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-    // MinBucketSize parameter must be a power of 2 for bucket sizes
-    // to generate correctly.
-    if (!parameters->MinBucketSize ||
-        !((parameters->MinBucketSize & (parameters->MinBucketSize - 1)) == 0)) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    impl = std::make_unique<AllocImpl>(provider, parameters);
-    return UMF_RESULT_SUCCESS;
-}
-
-void *DisjointPool::malloc(size_t size) { // For full-slab allocations indicates
-                                          // whether slab is from Pool.
-    bool FromPool;
-    auto Ptr = impl->allocate(size, FromPool);
-
-    if (impl->getParams().PoolTrace > 2) {
-        auto MT = impl->getParams().Name;
-        std::cout << "Allocated " << std::setw(8) << size << " " << MT
-                  << " bytes from " << (FromPool ? "Pool" : "Provider") << " ->"
-                  << Ptr << std::endl;
-    }
-    return Ptr;
-}
-
-void *DisjointPool::calloc(size_t, size_t) {
-    // Not supported
-    umf::getPoolLastStatusRef<DisjointPool>() = UMF_RESULT_ERROR_NOT_SUPPORTED;
-    return NULL;
-}
-
-void *DisjointPool::realloc(void *, size_t) {
-    // Not supported
-    umf::getPoolLastStatusRef<DisjointPool>() = UMF_RESULT_ERROR_NOT_SUPPORTED;
-    return NULL;
-}
-
-void *DisjointPool::aligned_malloc(size_t size, size_t alignment) {
-    bool FromPool;
-    auto Ptr = impl->allocate(size, alignment, FromPool);
-
-    if (impl->getParams().PoolTrace > 2) {
-        auto MT = impl->getParams().Name;
-        std::cout << "Allocated " << std::setw(8) << size << " " << MT
-                  << " bytes aligned at " << alignment << " from "
-                  << (FromPool ? "Pool" : "Provider") << " ->" << Ptr
-                  << std::endl;
-    }
-    return Ptr;
-}
-
-size_t DisjointPool::malloc_usable_size(void *) {
-    // Not supported
-    return 0;
-}
-
-umf_result_t DisjointPool::free(void *ptr) try {
-    bool ToPool;
-    impl->deallocate(ptr, ToPool);
-
-    if (impl->getParams().PoolTrace > 2) {
-        auto MT = impl->getParams().Name;
-        std::cout << "Freed " << MT << " " << ptr << " to "
-                  << (ToPool ? "Pool" : "Provider")
-                  << ", Current total pool size "
-                  << impl->getLimits()->TotalSize.load()
-                  << ", Current pool size for " << MT << " "
-                  << impl->getParams().CurPoolSize << "\n";
-    }
-    return UMF_RESULT_SUCCESS;
-} catch (MemoryProviderError &e) {
-    return e.code;
-}
-
-umf_result_t DisjointPool::get_last_allocation_error() {
-    return umf::getPoolLastStatusRef<DisjointPool>();
-}
-
-DisjointPool::DisjointPool() {}
-
-// Define destructor for use with unique_ptr
-DisjointPool::~DisjointPool() {
-    bool TitlePrinted = false;
-    size_t HighBucketSize;
-    size_t HighPeakSlabsInUse;
-    if (impl->getParams().PoolTrace > 1) {
-        auto name = impl->getParams().Name;
-        try { // cannot throw in destructor
-            impl->printStats(TitlePrinted, HighBucketSize, HighPeakSlabsInUse,
-                             name);
-            if (TitlePrinted) {
-                std::cout << "Current Pool Size "
-                          << impl->getLimits()->TotalSize.load() << std::endl;
-                std::cout << "Suggested Setting=;"
-                          << std::string(1, (char)tolower(name[0]))
-                          << std::string(name + 1) << ":" << HighBucketSize
-                          << "," << HighPeakSlabsInUse << ",64K" << std::endl;
-            }
-        } catch (...) { // ignore exceptions
-        }
-    }
-}
-
-static umf_memory_pool_ops_t UMF_DISJOINT_POOL_OPS =
-    umf::poolMakeCOps<DisjointPool, umf_disjoint_pool_params_t>();
-
-umf_memory_pool_ops_t *umfDisjointPoolOps(void) {
-    return &UMF_DISJOINT_POOL_OPS;
-}
diff --git a/src/pool/pool_disjoint_internal.h b/src/pool/pool_disjoint_internal.h
new file mode 100644
index 0000000000..4d934479e0
--- /dev/null
+++ b/src/pool/pool_disjoint_internal.h
@@ -0,0 +1,190 @@
+/*
+ * 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
+*/
+
+#ifndef UMF_POOL_DISJOINT_INTERNAL_H
+#define UMF_POOL_DISJOINT_INTERNAL_H 1
+
+#include <stdbool.h>
+
+#include <umf/pools/pool_disjoint.h>
+
+#include "critnib/critnib.h"
+#include "utils_concurrency.h"
+
+#define CHUNK_BITMAP_SIZE 64
+
+typedef struct bucket_t bucket_t;
+typedef struct slab_t slab_t;
+typedef struct slab_list_item_t slab_list_item_t;
+typedef struct disjoint_pool_t disjoint_pool_t;
+
+typedef struct bucket_t {
+    size_t size;
+
+    // Linked list of slabs which have at least 1 available chunk.
+    // We always count available slabs as an optimization.
+    slab_list_item_t *available_slabs;
+    size_t available_slabs_num;
+
+    // Linked list of slabs with 0 available chunks
+    slab_list_item_t *unavailable_slabs;
+
+    // Protects the bucket and all the corresponding slabs
+    utils_mutex_t bucket_lock;
+
+    // Reference to the allocator context, used to access memory allocation
+    // routines, slab map and etc.
+    disjoint_pool_t *pool;
+
+    umf_disjoint_pool_shared_limits_handle_t shared_limits;
+
+    // For buckets used in chunked mode, a counter of slabs in the pool.
+    // For allocations that use an entire slab each, the entries in the
+    // "available" list are entries in the pool. Each slab is available for a
+    // new allocation. The size of the available list is the size of the pool.
+    //
+    // For allocations that use slabs in chunked mode, slabs will be in the
+    // "available" list if any one or more of their chunks are free. The entire
+    // slab is not necessarily free, just some chunks in the slab are free. To
+    // implement pooling, we will allow one slab in the "available" list to be
+    // entirely empty, and treat this slab as "in the pool".
+    // When a slab becomes entirely free, we must decide whether to return it
+    // to the provider or keep it allocated. We keep a counter of entirely
+    // empty slabs within the "available" list to speed up the process of
+    // checking if a slab in this bucket is already pooled.
+    size_t chunked_slabs_in_pool;
+
+    // Statistics
+    size_t alloc_count;
+    size_t alloc_pool_count;
+    size_t free_count;
+    size_t curr_slabs_in_use;
+    size_t curr_slabs_in_pool;
+    size_t max_slabs_in_pool;
+    size_t max_slabs_in_use;
+} bucket_t;
+
+typedef struct slab_list_item_t {
+    slab_t *val;
+    struct slab_list_item_t *prev, *next;
+} slab_list_item_t;
+
+// Represents the allocated memory block of size 'slab_min_size'
+// Internally, it splits the memory block into chunks. The number of
+// chunks depends on the size of a Bucket which created the Slab.
+// Note: Bucket's methods are responsible for thread safety of Slab access,
+// so no locking happens here.
+typedef struct slab_t {
+    // Pointer to the allocated memory of slab_min_size bytes
+    void *mem_ptr;
+    size_t slab_size;
+
+    size_t num_chunks_total;
+
+    // Num of 64-bit words needed to store chunk state
+    size_t num_words;
+
+    // Total number of allocated chunks at the moment.
+    size_t num_chunks_allocated;
+
+    // The bucket which the slab belongs to
+    bucket_t *bucket;
+
+    // Store iterator to the corresponding node in avail/unavail list
+    // to achieve O(1) removal
+    slab_list_item_t iter;
+
+    // Represents the current state of each chunk: if the bit is clear, the
+    // chunk is allocated; otherwise, the chunk is free for allocation
+    uint64_t chunks[];
+} slab_t;
+
+typedef struct umf_disjoint_pool_shared_limits_t {
+    size_t max_size;
+    uint64_t total_size; // requires atomic access
+} umf_disjoint_pool_shared_limits_t;
+
+typedef struct umf_disjoint_pool_params_t {
+    // Minimum allocation size that will be requested from the memory provider.
+    size_t slab_min_size; // Default: 64KB
+
+    // Allocations up to this limit will be subject to chunking/pooling
+    size_t max_poolable_size; // Default: 2MB
+
+    // When pooling, each bucket will hold a max of 'capacity' unfreed slabs
+    size_t capacity; // Default: 4
+
+    // Holds the minimum bucket size valid for allocation of a memory type.
+    // This value must be a power of 2.
+    size_t min_bucket_size; // Default: 8
+
+    // Holds size of the pool managed by the allocator.
+    size_t cur_pool_size; // Default: 0
+
+    // Whether to print pool usage statistics
+    int pool_trace; // Default: 0
+
+    // Memory limits that can be shared between multiple pool instances,
+    // i.e. if multiple pools use the same shared_limits sum of those pools'
+    // sizes cannot exceed max_size.
+    umf_disjoint_pool_shared_limits_handle_t shared_limits;
+
+    // Name used in traces
+    char name[64];
+} umf_disjoint_pool_params_t;
+
+typedef struct disjoint_pool_t {
+    // Keep the list of known slabs to quickly find required one during the
+    // free()
+    critnib *known_slabs; // (void *, slab_t *)
+
+    // Handle to the memory provider
+    umf_memory_provider_handle_t provider;
+
+    // Array of bucket_t*
+    bucket_t **buckets;
+    size_t buckets_num;
+
+    // Configuration for this instance
+    umf_disjoint_pool_params_t params;
+
+    umf_disjoint_pool_shared_limits_handle_t default_shared_limits;
+
+    // Used in algorithm for finding buckets
+    size_t min_bucket_size_exp;
+
+    // Coarse-grain allocation min alignment
+    size_t provider_min_page_size;
+
+    // true after post_initialize was successfully called
+    bool post_initialized;
+
+    // bitmask of parameters overridden via CTL
+    unsigned params_overridden;
+} disjoint_pool_t;
+
+static inline void slab_set_chunk_bit(slab_t *slab, size_t index, bool value) {
+    assert(index < slab->num_chunks_total && "Index out of range");
+
+    size_t word_index = index / CHUNK_BITMAP_SIZE;
+    unsigned bit_index = index % CHUNK_BITMAP_SIZE;
+    if (value) {
+        slab->chunks[word_index] |= (1ULL << bit_index);
+    } else {
+        slab->chunks[word_index] &= ~(1ULL << bit_index);
+    }
+}
+
+static inline int slab_read_chunk_bit(const slab_t *slab, size_t index) {
+    assert(index < slab->num_chunks_total && "Index out of range");
+
+    size_t word_index = index / CHUNK_BITMAP_SIZE;
+    unsigned bit_index = index % CHUNK_BITMAP_SIZE;
+    return (slab->chunks[word_index] >> bit_index) & 1;
+}
+
+#endif // UMF_POOL_DISJOINT_INTERNAL_H
diff --git a/src/pool/pool_jemalloc.c b/src/pool/pool_jemalloc.c
index 3ec7c78050..50a245e05d 100644
--- a/src/pool/pool_jemalloc.c
+++ b/src/pool/pool_jemalloc.c
@@ -1,16 +1,20 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ * Copyright (C) 2022-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 <assert.h>
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "base_alloc_global.h"
+#include "ctl/ctl_internal.h"
+#include "memory_provider_internal.h"
+#include "provider_tracking.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
 #include "utils_log.h"
@@ -20,37 +24,64 @@
 #include <umf/memory_pool_ops.h>
 #include <umf/pools/pool_jemalloc.h>
 
-#include <jemalloc/jemalloc.h>
+#ifndef UMF_POOL_JEMALLOC_ENABLED
 
-// The Windows version of jemalloc uses API with je_ prefix,
-// while the Linux one does not.
-#ifndef _WIN32
-#define je_mallocx mallocx
-#define je_dallocx dallocx
-#define je_rallocx rallocx
-#define je_mallctl mallctl
-#define je_malloc_usable_size malloc_usable_size
-#endif
+const umf_memory_pool_ops_t *umfJemallocPoolOps(void) { return NULL; }
+umf_result_t
+umfJemallocPoolParamsCreate(umf_jemalloc_pool_params_handle_t *hParams) {
+    (void)hParams; // unused
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t
+umfJemallocPoolParamsDestroy(umf_jemalloc_pool_params_handle_t hParams) {
+    (void)hParams; // unused
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t
+umfJemallocPoolParamsSetNumArenas(umf_jemalloc_pool_params_handle_t hParams,
+                                  size_t numArenas) {
+    (void)hParams;   // unused
+    (void)numArenas; // unused
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t
+umfJemallocPoolParamsSetName(umf_jemalloc_pool_params_handle_t hParams,
+                             const char *name) {
+    (void)hParams; // unused
+    (void)name;    // unused
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+#else
+
+#include <jemalloc/jemalloc.h>
 
 #define MALLOCX_ARENA_MAX (MALLCTL_ARENAS_ALL - 1)
+#define DEFAULT_NAME "jemalloc"
+
+typedef struct umf_jemalloc_pool_params_t {
+    size_t n_arenas;
+    char name[64];
+} umf_jemalloc_pool_params_t;
 
 typedef struct jemalloc_memory_pool_t {
     umf_memory_provider_handle_t provider;
-    unsigned int arena_index; // index of jemalloc arena
-    // set to true if umfMemoryProviderFree() should never be called
-    bool disable_provider_free;
+    umf_jemalloc_pool_params_t params;
+    size_t n_arenas;
+    char name[64];
+    unsigned int *arena_index;
 } jemalloc_memory_pool_t;
 
-// Configuration of Jemalloc Pool
-typedef struct umf_jemalloc_pool_params_t {
-    /// Set to true if umfMemoryProviderFree() should never be called.
-    bool disable_provider_free;
-} umf_jemalloc_pool_params_t;
-
 static __TLS umf_result_t TLS_last_allocation_error;
 
 static jemalloc_memory_pool_t *pool_by_arena_index[MALLCTL_ARENAS_ALL];
 
+struct ctl jemalloc_ctl_root;
+static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT;
+
 static jemalloc_memory_pool_t *get_pool_by_arena_index(unsigned arena_ind) {
     // there is no way to obtain MALLOCX_ARENA_MAX from jemalloc
     // so this checks if arena_ind does not exceed assumed range
@@ -59,50 +90,12 @@ static jemalloc_memory_pool_t *get_pool_by_arena_index(unsigned arena_ind) {
     return pool_by_arena_index[arena_ind];
 }
 
-umf_result_t
-umfJemallocPoolParamsCreate(umf_jemalloc_pool_params_handle_t *hParams) {
-    if (!hParams) {
-        LOG_ERR("jemalloc pool params handle is NULL");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    umf_jemalloc_pool_params_t *params_data =
-        umf_ba_global_alloc(sizeof(*params_data));
-    if (!params_data) {
-        LOG_ERR("cannot allocate memory for jemalloc poolparams");
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    params_data->disable_provider_free = false;
-
-    *hParams = (umf_jemalloc_pool_params_handle_t)params_data;
-
-    return UMF_RESULT_SUCCESS;
-}
-
-umf_result_t
-umfJemallocPoolParamsDestroy(umf_jemalloc_pool_params_handle_t hParams) {
-    if (!hParams) {
-        LOG_ERR("jemalloc pool params handle is NULL");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    umf_ba_global_free(hParams);
-
-    return UMF_RESULT_SUCCESS;
-}
-
-umf_result_t
-umfJemallocPoolParamsSetKeepAllMemory(umf_jemalloc_pool_params_handle_t hParams,
-                                      bool keepAllMemory) {
-    if (!hParams) {
-        LOG_ERR("jemalloc pool params handle is NULL");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    hParams->disable_provider_free = keepAllMemory;
-
-    return UMF_RESULT_SUCCESS;
+// SplitMix64 hash
+static uint64_t hash64(uint64_t x) {
+    x += 0x9e3779b97f4a7c15;
+    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+    return x ^ (x >> 31);
 }
 
 // arena_extent_alloc - an extent allocation function conforms to the extent_alloc_t type and upon
@@ -134,15 +127,13 @@ static void *arena_extent_alloc(extent_hooks_t *extent_hooks, void *new_addr,
     }
 
     if (new_addr != NULL && ptr != new_addr) {
-        if (!pool->disable_provider_free) {
-            umfMemoryProviderFree(pool->provider, ptr, size);
-        }
+        umfMemoryProviderFree(pool->provider, ptr, size);
         return NULL;
     }
 
 #ifndef __SANITIZE_ADDRESS__
     // jemalloc might write to new extents in realloc, so we cannot
-    // mark them as unaccessible under asan
+    // mark them as inaccessible under asan
     utils_annotate_memory_inaccessible(ptr, size);
 #endif
 
@@ -170,10 +161,6 @@ static void arena_extent_destroy(extent_hooks_t *extent_hooks, void *addr,
 
     jemalloc_memory_pool_t *pool = get_pool_by_arena_index(arena_ind);
 
-    if (pool->disable_provider_free) {
-        return;
-    }
-
     umf_result_t ret;
     ret = umfMemoryProviderFree(pool->provider, addr, size);
     if (ret != UMF_RESULT_SUCCESS) {
@@ -196,10 +183,6 @@ static bool arena_extent_dalloc(extent_hooks_t *extent_hooks, void *addr,
 
     jemalloc_memory_pool_t *pool = get_pool_by_arena_index(arena_ind);
 
-    if (pool->disable_provider_free) {
-        return true; // opt-out from deallocation
-    }
-
     umf_result_t ret;
     ret = umfMemoryProviderFree(pool->provider, addr, size);
     if (ret != UMF_RESULT_SUCCESS) {
@@ -307,8 +290,15 @@ static bool arena_extent_split(extent_hooks_t *extent_hooks, void *addr,
 
     jemalloc_memory_pool_t *pool = get_pool_by_arena_index(arena_ind);
     assert(pool);
-    return umfMemoryProviderAllocationSplit(pool->provider, addr, size,
-                                            size_a) != UMF_RESULT_SUCCESS;
+
+    umf_result_t ret =
+        umfMemoryProviderAllocationSplit(pool->provider, addr, size, size_a);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("memory provider failed to split a memory region, while "
+                "jemalloc requires that");
+    }
+
+    return ret != UMF_RESULT_SUCCESS;
 }
 
 // arena_extent_merge - an extent merge function conforms to the extent_merge_t type and optionally
@@ -353,12 +343,22 @@ static extent_hooks_t arena_extent_hooks = {
     .merge = arena_extent_merge,
 };
 
+static unsigned get_arena_index(jemalloc_memory_pool_t *pool) {
+    static __TLS unsigned tid = 0;
+
+    if (tid == 0) {
+        tid = utils_gettid();
+    }
+
+    return pool->arena_index[hash64(tid) % pool->n_arenas];
+}
+
 static void *op_malloc(void *pool, size_t size) {
     assert(pool);
     jemalloc_memory_pool_t *je_pool = (jemalloc_memory_pool_t *)pool;
     // MALLOCX_TCACHE_NONE is set, because jemalloc can mix objects from different arenas inside
     // the tcache, so we wouldn't be able to guarantee isolation of different providers.
-    int flags = MALLOCX_ARENA(je_pool->arena_index) | MALLOCX_TCACHE_NONE;
+    int flags = MALLOCX_ARENA(get_arena_index(je_pool)) | MALLOCX_TCACHE_NONE;
     void *ptr = je_mallocx(size, flags);
     if (ptr == NULL) {
         TLS_last_allocation_error = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
@@ -411,7 +411,7 @@ static void *op_realloc(void *pool, void *ptr, size_t size) {
     jemalloc_memory_pool_t *je_pool = (jemalloc_memory_pool_t *)pool;
     // MALLOCX_TCACHE_NONE is set, because jemalloc can mix objects from different arenas inside
     // the tcache, so we wouldn't be able to guarantee isolation of different providers.
-    int flags = MALLOCX_ARENA(je_pool->arena_index) | MALLOCX_TCACHE_NONE;
+    int flags = MALLOCX_ARENA(get_arena_index(je_pool)) | MALLOCX_TCACHE_NONE;
     void *new_ptr = je_rallocx(ptr, size, flags);
     if (new_ptr == NULL) {
         TLS_last_allocation_error = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
@@ -432,7 +432,8 @@ static void *op_realloc(void *pool, void *ptr, size_t size) {
 static void *op_aligned_alloc(void *pool, size_t size, size_t alignment) {
     assert(pool);
     jemalloc_memory_pool_t *je_pool = (jemalloc_memory_pool_t *)pool;
-    unsigned arena = je_pool->arena_index;
+
+    unsigned arena = get_arena_index(je_pool);
     // MALLOCX_TCACHE_NONE is set, because jemalloc can mix objects from different arenas inside
     // the tcache, so we wouldn't be able to guarantee isolation of different providers.
     int flags =
@@ -448,80 +449,236 @@ static void *op_aligned_alloc(void *pool, size_t size, size_t alignment) {
     return ptr;
 }
 
+// Verify if the memory provider supports the split() operation,
+// because jemalloc pool requires that.
+static umf_result_t verify_split(umf_memory_provider_handle_t provider) {
+    // Retrieve the upstream memory provider
+    umf_memory_provider_handle_t upstream_provider = NULL;
+    umfTrackingMemoryProviderGetUpstreamProvider(
+        umfMemoryProviderGetPriv(provider), &upstream_provider);
+
+    size_t page_size = 0;
+    umf_result_t ret =
+        umfMemoryProviderGetMinPageSize(upstream_provider, NULL, &page_size);
+    if (ret != UMF_RESULT_SUCCESS) {
+        return ret;
+    }
+
+    size_t size = 2 * page_size; // use double the page size for the split test
+    if (UMF_RESULT_ERROR_NOT_SUPPORTED ==
+        umfMemoryProviderAllocationSplit(upstream_provider, (void *)size, size,
+                                         page_size)) {
+        LOG_ERR("memory provider does not support the split operation, while "
+                "jemalloc pool requires that");
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
 static umf_result_t op_initialize(umf_memory_provider_handle_t provider,
-                                  void *params, void **out_pool) {
+                                  const void *params, void **out_pool) {
     assert(provider);
     assert(out_pool);
 
-    umf_jemalloc_pool_params_handle_t je_params =
-        (umf_jemalloc_pool_params_handle_t)params;
+    // Verify if the memory provider supports the split() operation,
+    // because jemalloc pool requires that.
+    umf_result_t ret = verify_split(provider);
+    if (ret != UMF_RESULT_SUCCESS) {
+        return ret;
+    }
+
+    jemalloc_memory_pool_t *pool = umf_ba_global_alloc(sizeof(*pool));
+    if (!pool) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+    memset(pool, 0, sizeof(*pool));
+
+    pool->provider = provider;
+    if (params) {
+        pool->params = *(const umf_jemalloc_pool_params_t *)params;
+    } else {
+        // Set default values
+        memset(&pool->params, 0, sizeof(pool->params));
+        strncpy(pool->params.name, DEFAULT_NAME, sizeof(pool->params.name) - 1);
+    }
+
+    *out_pool = pool;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t op_post_initialize(void *pool) {
+    assert(pool);
 
     extent_hooks_t *pHooks = &arena_extent_hooks;
     size_t unsigned_size = sizeof(unsigned);
+    int n_arenas_set_from_params = 0;
+    jemalloc_memory_pool_t *je_pool = (jemalloc_memory_pool_t *)pool;
     int err;
+    const umf_jemalloc_pool_params_t *jemalloc_params = &je_pool->params;
 
-    jemalloc_memory_pool_t *pool =
-        umf_ba_global_alloc(sizeof(jemalloc_memory_pool_t));
-    if (!pool) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    size_t n_arenas = 0;
+    if (jemalloc_params) {
+        n_arenas = jemalloc_params->n_arenas;
+        n_arenas_set_from_params = 1;
     }
 
-    pool->provider = provider;
+    if (n_arenas == 0) {
+        n_arenas = utils_get_num_cores() * 4;
+        n_arenas = utils_min(n_arenas, (size_t)MALLOCX_ARENA_MAX);
+    }
 
-    if (je_params) {
-        pool->disable_provider_free = je_params->disable_provider_free;
-    } else {
-        pool->disable_provider_free = false;
+    if (n_arenas > MALLOCX_ARENA_MAX) {
+        LOG_ERR("Number of arenas %zu exceeds the limit (%i).", n_arenas,
+                MALLOCX_ARENA_MAX);
+        umf_ba_global_free(je_pool);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    unsigned arena_index;
-    err = je_mallctl("arenas.create", (void *)&arena_index, &unsigned_size,
-                     NULL, 0);
-    if (err) {
-        LOG_ERR("Could not create arena.");
-        goto err_free_pool;
+    je_pool->arena_index =
+        umf_ba_global_alloc(n_arenas * sizeof(*je_pool->arena_index));
+    if (!je_pool->arena_index) {
+        LOG_ERR("Could not allocate memory for arena indices.");
+        umf_ba_global_free(je_pool);
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    // setup extent_hooks for newly created arena
-    char cmd[64];
-    snprintf(cmd, sizeof(cmd), "arena.%u.extent_hooks", arena_index);
-    err = je_mallctl(cmd, NULL, NULL, (void *)&pHooks, sizeof(void *));
-    if (err) {
-        snprintf(cmd, sizeof(cmd), "arena.%u.destroy", arena_index);
-        je_mallctl(cmd, NULL, 0, NULL, 0);
-        LOG_ERR("Could not setup extent_hooks for newly created arena.");
-        goto err_free_pool;
+    memset(je_pool->arena_index, 0, n_arenas * sizeof(*je_pool->arena_index));
+
+    const char *pool_name = DEFAULT_NAME;
+    if (jemalloc_params) {
+        pool_name = jemalloc_params->name;
     }
 
-    pool->arena_index = arena_index;
-    pool_by_arena_index[arena_index] = pool;
+    snprintf(je_pool->name, sizeof(je_pool->name), "%s", pool_name);
+
+    je_pool->n_arenas = n_arenas;
+
+    size_t num_created = 0;
+    for (size_t i = 0; i < n_arenas; i++) {
+        unsigned arena_index;
+        err = je_mallctl("arenas.create", (void *)&arena_index, &unsigned_size,
+                         NULL, 0);
+        if (err) {
+            // EAGAIN - means that a memory allocation failure occurred
+            // (2 * utils_get_num_cores()) is the required minimum number of arenas
+            if (n_arenas_set_from_params || err != EAGAIN ||
+                (i < (2 * utils_get_num_cores()))) {
+                LOG_ERR("Could not create a jemalloc arena (n_arenas = %zu, i "
+                        "= %zu, arena_index = %u, unsigned_size = %zu): %s",
+                        n_arenas, i, arena_index, unsigned_size, strerror(err));
+                goto err_cleanup;
+            }
+
+            LOG_WARN("Could not create the #%zu jemalloc arena (%s), setting "
+                     "n_arenas = %zu",
+                     i + 1, strerror(err), i);
+            n_arenas = i;
+            break;
+        }
+
+        je_pool->arena_index[num_created++] = arena_index;
+        if (arena_index >= MALLOCX_ARENA_MAX) {
+            LOG_ERR("Number of arenas exceeds the limit.");
+            goto err_cleanup;
+        }
 
-    *out_pool = (umf_memory_pool_handle_t)pool;
+        pool_by_arena_index[arena_index] = je_pool;
 
-    VALGRIND_DO_CREATE_MEMPOOL(pool, 0, 0);
+        // Setup extent_hooks for the newly created arena.
+        char cmd[64];
+        snprintf(cmd, sizeof(cmd), "arena.%u.extent_hooks", arena_index);
+        err = je_mallctl(cmd, NULL, NULL, (void *)&pHooks, sizeof(void *));
+        if (err) {
+            LOG_ERR("Could not setup extent_hooks for newly created arena.");
+            goto err_cleanup;
+        }
+    }
+
+    VALGRIND_DO_CREATE_MEMPOOL(je_pool, 0, 0);
 
     return UMF_RESULT_SUCCESS;
 
-err_free_pool:
-    umf_ba_global_free(pool);
+err_cleanup:
+    // Destroy any arenas that were successfully created.
+    for (size_t i = 0; i < num_created; i++) {
+        char cmd[64];
+        unsigned arena = je_pool->arena_index[i];
+        snprintf(cmd, sizeof(cmd), "arena.%u.destroy", arena);
+        (void)je_mallctl(cmd, NULL, 0, NULL, 0);
+    }
+    if (je_pool->arena_index) {
+        umf_ba_global_free(je_pool->arena_index);
+        je_pool->arena_index = NULL;
+    }
+    umf_ba_global_free(je_pool);
     return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
 }
 
-static void op_finalize(void *pool) {
+static umf_result_t
+CTL_RUNNABLE_HANDLER(post_initialize)(void *ctx, umf_ctl_query_source_t source,
+                                      void *arg, size_t size,
+                                      umf_ctl_index_utlist_t *indexes) {
+    (void)source;
+    (void)arg;
+    (void)size;
+    (void)indexes;
+    return op_post_initialize(ctx);
+}
+
+static void initialize_jemalloc_ctl(void) {
+    jemalloc_ctl_root.root[jemalloc_ctl_root.first_free++] = (umf_ctl_node_t){
+        .name = "post_initialize",
+        .type = CTL_NODE_LEAF,
+        .runnable_cb = CTL_RUNNABLE_HANDLER(post_initialize),
+    };
+}
+
+static umf_result_t op_ctl(void *pool, umf_ctl_query_source_t operationType,
+                           const char *name, void *arg, size_t size,
+                           umf_ctl_query_type_t queryType, va_list args) {
+    (void)operationType;
+    (void)arg;
+    (void)size;
+    (void)args;
+    utils_init_once(&ctl_initialized, initialize_jemalloc_ctl);
+    return ctl_query(&jemalloc_ctl_root, pool, CTL_QUERY_PROGRAMMATIC, name,
+                     queryType, arg, size, args);
+}
+
+static umf_result_t op_finalize(void *pool) {
     assert(pool);
+    umf_result_t ret = UMF_RESULT_SUCCESS;
     jemalloc_memory_pool_t *je_pool = (jemalloc_memory_pool_t *)pool;
-    char cmd[64];
-    snprintf(cmd, sizeof(cmd), "arena.%u.destroy", je_pool->arena_index);
-    je_mallctl(cmd, NULL, 0, NULL, 0);
-    pool_by_arena_index[je_pool->arena_index] = NULL;
+    for (size_t i = 0; i < je_pool->n_arenas; i++) {
+        char cmd[64];
+        unsigned arena = je_pool->arena_index[i];
+        snprintf(cmd, sizeof(cmd), "arena.%u.destroy", arena);
+        if (je_mallctl(cmd, NULL, 0, NULL, 0)) {
+            LOG_ERR("Could not destroy jemalloc arena %u", arena);
+            ret = UMF_RESULT_ERROR_UNKNOWN;
+        }
+    }
+    if (je_pool->arena_index) {
+        umf_ba_global_free(je_pool->arena_index);
+    }
     umf_ba_global_free(je_pool);
 
     VALGRIND_DO_DESTROY_MEMPOOL(pool);
+    return ret;
 }
 
-static size_t op_malloc_usable_size(void *pool, void *ptr) {
+static umf_result_t op_malloc_usable_size(void *pool, const void *ptr,
+                                          size_t *size) {
     (void)pool; // not used
-    return je_malloc_usable_size(ptr);
+    if (!size) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    // Remove the 'const' qualifier because the je_malloc_usable_size
+    // function requires a non-const pointer.
+    *size = je_malloc_usable_size((void *)ptr);
+    return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t op_get_last_allocation_error(void *pool) {
@@ -529,8 +686,43 @@ static umf_result_t op_get_last_allocation_error(void *pool) {
     return TLS_last_allocation_error;
 }
 
+static umf_result_t op_get_name(void *pool, const char **name) {
+    if (!name) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    if (pool == NULL) {
+        *name = DEFAULT_NAME;
+        return UMF_RESULT_SUCCESS;
+    }
+    jemalloc_memory_pool_t *je_pool = (jemalloc_memory_pool_t *)pool;
+    *name = je_pool->name;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t op_trim_memory(void *pool, size_t minBytesToKeep) {
+    // there is no way to tell jemalloc to keep a minimum number of bytes
+    // so we just purge all arenas
+    if (minBytesToKeep > 0) {
+        LOG_WARN("Ignoring minBytesToKeep (%zu) in jemalloc pool",
+                 minBytesToKeep);
+    }
+
+    jemalloc_memory_pool_t *je_pool = (jemalloc_memory_pool_t *)pool;
+    for (size_t i = 0; i < je_pool->n_arenas; i++) {
+        char cmd[64];
+        unsigned arena = je_pool->arena_index[i];
+        snprintf(cmd, sizeof(cmd), "arena.%u.purge", arena);
+        if (je_mallctl(cmd, NULL, NULL, NULL, 0)) {
+            LOG_ERR("Could not purge jemalloc arena %u", arena);
+            return UMF_RESULT_ERROR_UNKNOWN;
+        }
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
 static umf_memory_pool_ops_t UMF_JEMALLOC_POOL_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_POOL_OPS_VERSION_CURRENT,
     .initialize = op_initialize,
     .finalize = op_finalize,
     .malloc = op_malloc,
@@ -540,8 +732,62 @@ static umf_memory_pool_ops_t UMF_JEMALLOC_POOL_OPS = {
     .malloc_usable_size = op_malloc_usable_size,
     .free = op_free,
     .get_last_allocation_error = op_get_last_allocation_error,
+    .get_name = op_get_name,
+    .ext_ctl = op_ctl,
+    .ext_trim_memory = op_trim_memory,
 };
 
-umf_memory_pool_ops_t *umfJemallocPoolOps(void) {
+const umf_memory_pool_ops_t *umfJemallocPoolOps(void) {
     return &UMF_JEMALLOC_POOL_OPS;
 }
+
+umf_result_t
+umfJemallocPoolParamsCreate(umf_jemalloc_pool_params_handle_t *hParams) {
+    umf_jemalloc_pool_params_t *params = umf_ba_global_alloc(sizeof(*params));
+    if (!params) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+    memset(params, 0, sizeof(*params));
+    strncpy(params->name, DEFAULT_NAME, sizeof(params->name) - 1);
+    params->name[sizeof(params->name) - 1] = '\0';
+    *hParams = params;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfJemallocPoolParamsDestroy(umf_jemalloc_pool_params_handle_t hParams) {
+    umf_ba_global_free(hParams);
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfJemallocPoolParamsSetNumArenas(umf_jemalloc_pool_params_handle_t hParams,
+                                  size_t numArenas) {
+    if (!hParams) {
+        LOG_ERR("jemalloc pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    hParams->n_arenas = numArenas;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfJemallocPoolParamsSetName(umf_jemalloc_pool_params_handle_t hParams,
+                             const char *name) {
+    if (!hParams) {
+        LOG_ERR("jemalloc pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (!name) {
+        LOG_ERR("name is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    strncpy(hParams->name, name, sizeof(hParams->name) - 1);
+    hParams->name[sizeof(hParams->name) - 1] = '\0';
+
+    return UMF_RESULT_SUCCESS;
+}
+
+#endif /* UMF_POOL_JEMALLOC_ENABLED */
diff --git a/src/pool/pool_proxy.c b/src/pool/pool_proxy.c
index 2269d9344b..6e256c4918 100644
--- a/src/pool/pool_proxy.c
+++ b/src/pool/pool_proxy.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -23,8 +23,8 @@ struct proxy_memory_pool {
 };
 
 static umf_result_t
-proxy_pool_initialize(umf_memory_provider_handle_t hProvider, void *params,
-                      void **ppPool) {
+proxy_pool_initialize(umf_memory_provider_handle_t hProvider,
+                      const void *params, void **ppPool) {
     (void)params; // unused
 
     struct proxy_memory_pool *pool =
@@ -39,7 +39,10 @@ proxy_pool_initialize(umf_memory_provider_handle_t hProvider, void *params,
     return UMF_RESULT_SUCCESS;
 }
 
-static void proxy_pool_finalize(void *pool) { umf_ba_global_free(pool); }
+static umf_result_t proxy_pool_finalize(void *pool) {
+    umf_ba_global_free(pool);
+    return UMF_RESULT_SUCCESS;
+}
 
 static void *proxy_aligned_malloc(void *pool, size_t size, size_t alignment) {
     assert(pool);
@@ -97,24 +100,40 @@ static umf_result_t proxy_free(void *pool, void *ptr) {
     struct proxy_memory_pool *hPool = (struct proxy_memory_pool *)pool;
 
     if (ptr) {
-        umf_alloc_info_t allocInfo = {NULL, 0, NULL};
-        umf_result_t umf_result = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
-        if (umf_result == UMF_RESULT_SUCCESS) {
-            size = allocInfo.baseSize;
+        umf_memory_properties_handle_t props = NULL;
+        umf_result_t umf_result = umfGetMemoryPropertiesHandle(ptr, &props);
+
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            TLS_last_allocation_error = umf_result;
+            LOG_ERR("failed to get allocation info from the memory tracker");
+            return umf_result;
         }
+
+        if (props == NULL) {
+            TLS_last_allocation_error = UMF_RESULT_ERROR_UNKNOWN;
+            LOG_ERR("failed to get allocation info from the memory tracker");
+            return UMF_RESULT_ERROR_UNKNOWN;
+        }
+
+        size = props->base_size;
     }
 
     return umfMemoryProviderFree(hPool->hProvider, ptr, size);
 }
 
-static size_t proxy_malloc_usable_size(void *pool, void *ptr) {
+static umf_result_t proxy_malloc_usable_size(void *pool, const void *ptr,
+                                             size_t *size) {
     assert(pool);
 
     (void)pool;
     (void)ptr;
+    if (!size) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
 
     TLS_last_allocation_error = UMF_RESULT_ERROR_NOT_SUPPORTED;
-    return 0;
+    *size = 0;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
 }
 
 static umf_result_t proxy_get_last_allocation_error(void *pool) {
@@ -122,8 +141,14 @@ static umf_result_t proxy_get_last_allocation_error(void *pool) {
     return TLS_last_allocation_error;
 }
 
+static umf_result_t proxy_get_name(void *pool, const char **name) {
+    (void)pool;
+    *name = "proxy";
+    return UMF_RESULT_SUCCESS;
+}
+
 static umf_memory_pool_ops_t UMF_PROXY_POOL_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_POOL_OPS_VERSION_CURRENT,
     .initialize = proxy_pool_initialize,
     .finalize = proxy_pool_finalize,
     .malloc = proxy_malloc,
@@ -132,6 +157,11 @@ static umf_memory_pool_ops_t UMF_PROXY_POOL_OPS = {
     .aligned_malloc = proxy_aligned_malloc,
     .malloc_usable_size = proxy_malloc_usable_size,
     .free = proxy_free,
-    .get_last_allocation_error = proxy_get_last_allocation_error};
+    .get_last_allocation_error = proxy_get_last_allocation_error,
+    .get_name = proxy_get_name,
+    .ext_trim_memory = NULL, // not supported
+};
 
-umf_memory_pool_ops_t *umfProxyPoolOps(void) { return &UMF_PROXY_POOL_OPS; }
+const umf_memory_pool_ops_t *umfProxyPoolOps(void) {
+    return &UMF_PROXY_POOL_OPS;
+}
diff --git a/src/pool/pool_scalable.c b/src/pool/pool_scalable.c
index 6ee364344e..b5211615b8 100644
--- a/src/pool/pool_scalable.c
+++ b/src/pool/pool_scalable.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -19,7 +19,10 @@
 #include <umf/pools/pool_scalable.h>
 
 #include "base_alloc_global.h"
+#include "ctl/ctl_internal.h"
 #include "libumf.h"
+#include "memory_pool_internal.h"
+#include "pool_scalable_internal.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
 #include "utils_load_library.h"
@@ -33,6 +36,8 @@ static __TLS umf_result_t TLS_last_allocation_error;
 static __TLS umf_result_t TLS_last_free_error;
 
 static const size_t DEFAULT_GRANULARITY = 2 * 1024 * 1024; // 2MB
+static const char *DEFAULT_NAME = "scalable";
+
 typedef struct tbb_mem_pool_policy_t {
     raw_alloc_tbb_type pAlloc;
     raw_free_tbb_type pFree;
@@ -44,6 +49,7 @@ typedef struct tbb_mem_pool_policy_t {
 typedef struct umf_scalable_pool_params_t {
     size_t granularity;
     bool keep_all_memory;
+    char name[64];
 } umf_scalable_pool_params_t;
 
 typedef struct tbb_callbacks_t {
@@ -65,8 +71,9 @@ typedef struct tbb_callbacks_t {
 
 typedef struct tbb_memory_pool_t {
     umf_memory_provider_handle_t mem_provider;
+    umf_scalable_pool_params_t params;
     void *tbb_pool;
-    tbb_callbacks_t tbb_callbacks;
+    char name[64];
 } tbb_memory_pool_t;
 
 typedef enum tbb_enums_t {
@@ -82,6 +89,10 @@ typedef enum tbb_enums_t {
     TBB_POOL_SYMBOLS_MAX // it has to be the last one
 } tbb_enums_t;
 
+static UTIL_ONCE_FLAG tbb_initialized = UTIL_ONCE_FLAG_INIT;
+static int tbb_init_result = 0;
+static tbb_callbacks_t tbb_callbacks = {0};
+
 static const char *tbb_symbol[TBB_POOL_SYMBOLS_MAX] = {
 #ifdef _WIN32
     // symbols copied from oneTBB/src/tbbmalloc/def/win64-tbbmalloc.def
@@ -109,46 +120,64 @@ static const char *tbb_symbol[TBB_POOL_SYMBOLS_MAX] = {
 #endif
 };
 
-static int init_tbb_callbacks(tbb_callbacks_t *tbb_callbacks) {
-    assert(tbb_callbacks);
+struct ctl pool_scallable_ctl_root;
+
+static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT;
 
+static void init_tbb_callbacks_once(void) {
     const char *lib_name = tbb_symbol[TBB_LIB_NAME];
-    tbb_callbacks->lib_handle = utils_open_library(lib_name, 0);
-    if (!tbb_callbacks->lib_handle) {
+    tbb_callbacks.lib_handle = utils_open_library(lib_name, 0);
+    if (!tbb_callbacks.lib_handle) {
         LOG_ERR("%s required by Scalable Pool not found - install TBB malloc "
                 "or make sure it is in the default search paths.",
                 lib_name);
-        return -1;
+        tbb_init_result = -1;
+        return;
     }
-
-    *(void **)&tbb_callbacks->pool_malloc = utils_get_symbol_addr(
-        tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_MALLOC], lib_name);
-    *(void **)&tbb_callbacks->pool_realloc = utils_get_symbol_addr(
-        tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_REALLOC], lib_name);
-    *(void **)&tbb_callbacks->pool_aligned_malloc =
-        utils_get_symbol_addr(tbb_callbacks->lib_handle,
+    *(void **)&tbb_callbacks.pool_malloc = utils_get_symbol_addr(
+        tbb_callbacks.lib_handle, tbb_symbol[TBB_POOL_MALLOC], lib_name);
+    *(void **)&tbb_callbacks.pool_realloc = utils_get_symbol_addr(
+        tbb_callbacks.lib_handle, tbb_symbol[TBB_POOL_REALLOC], lib_name);
+    *(void **)&tbb_callbacks.pool_aligned_malloc =
+        utils_get_symbol_addr(tbb_callbacks.lib_handle,
                               tbb_symbol[TBB_POOL_ALIGNED_MALLOC], lib_name);
-    *(void **)&tbb_callbacks->pool_free = utils_get_symbol_addr(
-        tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_FREE], lib_name);
-    *(void **)&tbb_callbacks->pool_create_v1 = utils_get_symbol_addr(
-        tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_CREATE_V1], lib_name);
-    *(void **)&tbb_callbacks->pool_destroy = utils_get_symbol_addr(
-        tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_DESTROY], lib_name);
-    *(void **)&tbb_callbacks->pool_identify = utils_get_symbol_addr(
-        tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_IDENTIFY], lib_name);
-    *(void **)&tbb_callbacks->pool_msize = utils_get_symbol_addr(
-        tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_MSIZE], lib_name);
-
-    if (!tbb_callbacks->pool_malloc || !tbb_callbacks->pool_realloc ||
-        !tbb_callbacks->pool_aligned_malloc || !tbb_callbacks->pool_free ||
-        !tbb_callbacks->pool_create_v1 || !tbb_callbacks->pool_destroy ||
-        !tbb_callbacks->pool_identify) {
-        LOG_ERR("Could not find symbols in %s", lib_name);
-        utils_close_library(tbb_callbacks->lib_handle);
-        return -1;
+    *(void **)&tbb_callbacks.pool_free = utils_get_symbol_addr(
+        tbb_callbacks.lib_handle, tbb_symbol[TBB_POOL_FREE], lib_name);
+    *(void **)&tbb_callbacks.pool_create_v1 = utils_get_symbol_addr(
+        tbb_callbacks.lib_handle, tbb_symbol[TBB_POOL_CREATE_V1], lib_name);
+    *(void **)&tbb_callbacks.pool_destroy = utils_get_symbol_addr(
+        tbb_callbacks.lib_handle, tbb_symbol[TBB_POOL_DESTROY], lib_name);
+    *(void **)&tbb_callbacks.pool_identify = utils_get_symbol_addr(
+        tbb_callbacks.lib_handle, tbb_symbol[TBB_POOL_IDENTIFY], lib_name);
+    *(void **)&tbb_callbacks.pool_msize = utils_get_symbol_addr(
+        tbb_callbacks.lib_handle, tbb_symbol[TBB_POOL_MSIZE], lib_name);
+
+    if (!tbb_callbacks.pool_malloc || !tbb_callbacks.pool_realloc ||
+        !tbb_callbacks.pool_aligned_malloc || !tbb_callbacks.pool_free ||
+        !tbb_callbacks.pool_create_v1 || !tbb_callbacks.pool_destroy ||
+        !tbb_callbacks.pool_identify) {
+        LOG_FATAL("Could not find all TBB symbols in %s", lib_name);
+        if (utils_close_library(tbb_callbacks.lib_handle)) {
+            LOG_ERR("Could not close %s library", lib_name);
+        }
+        tbb_init_result = -1;
     }
+}
+
+static int init_tbb_callbacks(void) {
+    utils_init_once(&tbb_initialized, init_tbb_callbacks_once);
+    return tbb_init_result;
+}
 
-    return 0;
+void fini_tbb_global_state(void) {
+    if (tbb_callbacks.lib_handle) {
+        if (!utils_close_library(tbb_callbacks.lib_handle)) {
+            tbb_callbacks.lib_handle = NULL;
+            LOG_DEBUG("TBB library closed");
+        } else {
+            LOG_ERR("TBB library cannot be unloaded");
+        }
+    }
 }
 
 static void *tbb_raw_alloc_wrapper(intptr_t pool_id, size_t *raw_bytes) {
@@ -191,6 +220,8 @@ umfScalablePoolParamsCreate(umf_scalable_pool_params_handle_t *hParams) {
 
     params_data->granularity = DEFAULT_GRANULARITY;
     params_data->keep_all_memory = false;
+    strncpy(params_data->name, DEFAULT_NAME, sizeof(params_data->name) - 1);
+    params_data->name[sizeof(params_data->name) - 1] = '\0';
 
     *hParams = (umf_scalable_pool_params_handle_t)params_data;
 
@@ -240,8 +271,54 @@ umfScalablePoolParamsSetKeepAllMemory(umf_scalable_pool_params_handle_t hParams,
     return UMF_RESULT_SUCCESS;
 }
 
+umf_result_t
+umfScalablePoolParamsSetName(umf_scalable_pool_params_handle_t hParams,
+                             const char *name) {
+    if (!hParams) {
+        LOG_ERR("scalable pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (!name) {
+        LOG_ERR("name is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    strncpy(hParams->name, name, sizeof(hParams->name) - 1);
+    hParams->name[sizeof(hParams->name) - 1] = '\0';
+
+    return UMF_RESULT_SUCCESS;
+}
+
 static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
-                                        void *params, void **pool) {
+                                        const void *params, void **pool) {
+    tbb_memory_pool_t *pool_data =
+        umf_ba_global_alloc(sizeof(tbb_memory_pool_t));
+    if (!pool_data) {
+        LOG_ERR("cannot allocate memory for metadata");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    memset(pool_data, 0, sizeof(*pool_data));
+    pool_data->mem_provider = provider;
+
+    if (params) {
+        pool_data->params = *(const umf_scalable_pool_params_t *)params;
+    } else {
+        // Set default values
+        memset(&pool_data->params, 0, sizeof(pool_data->params));
+        pool_data->params.granularity = DEFAULT_GRANULARITY;
+        pool_data->params.keep_all_memory = false;
+        strncpy(pool_data->params.name, DEFAULT_NAME,
+                sizeof(pool_data->params.name) - 1);
+    }
+
+    *pool = (void *)pool_data;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t tbb_pool_post_initialize(void *pool) {
     tbb_mem_pool_policy_t policy = {.pAlloc = tbb_raw_alloc_wrapper,
                                     .pFree = tbb_raw_free_wrapper,
                                     .granularity = DEFAULT_GRANULARITY,
@@ -250,49 +327,55 @@ static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
                                     .keep_all_memory = false,
                                     .reserved = 0};
 
-    if (params) {
-        umf_scalable_pool_params_handle_t scalable_params =
-            (umf_scalable_pool_params_handle_t)params;
-        policy.granularity = scalable_params->granularity;
-        policy.keep_all_memory = scalable_params->keep_all_memory;
-    }
+    assert(pool);
+    tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
 
-    tbb_memory_pool_t *pool_data =
-        umf_ba_global_alloc(sizeof(tbb_memory_pool_t));
-    if (!pool_data) {
-        LOG_ERR("cannot allocate memory for metadata");
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
+    const umf_scalable_pool_params_t *scalable_params = &pool_data->params;
+    const char *pool_name = scalable_params->name;
+
+    // Use stored params
+    policy.granularity = scalable_params->granularity;
+    policy.keep_all_memory = scalable_params->keep_all_memory;
 
-    int ret = init_tbb_callbacks(&pool_data->tbb_callbacks);
+    snprintf(pool_data->name, sizeof(pool_data->name), "%s", pool_name);
+
+    umf_result_t res = UMF_RESULT_SUCCESS;
+    int ret = init_tbb_callbacks();
     if (ret != 0) {
-        LOG_ERR("loading TBB symbols failed");
-        return UMF_RESULT_ERROR_UNKNOWN;
+        LOG_FATAL("loading TBB symbols failed");
+        res = UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
+        goto err_tbb_init;
     }
 
-    pool_data->mem_provider = provider;
-    ret = pool_data->tbb_callbacks.pool_create_v1((intptr_t)pool_data, &policy,
-                                                  &(pool_data->tbb_pool));
+    ret = tbb_callbacks.pool_create_v1((intptr_t)pool_data, &policy,
+                                       &(pool_data->tbb_pool));
     if (ret != 0 /* TBBMALLOC_OK */) {
-        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+        res = UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+        goto err_tbb_init;
     }
 
-    *pool = (void *)pool_data;
+    return res;
 
-    return UMF_RESULT_SUCCESS;
+err_tbb_init:
+    umf_ba_global_free(pool_data);
+    return res;
 }
 
-static void tbb_pool_finalize(void *pool) {
+static umf_result_t tbb_pool_finalize(void *pool) {
     tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
-    pool_data->tbb_callbacks.pool_destroy(pool_data->tbb_pool);
-    utils_close_library(pool_data->tbb_callbacks.lib_handle);
+    umf_result_t ret = UMF_RESULT_SUCCESS;
+    if (!tbb_callbacks.pool_destroy(pool_data->tbb_pool)) {
+        LOG_ERR("TBB pool destroy failed");
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+    }
     umf_ba_global_free(pool_data);
+    return ret;
 }
 
 static void *tbb_malloc(void *pool, size_t size) {
     tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
     TLS_last_allocation_error = UMF_RESULT_SUCCESS;
-    void *ptr = pool_data->tbb_callbacks.pool_malloc(pool_data->tbb_pool, size);
+    void *ptr = tbb_callbacks.pool_malloc(pool_data->tbb_pool, size);
     if (ptr == NULL) {
         if (TLS_last_allocation_error == UMF_RESULT_SUCCESS) {
             TLS_last_allocation_error = UMF_RESULT_ERROR_UNKNOWN;
@@ -319,8 +402,7 @@ static void *tbb_calloc(void *pool, size_t num, size_t size) {
 static void *tbb_realloc(void *pool, void *ptr, size_t size) {
     tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
     TLS_last_allocation_error = UMF_RESULT_SUCCESS;
-    void *new_ptr =
-        pool_data->tbb_callbacks.pool_realloc(pool_data->tbb_pool, ptr, size);
+    void *new_ptr = tbb_callbacks.pool_realloc(pool_data->tbb_pool, ptr, size);
     if (new_ptr == NULL) {
         if (TLS_last_allocation_error == UMF_RESULT_SUCCESS) {
             TLS_last_allocation_error = UMF_RESULT_ERROR_UNKNOWN;
@@ -334,8 +416,8 @@ static void *tbb_realloc(void *pool, void *ptr, size_t size) {
 static void *tbb_aligned_malloc(void *pool, size_t size, size_t alignment) {
     tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
     TLS_last_allocation_error = UMF_RESULT_SUCCESS;
-    void *ptr = pool_data->tbb_callbacks.pool_aligned_malloc(
-        pool_data->tbb_pool, size, alignment);
+    void *ptr =
+        tbb_callbacks.pool_aligned_malloc(pool_data->tbb_pool, size, alignment);
     if (ptr == NULL) {
         if (TLS_last_allocation_error == UMF_RESULT_SUCCESS) {
             TLS_last_allocation_error = UMF_RESULT_ERROR_UNKNOWN;
@@ -360,7 +442,7 @@ static umf_result_t tbb_free(void *pool, void *ptr) {
     utils_annotate_release(pool);
 
     tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
-    if (pool_data->tbb_callbacks.pool_free(pool_data->tbb_pool, ptr)) {
+    if (tbb_callbacks.pool_free(pool_data->tbb_pool, ptr)) {
         return UMF_RESULT_SUCCESS;
     }
 
@@ -371,9 +453,15 @@ static umf_result_t tbb_free(void *pool, void *ptr) {
     return UMF_RESULT_ERROR_UNKNOWN;
 }
 
-static size_t tbb_malloc_usable_size(void *pool, void *ptr) {
+static umf_result_t tbb_malloc_usable_size(void *pool, const void *ptr,
+                                           size_t *size) {
     tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
-    return pool_data->tbb_callbacks.pool_msize(pool_data->tbb_pool, ptr);
+    if (!size) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    // Remove the 'const' qualifier because the TBB pool_msize function requires a non-const pointer.
+    *size = tbb_callbacks.pool_msize(pool_data->tbb_pool, (void *)ptr);
+    return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t tbb_get_last_allocation_error(void *pool) {
@@ -381,8 +469,51 @@ static umf_result_t tbb_get_last_allocation_error(void *pool) {
     return TLS_last_allocation_error;
 }
 
+static umf_result_t
+CTL_RUNNABLE_HANDLER(post_initialize)(void *ctx, umf_ctl_query_source_t source,
+                                      void *arg, size_t size,
+                                      umf_ctl_index_utlist_t *indexes) {
+    (void)source;
+    (void)arg;
+    (void)size;
+    (void)indexes;
+    return tbb_pool_post_initialize(ctx);
+}
+
+static void initialize_pool_ctl(void) {
+    pool_scallable_ctl_root.root[pool_scallable_ctl_root.first_free++] =
+        (umf_ctl_node_t){
+            .name = "post_initialize",
+            .type = CTL_NODE_LEAF,
+            .runnable_cb = CTL_RUNNABLE_HANDLER(post_initialize),
+        };
+}
+
+static umf_result_t pool_ctl(void *hPool, umf_ctl_query_source_t operationType,
+                             const char *name, void *arg, size_t size,
+                             umf_ctl_query_type_t query_type, va_list args) {
+    (void)operationType; // unused
+
+    utils_init_once(&ctl_initialized, initialize_pool_ctl);
+    return ctl_query(&pool_scallable_ctl_root, hPool, CTL_QUERY_PROGRAMMATIC,
+                     name, query_type, arg, size, args);
+}
+
+static umf_result_t scalable_get_name(void *pool, const char **name) {
+    if (!name) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    if (pool == NULL) {
+        *name = DEFAULT_NAME;
+        return UMF_RESULT_SUCCESS;
+    }
+    tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
+    *name = pool_data->name;
+    return UMF_RESULT_SUCCESS;
+}
+
 static umf_memory_pool_ops_t UMF_SCALABLE_POOL_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_POOL_OPS_VERSION_CURRENT,
     .initialize = tbb_pool_initialize,
     .finalize = tbb_pool_finalize,
     .malloc = tbb_malloc,
@@ -391,8 +522,12 @@ static umf_memory_pool_ops_t UMF_SCALABLE_POOL_OPS = {
     .aligned_malloc = tbb_aligned_malloc,
     .malloc_usable_size = tbb_malloc_usable_size,
     .free = tbb_free,
-    .get_last_allocation_error = tbb_get_last_allocation_error};
+    .get_last_allocation_error = tbb_get_last_allocation_error,
+    .ext_ctl = pool_ctl,
+    .get_name = scalable_get_name,
+    .ext_trim_memory = NULL, // not supported
+};
 
-umf_memory_pool_ops_t *umfScalablePoolOps(void) {
+const umf_memory_pool_ops_t *umfScalablePoolOps(void) {
     return &UMF_SCALABLE_POOL_OPS;
 }
diff --git a/src/pool/pool_scalable_internal.h b/src/pool/pool_scalable_internal.h
new file mode 100644
index 0000000000..752cda8a40
--- /dev/null
+++ b/src/pool/pool_scalable_internal.h
@@ -0,0 +1,15 @@
+/*
+ *
+ * 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
+ *
+ */
+
+#ifndef UMF_POOL_SCALABLE_INTERNAL_H
+#define UMF_POOL_SCALABLE_INTERNAL_H 1
+
+void fini_tbb_global_state(void);
+
+#endif /* UMF_POOL_SCALABLE_INTERNAL_H */
diff --git a/src/provider/provider_coarse.c b/src/provider/provider_coarse.c
deleted file mode 100644
index c3027b91d7..0000000000
--- a/src/provider/provider_coarse.c
+++ /dev/null
@@ -1,1707 +0,0 @@
-/*
- * Copyright (C) 2023-2024 Intel Corporation
- *
- * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-*/
-
-#include <assert.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <umf/providers/provider_coarse.h>
-
-#include "base_alloc_global.h"
-#include "memory_provider_internal.h"
-#include "ravl.h"
-#include "utils_common.h"
-#include "utils_concurrency.h"
-#include "utils_log.h"
-
-#define COARSE_BASE_NAME "coarse"
-
-#define IS_ORIGIN_OF_BLOCK(origin, block)                                      \
-    (((uintptr_t)(block)->data >= (uintptr_t)(origin)->data) &&                \
-     ((uintptr_t)(block)->data + (block)->size <=                              \
-      (uintptr_t)(origin)->data + (origin)->size))
-
-typedef struct coarse_memory_provider_t {
-    umf_memory_provider_handle_t upstream_memory_provider;
-
-    // destroy upstream_memory_provider in finalize()
-    bool destroy_upstream_memory_provider;
-
-    // memory allocation strategy
-    coarse_memory_provider_strategy_t allocation_strategy;
-
-    void *init_buffer;
-
-    size_t used_size;
-    size_t alloc_size;
-
-    // upstream_blocks - tree of all blocks allocated from the upstream provider
-    struct ravl *upstream_blocks;
-
-    // all_blocks - tree of all blocks - sorted by an address of data
-    struct ravl *all_blocks;
-
-    // free_blocks - tree of free blocks - sorted by a size of data,
-    // each node contains a pointer (ravl_free_blocks_head_t)
-    // to the head of the list of free blocks of the same size
-    struct ravl *free_blocks;
-
-    struct utils_mutex_t lock;
-
-    // Name of the provider with the upstream provider:
-    // "coarse (<name_of_upstream_provider>)"
-    // for example: "coarse (L0)"
-    char *name;
-
-    // Set to true if the free() operation of the upstream memory provider is not supported
-    // (i.e. if (umfMemoryProviderFree(upstream_memory_provider, NULL, 0) == UMF_RESULT_ERROR_NOT_SUPPORTED)
-    bool disable_upstream_provider_free;
-} coarse_memory_provider_t;
-
-typedef struct ravl_node ravl_node_t;
-
-typedef enum check_free_blocks_t {
-    CHECK_ONLY_THE_FIRST_BLOCK = 0,
-    CHECK_ALL_BLOCKS_OF_SIZE,
-} check_free_blocks_t;
-
-typedef struct block_t {
-    size_t size;
-    unsigned char *data;
-    bool used;
-
-    // Node in the list of free blocks of the same size pointing to this block.
-    // The list is located in the (coarse_provider->free_blocks) RAVL tree.
-    struct ravl_free_blocks_elem_t *free_list_ptr;
-} block_t;
-
-// A general node in a RAVL tree.
-// 1) coarse_provider->all_blocks RAVL tree (tree of all blocks - sorted by an address of data):
-//    key   - pointer (block_t->data) to the beginning of the block data
-//    value - pointer (block_t) to the block of the allocation
-// 2) coarse_provider->free_blocks RAVL tree (tree of free blocks - sorted by a size of data):
-//    key   - size of the allocation (block_t->size)
-//    value - pointer (ravl_free_blocks_head_t) to the head of the list of free blocks of the same size
-typedef struct ravl_data_t {
-    uintptr_t key;
-    void *value;
-} ravl_data_t;
-
-// The head of the list of free blocks of the same size.
-typedef struct ravl_free_blocks_head_t {
-    struct ravl_free_blocks_elem_t *head;
-} ravl_free_blocks_head_t;
-
-// The node of the list of free blocks of the same size
-typedef struct ravl_free_blocks_elem_t {
-    struct block_t *block;
-    struct ravl_free_blocks_elem_t *next;
-    struct ravl_free_blocks_elem_t *prev;
-} ravl_free_blocks_elem_t;
-
-// The compare function of a RAVL tree
-static int coarse_ravl_comp(const void *lhs, const void *rhs) {
-    const ravl_data_t *lhs_ravl = (const ravl_data_t *)lhs;
-    const ravl_data_t *rhs_ravl = (const ravl_data_t *)rhs;
-
-    if (lhs_ravl->key < rhs_ravl->key) {
-        return -1;
-    }
-
-    if (lhs_ravl->key > rhs_ravl->key) {
-        return 1;
-    }
-
-    // lhs_ravl->key == rhs_ravl->key
-    return 0;
-}
-
-static inline block_t *get_node_block(ravl_node_t *node) {
-    ravl_data_t *node_data = ravl_data(node);
-    assert(node_data);
-    assert(node_data->value);
-    return node_data->value;
-}
-
-static inline ravl_node_t *get_node_prev(ravl_node_t *node) {
-    return ravl_node_predecessor(node);
-}
-
-static inline ravl_node_t *get_node_next(ravl_node_t *node) {
-    return ravl_node_successor(node);
-}
-
-#ifndef NDEBUG
-static block_t *get_block_prev(ravl_node_t *node) {
-    ravl_node_t *ravl_prev = ravl_node_predecessor(node);
-    if (!ravl_prev) {
-        return NULL;
-    }
-
-    return get_node_block(ravl_prev);
-}
-
-static block_t *get_block_next(ravl_node_t *node) {
-    ravl_node_t *ravl_next = ravl_node_successor(node);
-    if (!ravl_next) {
-        return NULL;
-    }
-
-    return get_node_block(ravl_next);
-}
-#endif /* NDEBUG */
-
-static bool is_same_origin(struct ravl *upstream_blocks, block_t *block1,
-                           block_t *block2) {
-    ravl_data_t rdata1 = {(uintptr_t)block1->data, NULL};
-    ravl_node_t *ravl_origin1 =
-        ravl_find(upstream_blocks, &rdata1, RAVL_PREDICATE_LESS_EQUAL);
-    assert(ravl_origin1);
-
-    block_t *origin1 = get_node_block(ravl_origin1);
-    assert(IS_ORIGIN_OF_BLOCK(origin1, block1));
-
-    return (IS_ORIGIN_OF_BLOCK(origin1, block2));
-}
-
-// The functions "coarse_ravl_*" handle lists of blocks:
-// - coarse_provider->all_blocks and coarse_provider->upstream_blocks
-// sorted by a pointer (block_t->data) to the beginning of the block data.
-//
-// coarse_ravl_add_new - allocate and add a new block to the tree
-// and link this block to the next and the previous one.
-static block_t *coarse_ravl_add_new(struct ravl *rtree, unsigned char *data,
-                                    size_t size, ravl_node_t **node) {
-    assert(rtree);
-    assert(data);
-    assert(size);
-
-    // TODO add valgrind annotations
-    block_t *block = umf_ba_global_alloc(sizeof(*block));
-    if (block == NULL) {
-        return NULL;
-    }
-
-    block->data = data;
-    block->size = size;
-    block->free_list_ptr = NULL;
-
-    ravl_data_t rdata = {(uintptr_t)block->data, block};
-    assert(NULL == ravl_find(rtree, &data, RAVL_PREDICATE_EQUAL));
-    int ret = ravl_emplace_copy(rtree, &rdata);
-    if (ret) {
-        umf_ba_global_free(block);
-        return NULL;
-    }
-
-    ravl_node_t *new_node = ravl_find(rtree, &rdata, RAVL_PREDICATE_EQUAL);
-    assert(NULL != new_node);
-
-    if (node) {
-        *node = new_node;
-    }
-
-    return block;
-}
-
-// coarse_ravl_find_node - find the node in the tree
-static ravl_node_t *coarse_ravl_find_node(struct ravl *rtree, void *ptr) {
-    ravl_data_t data = {(uintptr_t)ptr, NULL};
-    return ravl_find(rtree, &data, RAVL_PREDICATE_EQUAL);
-}
-
-// coarse_ravl_rm - remove the block from the tree
-static block_t *coarse_ravl_rm(struct ravl *rtree, void *ptr) {
-    ravl_data_t data = {(uintptr_t)ptr, NULL};
-    ravl_node_t *node;
-    node = ravl_find(rtree, &data, RAVL_PREDICATE_EQUAL);
-    if (node) {
-        ravl_data_t *node_data = ravl_data(node);
-        assert(node_data);
-        block_t *block = node_data->value;
-        assert(block);
-        ravl_remove(rtree, node);
-        assert(NULL == ravl_find(rtree, &data, RAVL_PREDICATE_EQUAL));
-        return block;
-    }
-    return NULL;
-}
-
-// The functions "node_list_*" handle lists of free blocks of the same size.
-// The heads (ravl_free_blocks_head_t) of those lists are stored in nodes of
-// the coarse_provider->free_blocks RAVL tree.
-//
-// node_list_add - add a free block to the list of free blocks of the same size
-static ravl_free_blocks_elem_t *
-node_list_add(ravl_free_blocks_head_t *head_node, struct block_t *block) {
-    assert(head_node);
-    assert(block);
-
-    ravl_free_blocks_elem_t *node = umf_ba_global_alloc(sizeof(*node));
-    if (node == NULL) {
-        return NULL;
-    }
-
-    if (head_node->head) {
-        head_node->head->prev = node;
-    }
-
-    node->block = block;
-    node->next = head_node->head;
-    node->prev = NULL;
-    head_node->head = node;
-
-    return node;
-}
-
-// node_list_rm - remove the given free block from the list of free blocks of the same size
-static block_t *node_list_rm(ravl_free_blocks_head_t *head_node,
-                             ravl_free_blocks_elem_t *node) {
-    assert(head_node);
-    assert(node);
-
-    if (!head_node->head) {
-        return NULL;
-    }
-
-    if (node == head_node->head) {
-        assert(node->prev == NULL);
-        head_node->head = node->next;
-    }
-
-    ravl_free_blocks_elem_t *node_next = node->next;
-    ravl_free_blocks_elem_t *node_prev = node->prev;
-    if (node_next) {
-        node_next->prev = node_prev;
-    }
-
-    if (node_prev) {
-        node_prev->next = node_next;
-    }
-
-    struct block_t *block = node->block;
-    block->free_list_ptr = NULL;
-    umf_ba_global_free(node);
-
-    return block;
-}
-
-// node_list_rm_first - remove the first free block from the list of free blocks of the same size only if it can be properly aligned
-static block_t *node_list_rm_first(ravl_free_blocks_head_t *head_node,
-                                   size_t alignment) {
-    assert(head_node);
-
-    if (!head_node->head) {
-        return NULL;
-    }
-
-    ravl_free_blocks_elem_t *node = head_node->head;
-    assert(node->prev == NULL);
-    struct block_t *block = node->block;
-
-    if (IS_NOT_ALIGNED(block->size, alignment)) {
-        return NULL;
-    }
-
-    if (node->next) {
-        node->next->prev = NULL;
-    }
-
-    head_node->head = node->next;
-    block->free_list_ptr = NULL;
-    umf_ba_global_free(node);
-
-    return block;
-}
-
-// node_list_rm_with_alignment - remove the first free block with the correct alignment from the list of free blocks of the same size
-static block_t *node_list_rm_with_alignment(ravl_free_blocks_head_t *head_node,
-                                            size_t alignment) {
-    assert(head_node);
-
-    if (!head_node->head) {
-        return NULL;
-    }
-
-    assert(((ravl_free_blocks_elem_t *)head_node->head)->prev == NULL);
-
-    ravl_free_blocks_elem_t *node;
-    for (node = head_node->head; node != NULL; node = node->next) {
-        if (IS_ALIGNED(node->block->size, alignment)) {
-            return node_list_rm(head_node, node);
-        }
-    }
-
-    return NULL;
-}
-
-// The functions "free_blocks_*" handle the coarse_provider->free_blocks RAVL tree
-// sorted by a size of the allocation (block_t->size).
-// This is a tree of heads (ravl_free_blocks_head_t) of lists of free blocks of the same size.
-//
-// free_blocks_add - add a free block to the list of free blocks of the same size
-static int free_blocks_add(struct ravl *free_blocks, block_t *block) {
-    ravl_free_blocks_head_t *head_node = NULL;
-    int rv;
-
-    ravl_data_t head_node_data = {(uintptr_t)block->size, NULL};
-    ravl_node_t *node;
-    node = ravl_find(free_blocks, &head_node_data, RAVL_PREDICATE_EQUAL);
-    if (node) {
-        ravl_data_t *node_data = ravl_data(node);
-        assert(node_data);
-        head_node = node_data->value;
-        assert(head_node);
-    } else { // no head_node
-        head_node = umf_ba_global_alloc(sizeof(*head_node));
-        if (!head_node) {
-            return -1;
-        }
-
-        head_node->head = NULL;
-
-        ravl_data_t data = {(uintptr_t)block->size, head_node};
-        rv = ravl_emplace_copy(free_blocks, &data);
-        if (rv) {
-            umf_ba_global_free(head_node);
-            return -1;
-        }
-    }
-
-    block->free_list_ptr = node_list_add(head_node, block);
-    if (!block->free_list_ptr) {
-        return -1;
-    }
-
-    assert(block->free_list_ptr->block->size == block->size);
-
-    return 0;
-}
-
-// free_blocks_rm_ge - remove the first free block of a size greater or equal to the given size only if it can be properly aligned
-// If it was the last block, the head node is freed and removed from the tree.
-// It is used during memory allocation (looking for a free block).
-static block_t *free_blocks_rm_ge(struct ravl *free_blocks, size_t size,
-                                  size_t alignment,
-                                  check_free_blocks_t check_blocks) {
-    ravl_data_t data = {(uintptr_t)size, NULL};
-    ravl_node_t *node;
-    node = ravl_find(free_blocks, &data, RAVL_PREDICATE_GREATER_EQUAL);
-    if (!node) {
-        return NULL;
-    }
-
-    ravl_data_t *node_data = ravl_data(node);
-    assert(node_data);
-    assert(node_data->key >= size);
-
-    ravl_free_blocks_head_t *head_node = node_data->value;
-    assert(head_node);
-
-    block_t *block;
-    switch (check_blocks) {
-    case CHECK_ONLY_THE_FIRST_BLOCK:
-        block = node_list_rm_first(head_node, alignment);
-        break;
-    case CHECK_ALL_BLOCKS_OF_SIZE:
-        block = node_list_rm_with_alignment(head_node, alignment);
-        break;
-    // wrong value of check_blocks
-    default:
-        abort();
-    }
-
-    if (head_node->head == NULL) {
-        umf_ba_global_free(head_node);
-        ravl_remove(free_blocks, node);
-    }
-
-    return block;
-}
-
-// free_blocks_rm_node - remove the free block pointed by the given node.
-// If it was the last block, the head node is freed and removed from the tree.
-// It is used during merging free blocks and destroying the coarse_provider->free_blocks tree.
-static block_t *free_blocks_rm_node(struct ravl *free_blocks,
-                                    ravl_free_blocks_elem_t *node) {
-    assert(free_blocks);
-    assert(node);
-    size_t size = node->block->size;
-    ravl_data_t data = {(uintptr_t)size, NULL};
-    ravl_node_t *ravl_node;
-    ravl_node = ravl_find(free_blocks, &data, RAVL_PREDICATE_EQUAL);
-    assert(ravl_node);
-
-    ravl_data_t *node_data = ravl_data(ravl_node);
-    assert(node_data);
-    assert(node_data->key == size);
-
-    ravl_free_blocks_head_t *head_node = node_data->value;
-    assert(head_node);
-
-    block_t *block = node_list_rm(head_node, node);
-
-    if (head_node->head == NULL) {
-        umf_ba_global_free(head_node);
-        ravl_remove(free_blocks, ravl_node);
-    }
-
-    return block;
-}
-
-// user_block_merge - merge two blocks from one of two lists of user blocks: all_blocks or free_blocks
-static umf_result_t user_block_merge(coarse_memory_provider_t *coarse_provider,
-                                     ravl_node_t *node1, ravl_node_t *node2,
-                                     bool used, ravl_node_t **merged_node) {
-    assert(node1);
-    assert(node2);
-    assert(node1 == get_node_prev(node2));
-    assert(node2 == get_node_next(node1));
-    assert(merged_node);
-
-    *merged_node = NULL;
-
-    struct ravl *upstream_blocks = coarse_provider->upstream_blocks;
-    struct ravl *all_blocks = coarse_provider->all_blocks;
-    struct ravl *free_blocks = coarse_provider->free_blocks;
-
-    block_t *block1 = get_node_block(node1);
-    block_t *block2 = get_node_block(node2);
-    assert(block1->data < block2->data);
-
-    bool same_used = ((block1->used == used) && (block2->used == used));
-    bool contignous_data = (block1->data + block1->size == block2->data);
-    bool same_origin = is_same_origin(upstream_blocks, block1, block2);
-
-    // check if blocks can be merged
-    if (!same_used || !contignous_data || !same_origin) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    if (block1->free_list_ptr) {
-        free_blocks_rm_node(free_blocks, block1->free_list_ptr);
-        block1->free_list_ptr = NULL;
-    }
-
-    if (block2->free_list_ptr) {
-        free_blocks_rm_node(free_blocks, block2->free_list_ptr);
-        block2->free_list_ptr = NULL;
-    }
-
-    // update the size
-    block1->size += block2->size;
-
-    block_t *block_rm = coarse_ravl_rm(all_blocks, block2->data);
-    assert(block_rm == block2);
-    (void)block_rm; // WA for unused variable error
-    umf_ba_global_free(block2);
-
-    *merged_node = node1;
-
-    return UMF_RESULT_SUCCESS;
-}
-
-// free_block_merge_with_prev - merge the given free block
-// with the previous one if both are unused and have continuous data.
-// Remove the merged block from the tree of free blocks.
-static ravl_node_t *
-free_block_merge_with_prev(coarse_memory_provider_t *coarse_provider,
-                           ravl_node_t *node) {
-    ravl_node_t *node_prev = get_node_prev(node);
-    if (!node_prev) {
-        return node;
-    }
-
-    ravl_node_t *merged_node = NULL;
-    umf_result_t umf_result =
-        user_block_merge(coarse_provider, node_prev, node, false, &merged_node);
-    if (umf_result != UMF_RESULT_SUCCESS) {
-        return node;
-    }
-
-    assert(merged_node != NULL);
-
-    return merged_node;
-}
-
-// free_block_merge_with_next - merge the given free block
-// with the next one if both are unused and have continuous data.
-// Remove the merged block from the tree of free blocks.
-static ravl_node_t *
-free_block_merge_with_next(coarse_memory_provider_t *coarse_provider,
-                           ravl_node_t *node) {
-    ravl_node_t *node_next = get_node_next(node);
-    if (!node_next) {
-        return node;
-    }
-
-    ravl_node_t *merged_node = NULL;
-    umf_result_t umf_result =
-        user_block_merge(coarse_provider, node, node_next, false, &merged_node);
-    if (umf_result != UMF_RESULT_SUCCESS) {
-        return node;
-    }
-
-    assert(merged_node != NULL);
-
-    return merged_node;
-}
-
-// upstream_block_merge - merge the given two upstream blocks
-static umf_result_t
-upstream_block_merge(coarse_memory_provider_t *coarse_provider,
-                     ravl_node_t *node1, ravl_node_t *node2,
-                     ravl_node_t **merged_node) {
-    assert(node1);
-    assert(node2);
-    assert(merged_node);
-
-    *merged_node = NULL;
-
-    umf_memory_provider_handle_t upstream_provider =
-        coarse_provider->upstream_memory_provider;
-    if (!upstream_provider) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    block_t *block1 = get_node_block(node1);
-    block_t *block2 = get_node_block(node2);
-    assert(block1->data < block2->data);
-
-    bool contignous_data = (block1->data + block1->size == block2->data);
-    if (!contignous_data) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    // check if blocks can be merged by the upstream provider
-    umf_result_t merge_status = umfMemoryProviderAllocationMerge(
-        coarse_provider->upstream_memory_provider, block1->data, block2->data,
-        block1->size + block2->size);
-    if (merge_status != UMF_RESULT_SUCCESS) {
-        return merge_status;
-    }
-
-    // update the size
-    block1->size += block2->size;
-
-    struct ravl *upstream_blocks = coarse_provider->upstream_blocks;
-    block_t *block_rm = coarse_ravl_rm(upstream_blocks, block2->data);
-    assert(block_rm == block2);
-    (void)block_rm; // WA for unused variable error
-    umf_ba_global_free(block2);
-
-    *merged_node = node1;
-
-    return UMF_RESULT_SUCCESS;
-}
-
-// upstream_block_merge_with_prev - merge the given upstream block
-// with the previous one if both have continuous data.
-// Remove the merged block from the tree of upstream blocks.
-static ravl_node_t *
-upstream_block_merge_with_prev(coarse_memory_provider_t *coarse_provider,
-                               ravl_node_t *node) {
-    assert(node);
-
-    ravl_node_t *node_prev = get_node_prev(node);
-    if (!node_prev) {
-        return node;
-    }
-
-    ravl_node_t *merged_node = NULL;
-    umf_result_t umf_result =
-        upstream_block_merge(coarse_provider, node_prev, node, &merged_node);
-    if (umf_result != UMF_RESULT_SUCCESS) {
-        return node;
-    }
-
-    assert(merged_node != NULL);
-
-    return merged_node;
-}
-
-// upstream_block_merge_with_next - merge the given upstream block
-// with the next one if both have continuous data.
-// Remove the merged block from the tree of upstream blocks.
-static ravl_node_t *
-upstream_block_merge_with_next(coarse_memory_provider_t *coarse_provider,
-                               ravl_node_t *node) {
-    assert(node);
-
-    ravl_node_t *node_next = get_node_next(node);
-    if (!node_next) {
-        return node;
-    }
-
-    ravl_node_t *merged_node = NULL;
-    umf_result_t umf_result =
-        upstream_block_merge(coarse_provider, node, node_next, &merged_node);
-    if (umf_result != UMF_RESULT_SUCCESS) {
-        return node;
-    }
-
-    assert(merged_node != NULL);
-
-    return merged_node;
-}
-
-#ifndef NDEBUG // begin of DEBUG code
-
-typedef struct debug_cb_args_t {
-    coarse_memory_provider_t *provider;
-    size_t sum_used;
-    size_t sum_blocks_size;
-    size_t num_all_blocks;
-    size_t num_free_blocks;
-    size_t num_alloc_blocks;
-    size_t sum_alloc_size;
-} debug_cb_args_t;
-
-static void debug_verify_all_blocks_cb(void *data, void *arg) {
-    assert(data);
-    assert(arg);
-
-    ravl_data_t *node_data = data;
-    block_t *block = node_data->value;
-    assert(block);
-
-    debug_cb_args_t *cb_args = (debug_cb_args_t *)arg;
-    coarse_memory_provider_t *provider = cb_args->provider;
-
-    ravl_node_t *node =
-        ravl_find(provider->all_blocks, data, RAVL_PREDICATE_EQUAL);
-    assert(node);
-
-    block_t *block_next = get_block_next(node);
-    block_t *block_prev = get_block_prev(node);
-
-    cb_args->num_all_blocks++;
-    if (!block->used) {
-        cb_args->num_free_blocks++;
-    }
-
-    assert(block->data);
-    assert(block->size > 0);
-
-    // There shouldn't be two adjacent unused blocks
-    // if they are continuous and have the same origin.
-    if (block_prev && !block_prev->used && !block->used &&
-        (block_prev->data + block_prev->size == block->data)) {
-        assert(!is_same_origin(provider->upstream_blocks, block_prev, block));
-    }
-
-    if (block_next && !block_next->used && !block->used &&
-        (block->data + block->size == block_next->data)) {
-        assert(!is_same_origin(provider->upstream_blocks, block, block_next));
-    }
-
-    // data addresses in the list are in ascending order
-    if (block_prev) {
-        assert(block_prev->data < block->data);
-    }
-
-    if (block_next) {
-        assert(block->data < block_next->data);
-    }
-
-    // two block's data should not overlap
-    if (block_next) {
-        assert((block->data + block->size) <= block_next->data);
-    }
-
-    cb_args->sum_blocks_size += block->size;
-    if (block->used) {
-        cb_args->sum_used += block->size;
-    }
-}
-
-static void debug_verify_upstream_blocks_cb(void *data, void *arg) {
-    assert(data);
-    assert(arg);
-
-    ravl_data_t *node_data = data;
-    block_t *alloc = node_data->value;
-    assert(alloc);
-
-    debug_cb_args_t *cb_args = (debug_cb_args_t *)arg;
-    coarse_memory_provider_t *provider = cb_args->provider;
-
-    ravl_node_t *node =
-        ravl_find(provider->upstream_blocks, data, RAVL_PREDICATE_EQUAL);
-    assert(node);
-
-    block_t *alloc_next = get_block_next(node);
-    block_t *alloc_prev = get_block_prev(node);
-
-    cb_args->num_alloc_blocks++;
-    cb_args->sum_alloc_size += alloc->size;
-
-    assert(alloc->data);
-    assert(alloc->size > 0);
-
-    // data addresses in the list are in ascending order
-    if (alloc_prev) {
-        assert(alloc_prev->data < alloc->data);
-    }
-
-    if (alloc_next) {
-        assert(alloc->data < alloc_next->data);
-    }
-
-    // data should not overlap
-    if (alloc_next) {
-        assert((alloc->data + alloc->size) <= alloc_next->data);
-    }
-}
-
-static umf_result_t
-coarse_memory_provider_get_stats(void *provider,
-                                 coarse_memory_provider_stats_t *stats);
-
-static bool debug_check(coarse_memory_provider_t *provider) {
-    assert(provider);
-
-    coarse_memory_provider_stats_t stats = {0};
-    coarse_memory_provider_get_stats(provider, &stats);
-
-    debug_cb_args_t cb_args = {0};
-    cb_args.provider = provider;
-
-    // verify the all_blocks list
-    ravl_foreach(provider->all_blocks, debug_verify_all_blocks_cb, &cb_args);
-
-    assert(cb_args.num_all_blocks == stats.num_all_blocks);
-    assert(cb_args.num_free_blocks == stats.num_free_blocks);
-    assert(cb_args.sum_used == provider->used_size);
-    assert(cb_args.sum_blocks_size == provider->alloc_size);
-    assert(provider->alloc_size >= provider->used_size);
-
-    // verify the upstream_blocks list
-    ravl_foreach(provider->upstream_blocks, debug_verify_upstream_blocks_cb,
-                 &cb_args);
-
-    assert(cb_args.sum_alloc_size == provider->alloc_size);
-    assert(cb_args.num_alloc_blocks == stats.num_upstream_blocks);
-
-    return true;
-}
-#endif /* NDEBUG */ // end of DEBUG code
-
-static umf_result_t
-coarse_add_upstream_block(coarse_memory_provider_t *coarse_provider, void *addr,
-                          size_t size) {
-    ravl_node_t *alloc_node = NULL;
-
-    block_t *alloc = coarse_ravl_add_new(coarse_provider->upstream_blocks, addr,
-                                         size, &alloc_node);
-    if (alloc == NULL) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    block_t *new_block =
-        coarse_ravl_add_new(coarse_provider->all_blocks, addr, size, NULL);
-    if (new_block == NULL) {
-        coarse_ravl_rm(coarse_provider->upstream_blocks, addr);
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    // check if the new upstream block can be merged with its neighbours
-    alloc_node = upstream_block_merge_with_prev(coarse_provider, alloc_node);
-    alloc_node = upstream_block_merge_with_next(coarse_provider, alloc_node);
-
-    new_block->used = true;
-    coarse_provider->alloc_size += size;
-    coarse_provider->used_size += size;
-
-    return UMF_RESULT_SUCCESS;
-}
-
-static umf_result_t
-coarse_memory_provider_set_name(coarse_memory_provider_t *coarse_provider) {
-    if (coarse_provider->upstream_memory_provider == NULL) {
-        // COARSE_BASE_NAME will be used
-        coarse_provider->name = NULL;
-        return UMF_RESULT_SUCCESS;
-    }
-
-    const char *up_name =
-        umfMemoryProviderGetName(coarse_provider->upstream_memory_provider);
-    if (!up_name) {
-        return UMF_RESULT_ERROR_UNKNOWN;
-    }
-
-    size_t length =
-        strlen(COARSE_BASE_NAME) + strlen(up_name) + 3; // + 3 for " ()"
-
-    coarse_provider->name = umf_ba_global_alloc(length + 1); // + 1 for '\0'
-    if (coarse_provider->name == NULL) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    sprintf(coarse_provider->name, "%s (%s)", COARSE_BASE_NAME, up_name);
-
-    return UMF_RESULT_SUCCESS;
-}
-
-// needed for coarse_memory_provider_initialize()
-static umf_result_t coarse_memory_provider_alloc(void *provider, size_t size,
-                                                 size_t alignment,
-                                                 void **resultPtr);
-
-// needed for coarse_memory_provider_initialize()
-static umf_result_t coarse_memory_provider_free(void *provider, void *ptr,
-                                                size_t bytes);
-
-static umf_result_t coarse_memory_provider_initialize(void *params,
-                                                      void **provider) {
-    assert(provider);
-
-    if (params == NULL) {
-        LOG_ERR("coarse provider parameters are missing");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    coarse_memory_provider_params_t *coarse_params =
-        (coarse_memory_provider_params_t *)params;
-
-    // check params
-    if (!coarse_params->upstream_memory_provider ==
-        !coarse_params->init_buffer) {
-        LOG_ERR("either upstream provider or init buffer has to be provided in "
-                "the parameters (exactly one of them)");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    if (coarse_params->init_buffer_size == 0 &&
-        (coarse_params->immediate_init_from_upstream ||
-         coarse_params->init_buffer != NULL)) {
-        LOG_ERR("init_buffer_size has to be greater than 0 if "
-                "immediate_init_from_upstream or init_buffer is set");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    if (coarse_params->init_buffer_size != 0 &&
-        (!coarse_params->immediate_init_from_upstream &&
-         coarse_params->init_buffer == NULL)) {
-        LOG_ERR("init_buffer_size is greater than 0 but none of "
-                "immediate_init_from_upstream nor init_buffer is set");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    if (coarse_params->destroy_upstream_memory_provider &&
-        !coarse_params->upstream_memory_provider) {
-        LOG_ERR("destroy_upstream_memory_provider is true, but an upstream "
-                "provider is not provided");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    coarse_memory_provider_t *coarse_provider =
-        umf_ba_global_alloc(sizeof(*coarse_provider));
-    if (!coarse_provider) {
-        LOG_ERR("out of the host memory");
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    memset(coarse_provider, 0, sizeof(*coarse_provider));
-
-    coarse_provider->upstream_memory_provider =
-        coarse_params->upstream_memory_provider;
-    coarse_provider->destroy_upstream_memory_provider =
-        coarse_params->destroy_upstream_memory_provider;
-    coarse_provider->allocation_strategy = coarse_params->allocation_strategy;
-    coarse_provider->init_buffer = coarse_params->init_buffer;
-
-    if (coarse_provider->upstream_memory_provider) {
-        coarse_provider->disable_upstream_provider_free =
-            umfIsFreeOpDefault(coarse_provider->upstream_memory_provider);
-    } else {
-        coarse_provider->disable_upstream_provider_free = false;
-    }
-
-    umf_result_t umf_result = coarse_memory_provider_set_name(coarse_provider);
-    if (umf_result != UMF_RESULT_SUCCESS) {
-        LOG_ERR("name initialization failed");
-        goto err_free_coarse_provider;
-    }
-
-    // most of the error handling paths below set this error
-    umf_result = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-
-    coarse_provider->upstream_blocks =
-        ravl_new_sized(coarse_ravl_comp, sizeof(ravl_data_t));
-    if (coarse_provider->upstream_blocks == NULL) {
-        LOG_ERR("out of the host memory");
-        goto err_free_name;
-    }
-
-    coarse_provider->free_blocks =
-        ravl_new_sized(coarse_ravl_comp, sizeof(ravl_data_t));
-    if (coarse_provider->free_blocks == NULL) {
-        LOG_ERR("out of the host memory");
-        goto err_delete_ravl_upstream_blocks;
-    }
-
-    coarse_provider->all_blocks =
-        ravl_new_sized(coarse_ravl_comp, sizeof(ravl_data_t));
-    if (coarse_provider->all_blocks == NULL) {
-        LOG_ERR("out of the host memory");
-        goto err_delete_ravl_free_blocks;
-    }
-
-    coarse_provider->alloc_size = 0;
-    coarse_provider->used_size = 0;
-
-    if (utils_mutex_init(&coarse_provider->lock) == NULL) {
-        LOG_ERR("lock initialization failed");
-        umf_result = UMF_RESULT_ERROR_UNKNOWN;
-        goto err_delete_ravl_all_blocks;
-    }
-
-    if (coarse_params->upstream_memory_provider &&
-        coarse_params->immediate_init_from_upstream) {
-        // allocate and immediately deallocate memory using the upstream provider
-        void *init_buffer = NULL;
-        coarse_memory_provider_alloc(
-            coarse_provider, coarse_params->init_buffer_size, 0, &init_buffer);
-        if (init_buffer == NULL) {
-            goto err_destroy_mutex;
-        }
-
-        coarse_memory_provider_free(coarse_provider, init_buffer,
-                                    coarse_params->init_buffer_size);
-
-    } else if (coarse_params->init_buffer) {
-        umf_result = coarse_add_upstream_block(coarse_provider,
-                                               coarse_provider->init_buffer,
-                                               coarse_params->init_buffer_size);
-        if (umf_result != UMF_RESULT_SUCCESS) {
-            goto err_destroy_mutex;
-        }
-
-        LOG_DEBUG("coarse_ALLOC (init_buffer) %zu used %zu alloc %zu",
-                  coarse_params->init_buffer_size, coarse_provider->used_size,
-                  coarse_provider->alloc_size);
-
-        coarse_memory_provider_free(coarse_provider,
-                                    coarse_provider->init_buffer,
-                                    coarse_params->init_buffer_size);
-    }
-
-    assert(coarse_provider->used_size == 0);
-    assert(coarse_provider->alloc_size == coarse_params->init_buffer_size);
-    assert(debug_check(coarse_provider));
-
-    *provider = coarse_provider;
-
-    return UMF_RESULT_SUCCESS;
-
-err_destroy_mutex:
-    utils_mutex_destroy_not_free(&coarse_provider->lock);
-err_delete_ravl_all_blocks:
-    ravl_delete(coarse_provider->all_blocks);
-err_delete_ravl_free_blocks:
-    ravl_delete(coarse_provider->free_blocks);
-err_delete_ravl_upstream_blocks:
-    ravl_delete(coarse_provider->upstream_blocks);
-err_free_name:
-    umf_ba_global_free(coarse_provider->name);
-err_free_coarse_provider:
-    umf_ba_global_free(coarse_provider);
-    return umf_result;
-}
-
-static void coarse_ravl_cb_rm_upstream_blocks_node(void *data, void *arg) {
-    assert(data);
-    assert(arg);
-
-    coarse_memory_provider_t *coarse_provider =
-        (struct coarse_memory_provider_t *)arg;
-    ravl_data_t *node_data = data;
-    block_t *alloc = node_data->value;
-    assert(alloc);
-
-    if (coarse_provider->upstream_memory_provider &&
-        !coarse_provider->disable_upstream_provider_free) {
-        // We continue to deallocate alloc blocks even if the upstream provider doesn't return success.
-        umfMemoryProviderFree(coarse_provider->upstream_memory_provider,
-                              alloc->data, alloc->size);
-    }
-
-    assert(coarse_provider->alloc_size >= alloc->size);
-    coarse_provider->alloc_size -= alloc->size;
-
-    umf_ba_global_free(alloc);
-}
-
-static void coarse_ravl_cb_rm_all_blocks_node(void *data, void *arg) {
-    assert(data);
-    assert(arg);
-
-    coarse_memory_provider_t *coarse_provider =
-        (struct coarse_memory_provider_t *)arg;
-    ravl_data_t *node_data = data;
-    block_t *block = node_data->value;
-    assert(block);
-
-    if (block->used) {
-        assert(coarse_provider->used_size >= block->size);
-        coarse_provider->used_size -= block->size;
-    }
-
-    if (block->free_list_ptr) {
-        free_blocks_rm_node(coarse_provider->free_blocks, block->free_list_ptr);
-    }
-
-    umf_ba_global_free(block);
-}
-
-static void coarse_memory_provider_finalize(void *provider) {
-    coarse_memory_provider_t *coarse_provider =
-        (struct coarse_memory_provider_t *)provider;
-
-    utils_mutex_destroy_not_free(&coarse_provider->lock);
-
-    ravl_foreach(coarse_provider->all_blocks, coarse_ravl_cb_rm_all_blocks_node,
-                 coarse_provider);
-    assert(coarse_provider->used_size == 0);
-
-    ravl_foreach(coarse_provider->upstream_blocks,
-                 coarse_ravl_cb_rm_upstream_blocks_node, coarse_provider);
-    assert(coarse_provider->alloc_size == 0);
-
-    ravl_delete(coarse_provider->upstream_blocks);
-    ravl_delete(coarse_provider->all_blocks);
-    ravl_delete(coarse_provider->free_blocks);
-
-    umf_ba_global_free(coarse_provider->name);
-
-    if (coarse_provider->destroy_upstream_memory_provider &&
-        coarse_provider->upstream_memory_provider) {
-        umfMemoryProviderDestroy(coarse_provider->upstream_memory_provider);
-    }
-
-    umf_ba_global_free(coarse_provider);
-}
-
-static umf_result_t
-create_aligned_block(coarse_memory_provider_t *coarse_provider,
-                     size_t orig_size, size_t alignment, block_t **current) {
-    (void)orig_size; // unused in the Release version
-    int rv;
-
-    block_t *curr = *current;
-
-    // In case of non-zero alignment create an aligned block what would be further used.
-    uintptr_t orig_data = (uintptr_t)curr->data;
-    uintptr_t aligned_data = ALIGN_UP(orig_data, alignment);
-    size_t padding = aligned_data - orig_data;
-    if (alignment > 0 && padding > 0) {
-        block_t *aligned_block = coarse_ravl_add_new(
-            coarse_provider->all_blocks, curr->data + padding,
-            curr->size - padding, NULL);
-        if (aligned_block == NULL) {
-            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-        }
-
-        curr->used = false;
-        curr->size = padding;
-
-        rv = free_blocks_add(coarse_provider->free_blocks, curr);
-        if (rv) {
-            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-        }
-
-        // use aligned block
-        *current = aligned_block;
-        assert((*current)->size >= orig_size);
-    }
-
-    return UMF_RESULT_SUCCESS;
-}
-
-// Split the current block and put the new block after the one that we use.
-static umf_result_t
-split_current_block(coarse_memory_provider_t *coarse_provider, block_t *curr,
-                    size_t size) {
-    ravl_node_t *new_node = NULL;
-
-    block_t *new_block =
-        coarse_ravl_add_new(coarse_provider->all_blocks, curr->data + size,
-                            curr->size - size, &new_node);
-    if (new_block == NULL) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    new_block->used = false;
-
-    int rv =
-        free_blocks_add(coarse_provider->free_blocks, get_node_block(new_node));
-    if (rv) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    return UMF_RESULT_SUCCESS;
-}
-
-static block_t *
-find_free_block(struct ravl *free_blocks, size_t size, size_t alignment,
-                coarse_memory_provider_strategy_t allocation_strategy) {
-    block_t *block;
-
-    switch (allocation_strategy) {
-    case UMF_COARSE_MEMORY_STRATEGY_FASTEST:
-        // Always allocate a free block of the (size + alignment) size
-        // and later cut out the properly aligned part leaving two remaining parts.
-        return free_blocks_rm_ge(free_blocks, size + alignment, 0,
-                                 CHECK_ONLY_THE_FIRST_BLOCK);
-
-    case UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE:
-        // First check if the first free block of the 'size' size has the correct alignment.
-        block = free_blocks_rm_ge(free_blocks, size, alignment,
-                                  CHECK_ONLY_THE_FIRST_BLOCK);
-        if (block) {
-            return block;
-        }
-
-        // If not, use the `UMF_COARSE_MEMORY_STRATEGY_FASTEST` strategy.
-        return free_blocks_rm_ge(free_blocks, size + alignment, 0,
-                                 CHECK_ONLY_THE_FIRST_BLOCK);
-
-    case UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE:
-        // First look through all free blocks of the 'size' size
-        // and choose the first one with the correct alignment.
-        block = free_blocks_rm_ge(free_blocks, size, alignment,
-                                  CHECK_ALL_BLOCKS_OF_SIZE);
-        if (block) {
-            return block;
-        }
-
-        // If none of them had the correct alignment,
-        // use the `UMF_COARSE_MEMORY_STRATEGY_FASTEST` strategy.
-        return free_blocks_rm_ge(free_blocks, size + alignment, 0,
-                                 CHECK_ONLY_THE_FIRST_BLOCK);
-
-    // unknown memory allocation strategy
-    default:
-        abort();
-    }
-}
-
-static umf_result_t coarse_memory_provider_alloc(void *provider, size_t size,
-                                                 size_t alignment,
-                                                 void **resultPtr) {
-    umf_result_t umf_result = UMF_RESULT_ERROR_UNKNOWN;
-
-    if (resultPtr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    coarse_memory_provider_t *coarse_provider =
-        (struct coarse_memory_provider_t *)provider;
-
-    if (utils_mutex_lock(&coarse_provider->lock) != 0) {
-        LOG_ERR("locking the lock failed");
-        return UMF_RESULT_ERROR_UNKNOWN;
-    }
-
-    assert(debug_check(coarse_provider));
-
-    // Find a block with greater or equal size using the given memory allocation strategy
-    block_t *curr =
-        find_free_block(coarse_provider->free_blocks, size, alignment,
-                        coarse_provider->allocation_strategy);
-
-    // If the block that we want to reuse has a greater size, split it.
-    // Try to merge the split part with the successor if it is not used.
-    enum { ACTION_NONE = 0, ACTION_USE, ACTION_SPLIT } action = ACTION_NONE;
-
-    if (curr && curr->size > size) {
-        action = ACTION_SPLIT;
-    } else if (curr && curr->size == size) {
-        action = ACTION_USE;
-    }
-
-    if (action) { // ACTION_SPLIT or ACTION_USE
-        assert(curr->used == false);
-
-        // In case of non-zero alignment create an aligned block what would be further used.
-        if (alignment > 0) {
-            umf_result =
-                create_aligned_block(coarse_provider, size, alignment, &curr);
-            if (umf_result != UMF_RESULT_SUCCESS) {
-                utils_mutex_unlock(&coarse_provider->lock);
-                return umf_result;
-            }
-        }
-
-        if (action == ACTION_SPLIT) {
-            // Split the current block and put the new block after the one that we use.
-            umf_result = split_current_block(coarse_provider, curr, size);
-            if (umf_result != UMF_RESULT_SUCCESS) {
-                utils_mutex_unlock(&coarse_provider->lock);
-                return umf_result;
-            }
-
-            curr->size = size;
-
-            LOG_DEBUG("coarse_ALLOC (split_block) %zu used %zu alloc %zu", size,
-                      coarse_provider->used_size, coarse_provider->alloc_size);
-
-        } else { // action == ACTION_USE
-            LOG_DEBUG("coarse_ALLOC (same_block) %zu used %zu alloc %zu", size,
-                      coarse_provider->used_size, coarse_provider->alloc_size);
-        }
-
-        curr->used = true;
-        *resultPtr = curr->data;
-        coarse_provider->used_size += size;
-
-        assert(debug_check(coarse_provider));
-        utils_mutex_unlock(&coarse_provider->lock);
-
-        return UMF_RESULT_SUCCESS;
-    }
-
-    // no suitable block found - try to get more memory from the upstream provider
-    umf_result = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-
-    if (coarse_provider->upstream_memory_provider == NULL) {
-        LOG_ERR("out of memory - no upstream memory provider given");
-        goto err_unlock;
-    }
-
-    umfMemoryProviderAlloc(coarse_provider->upstream_memory_provider, size,
-                           alignment, resultPtr);
-    if (*resultPtr == NULL) {
-        LOG_ERR("out of memory - upstream memory provider allocation failed");
-        goto err_unlock;
-    }
-
-    ASSERT_IS_ALIGNED(((uintptr_t)(*resultPtr)), alignment);
-
-    umf_result = coarse_add_upstream_block(coarse_provider, *resultPtr, size);
-    if (umf_result != UMF_RESULT_SUCCESS) {
-        if (!coarse_provider->disable_upstream_provider_free) {
-            umfMemoryProviderFree(coarse_provider->upstream_memory_provider,
-                                  *resultPtr, size);
-        }
-        goto err_unlock;
-    }
-
-    LOG_DEBUG("coarse_ALLOC (upstream) %zu used %zu alloc %zu", size,
-              coarse_provider->used_size, coarse_provider->alloc_size);
-
-    umf_result = UMF_RESULT_SUCCESS;
-
-err_unlock:
-    assert(debug_check(coarse_provider));
-    utils_mutex_unlock(&coarse_provider->lock);
-
-    return umf_result;
-}
-
-static umf_result_t coarse_memory_provider_free(void *provider, void *ptr,
-                                                size_t bytes) {
-    coarse_memory_provider_t *coarse_provider =
-        (struct coarse_memory_provider_t *)provider;
-
-    if (utils_mutex_lock(&coarse_provider->lock) != 0) {
-        LOG_ERR("locking the lock failed");
-        return UMF_RESULT_ERROR_UNKNOWN;
-    }
-
-    assert(debug_check(coarse_provider));
-
-    ravl_node_t *node = coarse_ravl_find_node(coarse_provider->all_blocks, ptr);
-    if (node == NULL) {
-        // the block was not found
-        utils_mutex_unlock(&coarse_provider->lock);
-        LOG_ERR("memory block not found (ptr = %p, size = %zu)", ptr, bytes);
-        return UMF_RESULT_ERROR_UNKNOWN;
-    }
-
-    block_t *block = get_node_block(node);
-    if (!block->used) {
-        // the block is already free
-        utils_mutex_unlock(&coarse_provider->lock);
-        LOG_ERR("the block is already free");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    if (bytes > 0 && bytes != block->size) {
-        // wrong size of allocation
-        utils_mutex_unlock(&coarse_provider->lock);
-        LOG_ERR("wrong size of allocation");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    LOG_DEBUG("coarse_FREE (return_block_to_pool) %zu used %zu alloc %zu",
-              block->size, coarse_provider->used_size - block->size,
-              coarse_provider->alloc_size);
-
-    assert(coarse_provider->used_size >= block->size);
-    coarse_provider->used_size -= block->size;
-
-    block->used = false;
-
-    // Merge with prev and/or next block if they are unused and have continuous data.
-    node = free_block_merge_with_prev(coarse_provider, node);
-    node = free_block_merge_with_next(coarse_provider, node);
-
-    int rv =
-        free_blocks_add(coarse_provider->free_blocks, get_node_block(node));
-    if (rv) {
-        utils_mutex_unlock(&coarse_provider->lock);
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    assert(debug_check(coarse_provider));
-    utils_mutex_unlock(&coarse_provider->lock);
-
-    return UMF_RESULT_SUCCESS;
-}
-
-static void coarse_memory_provider_get_last_native_error(void *provider,
-                                                         const char **ppMessage,
-                                                         int32_t *pError) {
-    (void)provider; // unused
-
-    if (ppMessage == NULL || pError == NULL) {
-        assert(0);
-        return;
-    }
-
-    // Nothing more is needed here, since
-    // there is no UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC error used.
-}
-
-static umf_result_t coarse_memory_provider_get_min_page_size(void *provider,
-                                                             void *ptr,
-                                                             size_t *pageSize) {
-    coarse_memory_provider_t *coarse_provider =
-        (struct coarse_memory_provider_t *)provider;
-
-    if (!coarse_provider->upstream_memory_provider) {
-        *pageSize = utils_get_page_size();
-        return UMF_RESULT_SUCCESS;
-    }
-
-    return umfMemoryProviderGetMinPageSize(
-        coarse_provider->upstream_memory_provider, ptr, pageSize);
-}
-
-static umf_result_t
-coarse_memory_provider_get_recommended_page_size(void *provider, size_t size,
-                                                 size_t *pageSize) {
-    coarse_memory_provider_t *coarse_provider =
-        (struct coarse_memory_provider_t *)provider;
-
-    if (!coarse_provider->upstream_memory_provider) {
-        *pageSize = utils_get_page_size();
-        return UMF_RESULT_SUCCESS;
-    }
-
-    return umfMemoryProviderGetRecommendedPageSize(
-        coarse_provider->upstream_memory_provider, size, pageSize);
-}
-
-static const char *coarse_memory_provider_get_name(void *provider) {
-    coarse_memory_provider_t *coarse_provider =
-        (struct coarse_memory_provider_t *)provider;
-
-    if (!coarse_provider->name) {
-        return COARSE_BASE_NAME;
-    }
-
-    return coarse_provider->name;
-}
-
-static void ravl_cb_count(void *data, void *arg) {
-    assert(arg);
-    (void)data; /* unused */
-
-    size_t *num_all_blocks = arg;
-    (*num_all_blocks)++;
-}
-
-static void ravl_cb_count_free(void *data, void *arg) {
-    assert(data);
-    assert(arg);
-
-    ravl_data_t *node_data = data;
-    assert(node_data);
-    ravl_free_blocks_head_t *head_node = node_data->value;
-    assert(head_node);
-    struct ravl_free_blocks_elem_t *free_block = head_node->head;
-    assert(free_block);
-
-    size_t *num_all_blocks = arg;
-    while (free_block) {
-        (*num_all_blocks)++;
-        free_block = free_block->next;
-    }
-}
-
-static umf_result_t
-coarse_memory_provider_get_stats(void *provider,
-                                 coarse_memory_provider_stats_t *stats) {
-    coarse_memory_provider_t *coarse_provider =
-        (struct coarse_memory_provider_t *)provider;
-
-    // count blocks
-    size_t num_upstream_blocks = 0;
-    ravl_foreach(coarse_provider->upstream_blocks, ravl_cb_count,
-                 &num_upstream_blocks);
-
-    size_t num_all_blocks = 0;
-    ravl_foreach(coarse_provider->all_blocks, ravl_cb_count, &num_all_blocks);
-
-    size_t num_free_blocks = 0;
-    ravl_foreach(coarse_provider->free_blocks, ravl_cb_count_free,
-                 &num_free_blocks);
-
-    stats->alloc_size = coarse_provider->alloc_size;
-    stats->used_size = coarse_provider->used_size;
-    stats->num_upstream_blocks = num_upstream_blocks;
-    stats->num_all_blocks = num_all_blocks;
-    stats->num_free_blocks = num_free_blocks;
-
-    return UMF_RESULT_SUCCESS;
-}
-
-static umf_result_t coarse_memory_provider_purge_lazy(void *provider, void *ptr,
-                                                      size_t size) {
-    coarse_memory_provider_t *coarse_provider =
-        (struct coarse_memory_provider_t *)provider;
-    if (coarse_provider->upstream_memory_provider == NULL) {
-        LOG_ERR("no upstream memory provider given");
-        return UMF_RESULT_ERROR_NOT_SUPPORTED;
-    }
-
-    return umfMemoryProviderPurgeLazy(coarse_provider->upstream_memory_provider,
-                                      ptr, size);
-}
-
-static umf_result_t coarse_memory_provider_purge_force(void *provider,
-                                                       void *ptr, size_t size) {
-    coarse_memory_provider_t *coarse_provider =
-        (struct coarse_memory_provider_t *)provider;
-    if (coarse_provider->upstream_memory_provider == NULL) {
-        LOG_ERR("no upstream memory provider given");
-        return UMF_RESULT_ERROR_NOT_SUPPORTED;
-    }
-
-    return umfMemoryProviderPurgeForce(
-        coarse_provider->upstream_memory_provider, ptr, size);
-}
-
-static umf_result_t coarse_memory_provider_allocation_split(void *provider,
-                                                            void *ptr,
-                                                            size_t totalSize,
-                                                            size_t firstSize) {
-    umf_result_t umf_result;
-
-    coarse_memory_provider_t *coarse_provider =
-        (struct coarse_memory_provider_t *)provider;
-
-    if (utils_mutex_lock(&coarse_provider->lock) != 0) {
-        LOG_ERR("locking the lock failed");
-        return UMF_RESULT_ERROR_UNKNOWN;
-    }
-
-    assert(debug_check(coarse_provider));
-
-    ravl_node_t *node = coarse_ravl_find_node(coarse_provider->all_blocks, ptr);
-    if (node == NULL) {
-        LOG_ERR("memory block not found");
-        umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_mutex_unlock;
-    }
-
-    block_t *block = get_node_block(node);
-
-    if (block->size != totalSize) {
-        LOG_ERR("wrong totalSize");
-        umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_mutex_unlock;
-    }
-
-    if (!block->used) {
-        LOG_ERR("block is not allocated");
-        umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_mutex_unlock;
-    }
-
-    block_t *new_block = coarse_ravl_add_new(coarse_provider->all_blocks,
-                                             block->data + firstSize,
-                                             block->size - firstSize, NULL);
-    if (new_block == NULL) {
-        umf_result = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-        goto err_mutex_unlock;
-    }
-
-    block->size = firstSize;
-    new_block->used = true;
-
-    assert(new_block->size == (totalSize - firstSize));
-
-    umf_result = UMF_RESULT_SUCCESS;
-
-err_mutex_unlock:
-    assert(debug_check(coarse_provider));
-    utils_mutex_unlock(&coarse_provider->lock);
-
-    return umf_result;
-}
-
-static umf_result_t coarse_memory_provider_allocation_merge(void *provider,
-                                                            void *lowPtr,
-                                                            void *highPtr,
-                                                            size_t totalSize) {
-    umf_result_t umf_result;
-
-    coarse_memory_provider_t *coarse_provider =
-        (struct coarse_memory_provider_t *)provider;
-
-    if (utils_mutex_lock(&coarse_provider->lock) != 0) {
-        LOG_ERR("locking the lock failed");
-        return UMF_RESULT_ERROR_UNKNOWN;
-    }
-
-    assert(debug_check(coarse_provider));
-
-    ravl_node_t *low_node =
-        coarse_ravl_find_node(coarse_provider->all_blocks, lowPtr);
-    if (low_node == NULL) {
-        LOG_ERR("the lowPtr memory block not found");
-        umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_mutex_unlock;
-    }
-
-    block_t *low_block = get_node_block(low_node);
-    if (!low_block->used) {
-        LOG_ERR("the lowPtr block is not allocated");
-        umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_mutex_unlock;
-    }
-
-    ravl_node_t *high_node =
-        coarse_ravl_find_node(coarse_provider->all_blocks, highPtr);
-    if (high_node == NULL) {
-        LOG_ERR("the highPtr memory block not found");
-        umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_mutex_unlock;
-    }
-
-    block_t *high_block = get_node_block(high_node);
-    if (!high_block->used) {
-        LOG_ERR("the highPtr block is not allocated");
-        umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_mutex_unlock;
-    }
-
-    if (get_node_next(low_node) != high_node) {
-        LOG_ERR("given pointers cannot be merged");
-        umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_mutex_unlock;
-    }
-
-    if (get_node_prev(high_node) != low_node) {
-        LOG_ERR("given pointers cannot be merged");
-        umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_mutex_unlock;
-    }
-
-    if (low_block->size + high_block->size != totalSize) {
-        LOG_ERR("wrong totalSize");
-        umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_mutex_unlock;
-    }
-
-    if ((uintptr_t)highPtr != ((uintptr_t)lowPtr + low_block->size)) {
-        LOG_ERR("given pointers cannot be merged");
-        umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_mutex_unlock;
-    }
-
-    ravl_node_t *merged_node = NULL;
-
-    umf_result = user_block_merge(coarse_provider, low_node, high_node, true,
-                                  &merged_node);
-    if (umf_result != UMF_RESULT_SUCCESS) {
-        LOG_ERR("merging failed");
-        goto err_mutex_unlock;
-    }
-
-    assert(merged_node == low_node);
-    assert(low_block->size == totalSize);
-
-    umf_result = UMF_RESULT_SUCCESS;
-
-err_mutex_unlock:
-    assert(debug_check(coarse_provider));
-    utils_mutex_unlock(&coarse_provider->lock);
-
-    return umf_result;
-}
-
-umf_memory_provider_ops_t UMF_COARSE_MEMORY_PROVIDER_OPS = {
-    .version = UMF_VERSION_CURRENT,
-    .initialize = coarse_memory_provider_initialize,
-    .finalize = coarse_memory_provider_finalize,
-    .alloc = coarse_memory_provider_alloc,
-    .get_last_native_error = coarse_memory_provider_get_last_native_error,
-    .get_recommended_page_size =
-        coarse_memory_provider_get_recommended_page_size,
-    .get_min_page_size = coarse_memory_provider_get_min_page_size,
-    .get_name = coarse_memory_provider_get_name,
-    .ext.free = coarse_memory_provider_free,
-    .ext.purge_lazy = coarse_memory_provider_purge_lazy,
-    .ext.purge_force = coarse_memory_provider_purge_force,
-    .ext.allocation_merge = coarse_memory_provider_allocation_merge,
-    .ext.allocation_split = coarse_memory_provider_allocation_split,
-    // TODO
-    /*
-    .ipc.get_ipc_handle_size = coarse_memory_provider_get_ipc_handle_size,
-    .ipc.get_ipc_handle = coarse_memory_provider_get_ipc_handle,
-    .ipc.put_ipc_handle = coarse_memory_provider_put_ipc_handle,
-    .ipc.open_ipc_handle = coarse_memory_provider_open_ipc_handle,
-    .ipc.close_ipc_handle = coarse_memory_provider_close_ipc_handle,
-    */
-};
-
-umf_memory_provider_ops_t *umfCoarseMemoryProviderOps(void) {
-    return &UMF_COARSE_MEMORY_PROVIDER_OPS;
-}
-
-coarse_memory_provider_stats_t
-umfCoarseMemoryProviderGetStats(umf_memory_provider_handle_t provider) {
-    coarse_memory_provider_stats_t stats = {0};
-
-    if (provider == NULL) {
-        return stats;
-    }
-
-    void *priv = umfMemoryProviderGetPriv(provider);
-
-    coarse_memory_provider_t *coarse_provider =
-        (struct coarse_memory_provider_t *)priv;
-
-    if (utils_mutex_lock(&coarse_provider->lock) != 0) {
-        LOG_ERR("locking the lock failed");
-        return stats;
-    }
-
-    coarse_memory_provider_get_stats(priv, &stats);
-
-    utils_mutex_unlock(&coarse_provider->lock);
-
-    return stats;
-}
diff --git a/src/provider/provider_ctl_stats_impl.h b/src/provider/provider_ctl_stats_impl.h
new file mode 100644
index 0000000000..72ffa93fb4
--- /dev/null
+++ b/src/provider/provider_ctl_stats_impl.h
@@ -0,0 +1,107 @@
+/*
+ * 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
+ */
+
+#ifdef UMF_PROVIDER_CTL_STATS_IMPL_H
+#error This file should not be included more than once
+#else
+#define UMF_PROVIDER_CTL_STATS_IMPL_H 1
+
+#ifndef CTL_PROVIDER_TYPE
+#error "CTL_PROVIDER_TYPE must be defined"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ctl/ctl_internal.h"
+#include "utils/utils_assert.h"
+
+static umf_result_t
+CTL_READ_HANDLER(peak_memory)(void *ctx, umf_ctl_query_source_t source,
+                              void *arg, size_t size,
+                              umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)size, (void)indexes;
+
+    size_t *arg_out = arg;
+    CTL_PROVIDER_TYPE *provider = (CTL_PROVIDER_TYPE *)ctx;
+    utils_atomic_load_acquire_size_t(&provider->stats.peak_memory, arg_out);
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t
+CTL_READ_HANDLER(allocated_memory)(void *ctx, umf_ctl_query_source_t source,
+                                   void *arg, size_t size,
+                                   umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)size, (void)indexes;
+
+    size_t *arg_out = arg;
+    CTL_PROVIDER_TYPE *provider = (CTL_PROVIDER_TYPE *)ctx;
+    utils_atomic_load_acquire_size_t(&provider->stats.allocated_memory,
+                                     arg_out);
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t
+CTL_RUNNABLE_HANDLER(reset)(void *ctx, umf_ctl_query_source_t source, void *arg,
+                            size_t size, umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)arg, (void)size;
+
+    CTL_PROVIDER_TYPE *provider = (CTL_PROVIDER_TYPE *)ctx;
+    size_t allocated;
+    size_t current_peak;
+
+    utils_atomic_load_acquire_size_t(&provider->stats.peak_memory,
+                                     &current_peak);
+    do {
+        utils_atomic_load_acquire_size_t(&provider->stats.allocated_memory,
+                                         &allocated);
+    } while (!utils_compare_exchange_size_t(&provider->stats.peak_memory,
+                                            &current_peak, &allocated));
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static const umf_ctl_node_t CTL_NODE(peak_memory)[] = {CTL_LEAF_RUNNABLE(reset),
+                                                       CTL_NODE_END};
+
+static const umf_ctl_node_t CTL_NODE(stats)[] = {
+    CTL_LEAF_RO(allocated_memory), CTL_LEAF_RO(peak_memory),
+    CTL_CHILD(peak_memory), CTL_NODE_END};
+
+static inline void provider_ctl_stats_alloc(CTL_PROVIDER_TYPE *provider,
+                                            size_t size) {
+    size_t allocated =
+        utils_fetch_and_add_size_t(&provider->stats.allocated_memory, size) +
+        size;
+
+    size_t peak;
+    utils_atomic_load_acquire_size_t(&provider->stats.peak_memory, &peak);
+
+    // If the compare-exchange fails, 'peak' is updated to the current value
+    // of peak_memory. We then re-check whether allocated is still greater than
+    // the updated peak value.
+    while (allocated > peak &&
+           !utils_compare_exchange_size_t(&provider->stats.peak_memory, &peak,
+                                          &allocated)) {
+        ;
+    }
+}
+
+static inline void provider_ctl_stats_free(CTL_PROVIDER_TYPE *provider,
+                                           size_t size) {
+    utils_fetch_and_sub_size_t(&provider->stats.allocated_memory, size);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_PROVIDER_CTL_STATS_IMPL_H */
diff --git a/src/provider/provider_ctl_stats_type.h b/src/provider/provider_ctl_stats_type.h
new file mode 100644
index 0000000000..607d7f5b0c
--- /dev/null
+++ b/src/provider/provider_ctl_stats_type.h
@@ -0,0 +1,26 @@
+/*
+ * 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
+*/
+
+#ifndef UMF_PROVIDER_CTL_STATS_TYPE_H
+#define UMF_PROVIDER_CTL_STATS_TYPE_H 1
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct ctl_stats_t {
+    size_t allocated_memory;
+    size_t peak_memory;
+} ctl_stats_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_PROVIDER_CTL_STATS_TYPE_H */
diff --git a/src/provider/provider_cuda.c b/src/provider/provider_cuda.c
index ce2f1debb7..304452f2c1 100644
--- a/src/provider/provider_cuda.c
+++ b/src/provider/provider_cuda.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -12,56 +12,22 @@
 #include <umf.h>
 #include <umf/providers/provider_cuda.h>
 
+#include "memory_provider_internal.h"
+#include "provider_ctl_stats_type.h"
+#include "provider_cuda_internal.h"
+#include "utils_load_library.h"
 #include "utils_log.h"
 
-#if defined(UMF_NO_CUDA_PROVIDER)
-
-umf_result_t umfCUDAMemoryProviderParamsCreate(
-    umf_cuda_memory_provider_params_handle_t *hParams) {
-    (void)hParams;
-    LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-umf_result_t umfCUDAMemoryProviderParamsDestroy(
-    umf_cuda_memory_provider_params_handle_t hParams) {
-    (void)hParams;
-    LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-umf_result_t umfCUDAMemoryProviderParamsSetContext(
-    umf_cuda_memory_provider_params_handle_t hParams, void *hContext) {
-    (void)hParams;
-    (void)hContext;
-    LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-umf_result_t umfCUDAMemoryProviderParamsSetDevice(
-    umf_cuda_memory_provider_params_handle_t hParams, int hDevice) {
-    (void)hParams;
-    (void)hDevice;
-    LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
+static void *cu_lib_handle = NULL;
 
-umf_result_t umfCUDAMemoryProviderParamsSetMemoryType(
-    umf_cuda_memory_provider_params_handle_t hParams,
-    umf_usm_memory_type_t memoryType) {
-    (void)hParams;
-    (void)memoryType;
-    LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-umf_memory_provider_ops_t *umfCUDAMemoryProviderOps(void) {
-    // not supported
-    LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
-    return NULL;
+void fini_cu_global_state(void) {
+    if (cu_lib_handle) {
+        utils_close_library(cu_lib_handle);
+        cu_lib_handle = NULL;
+    }
 }
 
-#else // !defined(UMF_NO_CUDA_PROVIDER)
+#if UMF_BUILD_CUDA_PROVIDER
 
 // disable warning 4201: nonstandard extension used: nameless struct/union
 #if defined(_MSC_VER)
@@ -80,7 +46,6 @@ umf_memory_provider_ops_t *umfCUDAMemoryProviderOps(void) {
 #include "utils_assert.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
-#include "utils_load_library.h"
 #include "utils_log.h"
 #include "utils_sanitizers.h"
 
@@ -89,13 +54,28 @@ typedef struct cu_memory_provider_t {
     CUdevice device;
     umf_usm_memory_type_t memory_type;
     size_t min_alignment;
+    unsigned int alloc_flags;
+    ctl_stats_t stats;
+    char name[64];
 } cu_memory_provider_t;
 
+#define CTL_PROVIDER_TYPE cu_memory_provider_t
+#include "provider_ctl_stats_impl.h"
+
 // CUDA Memory Provider settings struct
 typedef struct umf_cuda_memory_provider_params_t {
-    void *cuda_context_handle;         ///< Handle to the CUDA context
-    int cuda_device_handle;            ///< Handle to the CUDA device
-    umf_usm_memory_type_t memory_type; ///< Allocation memory type
+    // Handle to the CUDA context
+    void *cuda_context_handle;
+
+    // Handle to the CUDA device
+    int cuda_device_handle;
+
+    // Allocation memory type
+    umf_usm_memory_type_t memory_type;
+
+    // Allocation flags for cuMemHostAlloc/cuMemAllocManaged
+    unsigned int alloc_flags;
+    char name[64];
 } umf_cuda_memory_provider_params_t;
 
 typedef struct cu_ops_t {
@@ -103,7 +83,7 @@ typedef struct cu_ops_t {
         size_t *granularity, const CUmemAllocationProp *prop,
         CUmemAllocationGranularity_flags option);
     CUresult (*cuMemAlloc)(CUdeviceptr *dptr, size_t bytesize);
-    CUresult (*cuMemAllocHost)(void **pp, size_t bytesize);
+    CUresult (*cuMemHostAlloc)(void **pp, size_t bytesize, unsigned int flags);
     CUresult (*cuMemAllocManaged)(CUdeviceptr *dptr, size_t bytesize,
                                   unsigned int flags);
     CUresult (*cuMemFree)(CUdeviceptr dptr);
@@ -112,6 +92,7 @@ typedef struct cu_ops_t {
     CUresult (*cuGetErrorName)(CUresult error, const char **pStr);
     CUresult (*cuGetErrorString)(CUresult error, const char **pStr);
     CUresult (*cuCtxGetCurrent)(CUcontext *pctx);
+    CUresult (*cuCtxGetDevice)(CUdevice *device);
     CUresult (*cuCtxSetCurrent)(CUcontext ctx);
     CUresult (*cuIpcGetMemHandle)(CUipcMemHandle *pHandle, CUdeviceptr dptr);
     CUresult (*cuIpcOpenMemHandle)(CUdeviceptr *pdptr, CUipcMemHandle handle,
@@ -125,12 +106,29 @@ static cu_ops_t g_cu_ops;
 static UTIL_ONCE_FLAG cu_is_initialized = UTIL_ONCE_FLAG_INIT;
 static bool Init_cu_global_state_failed;
 
+struct ctl cu_memory_ctl_root;
+static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT;
+
+static umf_result_t cu_memory_provider_post_initialize(void *provider);
+static umf_result_t
+CTL_RUNNABLE_HANDLER(post_initialize)(void *ctx, umf_ctl_query_source_t source,
+                                      void *arg, size_t size,
+                                      umf_ctl_index_utlist_t *indexes) {
+    (void)source;
+    (void)arg;
+    (void)size;
+    (void)indexes;
+    return cu_memory_provider_post_initialize(ctx);
+}
+
 // forward decl needed for alloc
 static umf_result_t cu_memory_provider_free(void *provider, void *ptr,
                                             size_t bytes);
 
 #define TLS_MSG_BUF_LEN 1024
 
+static const char *DEFAULT_NAME = "CUDA";
+
 typedef struct cu_last_native_error_t {
     CUresult native_error;
     char msg_buff[TLS_MSG_BUF_LEN];
@@ -150,62 +148,86 @@ static umf_result_t cu2umf_result(CUresult result) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     case CUDA_ERROR_INVALID_VALUE:
     case CUDA_ERROR_INVALID_HANDLE:
-    case CUDA_ERROR_INVALID_RESOURCE_TYPE:
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    case CUDA_ERROR_DEINITIALIZED:
+        LOG_ERR("CUDA driver has been deinitialized");
+        return UMF_RESULT_ERROR_OUT_OF_RESOURCES;
     default:
         cu_store_last_native_error(result);
         return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
     }
 }
 
+static void initialize_cu_ctl(void) {
+    CTL_REGISTER_MODULE(&cu_memory_ctl_root, stats);
+    cu_memory_ctl_root.root[cu_memory_ctl_root.first_free++] = (umf_ctl_node_t){
+        .name = "post_initialize",
+        .type = CTL_NODE_LEAF,
+        .runnable_cb = CTL_RUNNABLE_HANDLER(post_initialize),
+    };
+}
+
 static void init_cu_global_state(void) {
 #ifdef _WIN32
     const char *lib_name = "nvcuda.dll";
 #else
-    const char *lib_name = "libcuda.so";
+    const char *lib_name = "libcuda.so.1";
 #endif
-    // check if CUDA shared library is already loaded
-    // we pass 0 as a handle to search the global symbol table
+    // The CUDA shared library should be already loaded by the user
+    // of the CUDA provider. UMF just want to reuse it
+    // and increase the reference count to the CUDA shared library.
+    void *lib_handle =
+        utils_open_library(lib_name, UMF_UTIL_OPEN_LIBRARY_NO_LOAD);
+    if (!lib_handle) {
+        LOG_ERR("Failed to open CUDA shared library");
+        Init_cu_global_state_failed = true;
+        return;
+    }
 
     // NOTE: some symbols defined in the lib have _vX postfixes - it is
     // important to load the proper version of functions
-    *(void **)&g_cu_ops.cuMemGetAllocationGranularity =
-        utils_get_symbol_addr(0, "cuMemGetAllocationGranularity", lib_name);
+    *(void **)&g_cu_ops.cuMemGetAllocationGranularity = utils_get_symbol_addr(
+        lib_handle, "cuMemGetAllocationGranularity", lib_name);
     *(void **)&g_cu_ops.cuMemAlloc =
-        utils_get_symbol_addr(0, "cuMemAlloc_v2", lib_name);
-    *(void **)&g_cu_ops.cuMemAllocHost =
-        utils_get_symbol_addr(0, "cuMemAllocHost_v2", lib_name);
+        utils_get_symbol_addr(lib_handle, "cuMemAlloc_v2", lib_name);
+    *(void **)&g_cu_ops.cuMemHostAlloc =
+        utils_get_symbol_addr(lib_handle, "cuMemHostAlloc", lib_name);
     *(void **)&g_cu_ops.cuMemAllocManaged =
-        utils_get_symbol_addr(0, "cuMemAllocManaged", lib_name);
+        utils_get_symbol_addr(lib_handle, "cuMemAllocManaged", lib_name);
     *(void **)&g_cu_ops.cuMemFree =
-        utils_get_symbol_addr(0, "cuMemFree_v2", lib_name);
+        utils_get_symbol_addr(lib_handle, "cuMemFree_v2", lib_name);
     *(void **)&g_cu_ops.cuMemFreeHost =
-        utils_get_symbol_addr(0, "cuMemFreeHost", lib_name);
+        utils_get_symbol_addr(lib_handle, "cuMemFreeHost", lib_name);
     *(void **)&g_cu_ops.cuGetErrorName =
-        utils_get_symbol_addr(0, "cuGetErrorName", lib_name);
+        utils_get_symbol_addr(lib_handle, "cuGetErrorName", lib_name);
     *(void **)&g_cu_ops.cuGetErrorString =
-        utils_get_symbol_addr(0, "cuGetErrorString", lib_name);
+        utils_get_symbol_addr(lib_handle, "cuGetErrorString", lib_name);
     *(void **)&g_cu_ops.cuCtxGetCurrent =
-        utils_get_symbol_addr(0, "cuCtxGetCurrent", lib_name);
+        utils_get_symbol_addr(lib_handle, "cuCtxGetCurrent", lib_name);
+    *(void **)&g_cu_ops.cuCtxGetDevice =
+        utils_get_symbol_addr(lib_handle, "cuCtxGetDevice", lib_name);
     *(void **)&g_cu_ops.cuCtxSetCurrent =
-        utils_get_symbol_addr(0, "cuCtxSetCurrent", lib_name);
+        utils_get_symbol_addr(lib_handle, "cuCtxSetCurrent", lib_name);
     *(void **)&g_cu_ops.cuIpcGetMemHandle =
-        utils_get_symbol_addr(0, "cuIpcGetMemHandle", lib_name);
+        utils_get_symbol_addr(lib_handle, "cuIpcGetMemHandle", lib_name);
     *(void **)&g_cu_ops.cuIpcOpenMemHandle =
-        utils_get_symbol_addr(0, "cuIpcOpenMemHandle_v2", lib_name);
+        utils_get_symbol_addr(lib_handle, "cuIpcOpenMemHandle_v2", lib_name);
     *(void **)&g_cu_ops.cuIpcCloseMemHandle =
-        utils_get_symbol_addr(0, "cuIpcCloseMemHandle", lib_name);
+        utils_get_symbol_addr(lib_handle, "cuIpcCloseMemHandle", lib_name);
 
     if (!g_cu_ops.cuMemGetAllocationGranularity || !g_cu_ops.cuMemAlloc ||
-        !g_cu_ops.cuMemAllocHost || !g_cu_ops.cuMemAllocManaged ||
+        !g_cu_ops.cuMemHostAlloc || !g_cu_ops.cuMemAllocManaged ||
         !g_cu_ops.cuMemFree || !g_cu_ops.cuMemFreeHost ||
         !g_cu_ops.cuGetErrorName || !g_cu_ops.cuGetErrorString ||
-        !g_cu_ops.cuCtxGetCurrent || !g_cu_ops.cuCtxSetCurrent ||
-        !g_cu_ops.cuIpcGetMemHandle || !g_cu_ops.cuIpcOpenMemHandle ||
-        !g_cu_ops.cuIpcCloseMemHandle) {
-        LOG_ERR("Required CUDA symbols not found.");
+        !g_cu_ops.cuCtxGetCurrent || !g_cu_ops.cuCtxGetDevice ||
+        !g_cu_ops.cuCtxSetCurrent || !g_cu_ops.cuIpcGetMemHandle ||
+        !g_cu_ops.cuIpcOpenMemHandle || !g_cu_ops.cuIpcCloseMemHandle) {
+        LOG_FATAL("Required CUDA symbols not found.");
         Init_cu_global_state_failed = true;
+        utils_close_library(lib_handle);
+        return;
     }
+    cu_lib_handle = lib_handle;
 }
 
 umf_result_t umfCUDAMemoryProviderParamsCreate(
@@ -223,9 +245,33 @@ umf_result_t umfCUDAMemoryProviderParamsCreate(
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    params_data->cuda_context_handle = NULL;
-    params_data->cuda_device_handle = -1;
+    utils_init_once(&cu_is_initialized, init_cu_global_state);
+    if (Init_cu_global_state_failed) {
+        LOG_FATAL("Loading CUDA symbols failed");
+        return UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
+    }
+
+    // initialize context and device to the current ones
+    CUcontext current_ctx = NULL;
+    CUresult cu_result = g_cu_ops.cuCtxGetCurrent(&current_ctx);
+    if (cu_result == CUDA_SUCCESS) {
+        params_data->cuda_context_handle = current_ctx;
+    } else {
+        params_data->cuda_context_handle = NULL;
+    }
+
+    CUdevice current_device = -1;
+    cu_result = g_cu_ops.cuCtxGetDevice(&current_device);
+    if (cu_result == CUDA_SUCCESS) {
+        params_data->cuda_device_handle = current_device;
+    } else {
+        params_data->cuda_device_handle = -1;
+    }
+
     params_data->memory_type = UMF_MEMORY_TYPE_UNKNOWN;
+    params_data->alloc_flags = 0;
+    strncpy(params_data->name, DEFAULT_NAME, sizeof(params_data->name) - 1);
+    params_data->name[sizeof(params_data->name) - 1] = '\0';
 
     *hParams = params_data;
 
@@ -276,14 +322,43 @@ umf_result_t umfCUDAMemoryProviderParamsSetMemoryType(
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t cu_memory_provider_initialize(void *params,
+umf_result_t umfCUDAMemoryProviderParamsSetAllocFlags(
+    umf_cuda_memory_provider_params_handle_t hParams, unsigned int flags) {
+    if (!hParams) {
+        LOG_ERR("CUDA Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->alloc_flags = flags;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfCUDAMemoryProviderParamsSetName(
+    umf_cuda_memory_provider_params_handle_t hParams, const char *name) {
+    if (!hParams) {
+        LOG_ERR("CUDA Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (!name) {
+        LOG_ERR("name is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    strncpy(hParams->name, name, sizeof(hParams->name) - 1);
+    hParams->name[sizeof(hParams->name) - 1] = '\0';
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t cu_memory_provider_initialize(const void *params,
                                                   void **provider) {
     if (params == NULL) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    umf_cuda_memory_provider_params_handle_t cu_params =
-        (umf_cuda_memory_provider_params_handle_t)params;
+    const umf_cuda_memory_provider_params_t *cu_params = params;
 
     if (cu_params->memory_type == UMF_MEMORY_TYPE_UNKNOWN ||
         cu_params->memory_type > UMF_MEMORY_TYPE_SHARED) {
@@ -292,13 +367,19 @@ static umf_result_t cu_memory_provider_initialize(void *params,
     }
 
     if (cu_params->cuda_context_handle == NULL) {
+        LOG_ERR("Invalid context handle");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (cu_params->cuda_device_handle < 0) {
+        LOG_ERR("Invalid device handle");
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
     utils_init_once(&cu_is_initialized, init_cu_global_state);
     if (Init_cu_global_state_failed) {
-        LOG_ERR("Loading CUDA symbols failed");
-        return UMF_RESULT_ERROR_UNKNOWN;
+        LOG_FATAL("Loading CUDA symbols failed");
+        return UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
     }
 
     cu_memory_provider_t *cu_provider =
@@ -307,6 +388,29 @@ static umf_result_t cu_memory_provider_initialize(void *params,
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
+    memset(cu_provider, 0, sizeof(*cu_provider));
+    snprintf(cu_provider->name, sizeof(cu_provider->name), "%s",
+             cu_params->name);
+
+    cu_provider->context = cu_params->cuda_context_handle;
+    cu_provider->device = cu_params->cuda_device_handle;
+    cu_provider->memory_type = cu_params->memory_type;
+    cu_provider->alloc_flags = cu_params->alloc_flags;
+
+    *provider = cu_provider;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t cu_memory_provider_finalize(void *provider) {
+    umf_ba_global_free(provider);
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t cu_memory_provider_post_initialize(void *provider) {
+    cu_memory_provider_t *cu_provider = (cu_memory_provider_t *)provider;
+
+    assert(provider);
     // CUDA alloc functions doesn't allow to provide user alignment - get the
     // minimum one from the driver
     size_t min_alignment = 0;
@@ -321,20 +425,19 @@ static umf_result_t cu_memory_provider_initialize(void *params,
         return cu2umf_result(cu_result);
     }
 
-    cu_provider->context = cu_params->cuda_context_handle;
-    cu_provider->device = cu_params->cuda_device_handle;
-    cu_provider->memory_type = cu_params->memory_type;
     cu_provider->min_alignment = min_alignment;
 
-    *provider = cu_provider;
-
+    // If the memory type is shared (CUDA managed), the allocation flags must
+    // be set. NOTE: we do not check here if the flags are valid -
+    // this will be done by CUDA runtime.
+    if (cu_provider->memory_type == UMF_MEMORY_TYPE_SHARED &&
+        cu_provider->alloc_flags == 0) {
+        // the default setting is CU_MEM_ATTACH_GLOBAL
+        cu_provider->alloc_flags = CU_MEM_ATTACH_GLOBAL;
+    }
     return UMF_RESULT_SUCCESS;
 }
 
-static void cu_memory_provider_finalize(void *provider) {
-    umf_ba_global_free(provider);
-}
-
 /*
  * This function is used by the CUDA provider to make sure that
  * the required context is set. If the current context is
@@ -382,7 +485,8 @@ static umf_result_t cu_memory_provider_alloc(void *provider, size_t size,
     CUresult cu_result = CUDA_SUCCESS;
     switch (cu_provider->memory_type) {
     case UMF_MEMORY_TYPE_HOST: {
-        cu_result = g_cu_ops.cuMemAllocHost(resultPtr, size);
+        cu_result =
+            g_cu_ops.cuMemHostAlloc(resultPtr, size, cu_provider->alloc_flags);
         break;
     }
     case UMF_MEMORY_TYPE_DEVICE: {
@@ -391,7 +495,7 @@ static umf_result_t cu_memory_provider_alloc(void *provider, size_t size,
     }
     case UMF_MEMORY_TYPE_SHARED: {
         cu_result = g_cu_ops.cuMemAllocManaged((CUdeviceptr *)resultPtr, size,
-                                               CU_MEM_ATTACH_GLOBAL);
+                                               cu_provider->alloc_flags);
         break;
     }
     default:
@@ -420,6 +524,8 @@ static umf_result_t cu_memory_provider_alloc(void *provider, size_t size,
         LOG_ERR("unsupported alignment size");
         return UMF_RESULT_ERROR_INVALID_ALIGNMENT;
     }
+
+    provider_ctl_stats_alloc(cu_provider, size);
     return umf_result;
 }
 
@@ -433,6 +539,14 @@ static umf_result_t cu_memory_provider_free(void *provider, void *ptr,
 
     cu_memory_provider_t *cu_provider = (cu_memory_provider_t *)provider;
 
+    // Remember current context and set the one from the provider
+    CUcontext restore_ctx = NULL;
+    umf_result_t umf_result = set_context(cu_provider->context, &restore_ctx);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Failed to set CUDA context, ret = %d", umf_result);
+        return umf_result;
+    }
+
     CUresult cu_result = CUDA_SUCCESS;
     switch (cu_provider->memory_type) {
     case UMF_MEMORY_TYPE_HOST: {
@@ -451,42 +565,76 @@ static umf_result_t cu_memory_provider_free(void *provider, void *ptr,
         return UMF_RESULT_ERROR_UNKNOWN;
     }
 
-    return cu2umf_result(cu_result);
+    umf_result = set_context(restore_ctx, &restore_ctx);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Failed to restore CUDA context, ret = %d", umf_result);
+    }
+
+    umf_result_t ret = cu2umf_result(cu_result);
+    if (ret == UMF_RESULT_SUCCESS) {
+        provider_ctl_stats_free(cu_provider, bytes);
+    }
+    return ret;
 }
 
-static void cu_memory_provider_get_last_native_error(void *provider,
-                                                     const char **ppMessage,
-                                                     int32_t *pError) {
+static umf_result_t
+cu_memory_provider_get_last_native_error(void *provider, const char **ppMessage,
+                                         int32_t *pError) {
     (void)provider;
 
     if (ppMessage == NULL || pError == NULL) {
         ASSERT(0);
-        return;
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    const char *error_name = 0;
-    const char *error_string = 0;
-    g_cu_ops.cuGetErrorName(TLS_last_native_error.native_error, &error_name);
-    g_cu_ops.cuGetErrorString(TLS_last_native_error.native_error,
-                              &error_string);
-
+    CUresult result;
+    umf_result_t ret = UMF_RESULT_SUCCESS;
     size_t buf_size = 0;
-    strncpy(TLS_last_native_error.msg_buff, error_name, TLS_MSG_BUF_LEN - 1);
-    buf_size = strlen(TLS_last_native_error.msg_buff);
+    const char *error_name = NULL;
+    const char *error_string = NULL;
+
+    // If the error code is not recognized,
+    // CUDA_ERROR_INVALID_VALUE will be returned
+    // and error_name will be set to the NULL address.
+    result = g_cu_ops.cuGetErrorName(TLS_last_native_error.native_error,
+                                     &error_name);
+    if (result == CUDA_SUCCESS && error_name != NULL) {
+        strncpy(TLS_last_native_error.msg_buff, error_name,
+                TLS_MSG_BUF_LEN - 1);
+        TLS_last_native_error.msg_buff[TLS_MSG_BUF_LEN - 1] = '\0';
+    } else {
+        strncpy(TLS_last_native_error.msg_buff, "cuGetErrorName() failed",
+                TLS_MSG_BUF_LEN - 1);
+        TLS_last_native_error.msg_buff[TLS_MSG_BUF_LEN - 1] = '\0';
+        ret = cu2umf_result(result);
+    }
 
+    buf_size = strlen(TLS_last_native_error.msg_buff);
     strncat(TLS_last_native_error.msg_buff, " - ",
             TLS_MSG_BUF_LEN - buf_size - 1);
     buf_size = strlen(TLS_last_native_error.msg_buff);
 
-    strncat(TLS_last_native_error.msg_buff, error_string,
-            TLS_MSG_BUF_LEN - buf_size - 1);
+    // If the error code is not recognized,
+    // CUDA_ERROR_INVALID_VALUE will be returned
+    // and error_string will be set to the NULL address.
+    result = g_cu_ops.cuGetErrorString(TLS_last_native_error.native_error,
+                                       &error_string);
+    if (result == CUDA_SUCCESS && error_string != NULL) {
+        strncat(TLS_last_native_error.msg_buff, error_string,
+                TLS_MSG_BUF_LEN - buf_size - 1);
+    } else {
+        strncat(TLS_last_native_error.msg_buff, "cuGetErrorString() failed",
+                TLS_MSG_BUF_LEN - buf_size - 1);
+        ret = cu2umf_result(result);
+    }
 
     *pError = TLS_last_native_error.native_error;
     *ppMessage = TLS_last_native_error.msg_buff;
+    return ret;
 }
 
 static umf_result_t cu_memory_provider_get_min_page_size(void *provider,
-                                                         void *ptr,
+                                                         const void *ptr,
                                                          size_t *pageSize) {
     (void)ptr;
 
@@ -521,9 +669,18 @@ cu_memory_provider_get_recommended_page_size(void *provider, size_t size,
     return cu2umf_result(cu_result);
 }
 
-static const char *cu_memory_provider_get_name(void *provider) {
-    (void)provider;
-    return "CUDA";
+static umf_result_t cu_memory_provider_get_name(void *provider,
+                                                const char **name) {
+    if (!name) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    if (provider == NULL) {
+        *name = DEFAULT_NAME;
+        return UMF_RESULT_SUCCESS;
+    }
+    cu_memory_provider_t *cu_provider = (cu_memory_provider_t *)provider;
+    *name = cu_provider->name;
+    return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t cu_memory_provider_get_ipc_handle_size(void *provider,
@@ -581,7 +738,10 @@ static umf_result_t cu_memory_provider_open_ipc_handle(void *provider,
         LOG_ERR("cuIpcOpenMemHandle() failed.");
     }
 
-    set_context(restore_ctx, &restore_ctx);
+    umf_result = set_context(restore_ctx, &restore_ctx);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Failed to restore CUDA context, ret = %d", umf_result);
+    }
 
     return cu2umf_result(cu_result);
 }
@@ -602,32 +762,163 @@ cu_memory_provider_close_ipc_handle(void *provider, void *ptr, size_t size) {
     return UMF_RESULT_SUCCESS;
 }
 
-static struct umf_memory_provider_ops_t UMF_CUDA_MEMORY_PROVIDER_OPS = {
-    .version = UMF_VERSION_CURRENT,
+static umf_result_t cu_ctl(void *provider, umf_ctl_query_source_t operationType,
+                           const char *name, void *arg, size_t size,
+                           umf_ctl_query_type_t query_type, va_list args) {
+    utils_init_once(&ctl_initialized, initialize_cu_ctl);
+    return ctl_query(&cu_memory_ctl_root, provider, operationType, name,
+                     query_type, arg, size, args);
+}
+
+static umf_result_t cu_memory_provider_get_allocation_properties(
+    void *provider, const void *ptr,
+    umf_memory_property_id_t memory_property_id, void *value) {
+
+    // unused
+    (void)ptr;
+
+    cu_memory_provider_t *cuda_provider = (cu_memory_provider_t *)provider;
+
+    switch (memory_property_id) {
+    case UMF_MEMORY_PROPERTY_POINTER_TYPE:
+        *(umf_usm_memory_type_t *)value = cuda_provider->memory_type;
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_PROPERTY_CONTEXT:
+        *(CUcontext *)value = cuda_provider->context;
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_PROPERTY_DEVICE:
+        *(CUdevice *)value = cuda_provider->device;
+        return UMF_RESULT_SUCCESS;
+
+    default:
+        break;
+    };
+
+    return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+}
+
+static umf_result_t cu_memory_provider_get_allocation_properties_size(
+    void *provider, umf_memory_property_id_t memory_property_id, size_t *size) {
+
+    // unused
+    (void)provider;
+
+    switch (memory_property_id) {
+    case UMF_MEMORY_PROPERTY_POINTER_TYPE:
+        *size = sizeof(umf_usm_memory_type_t);
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_PROPERTY_CONTEXT:
+        *size = sizeof(CUcontext);
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_PROPERTY_DEVICE:
+        *size = sizeof(CUdevice);
+        return UMF_RESULT_SUCCESS;
+
+    default:
+        break;
+    };
+
+    return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+}
+
+static umf_memory_provider_ops_t UMF_CUDA_MEMORY_PROVIDER_OPS = {
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = cu_memory_provider_initialize,
     .finalize = cu_memory_provider_finalize,
     .alloc = cu_memory_provider_alloc,
+    .free = cu_memory_provider_free,
     .get_last_native_error = cu_memory_provider_get_last_native_error,
     .get_recommended_page_size = cu_memory_provider_get_recommended_page_size,
     .get_min_page_size = cu_memory_provider_get_min_page_size,
     .get_name = cu_memory_provider_get_name,
-    .ext.free = cu_memory_provider_free,
     // TODO
     /*
-    .ext.purge_lazy = cu_memory_provider_purge_lazy,
-    .ext.purge_force = cu_memory_provider_purge_force,
-    .ext.allocation_merge = cu_memory_provider_allocation_merge,
-    .ext.allocation_split = cu_memory_provider_allocation_split,
+    .ext_purge_lazy = cu_memory_provider_purge_lazy,
+    .ext_purge_force = cu_memory_provider_purge_force,
+    .ext_allocation_merge = cu_memory_provider_allocation_merge,
+    .ext_allocation_split = cu_memory_provider_allocation_split,
     */
-    .ipc.get_ipc_handle_size = cu_memory_provider_get_ipc_handle_size,
-    .ipc.get_ipc_handle = cu_memory_provider_get_ipc_handle,
-    .ipc.put_ipc_handle = cu_memory_provider_put_ipc_handle,
-    .ipc.open_ipc_handle = cu_memory_provider_open_ipc_handle,
-    .ipc.close_ipc_handle = cu_memory_provider_close_ipc_handle,
+    .ext_get_ipc_handle_size = cu_memory_provider_get_ipc_handle_size,
+    .ext_get_ipc_handle = cu_memory_provider_get_ipc_handle,
+    .ext_put_ipc_handle = cu_memory_provider_put_ipc_handle,
+    .ext_open_ipc_handle = cu_memory_provider_open_ipc_handle,
+    .ext_close_ipc_handle = cu_memory_provider_close_ipc_handle,
+    .ext_ctl = cu_ctl,
+    .ext_get_allocation_properties =
+        cu_memory_provider_get_allocation_properties,
+    .ext_get_allocation_properties_size =
+        cu_memory_provider_get_allocation_properties_size,
 };
 
-umf_memory_provider_ops_t *umfCUDAMemoryProviderOps(void) {
+const umf_memory_provider_ops_t *umfCUDAMemoryProviderOps(void) {
     return &UMF_CUDA_MEMORY_PROVIDER_OPS;
 }
 
-#endif // !defined(UMF_NO_CUDA_PROVIDER)
+#else // !UMF_BUILD_CUDA_PROVIDER
+
+umf_result_t umfCUDAMemoryProviderParamsCreate(
+    umf_cuda_memory_provider_params_handle_t *hParams) {
+    (void)hParams;
+    LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfCUDAMemoryProviderParamsDestroy(
+    umf_cuda_memory_provider_params_handle_t hParams) {
+    (void)hParams;
+    LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfCUDAMemoryProviderParamsSetContext(
+    umf_cuda_memory_provider_params_handle_t hParams, void *hContext) {
+    (void)hParams;
+    (void)hContext;
+    LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfCUDAMemoryProviderParamsSetDevice(
+    umf_cuda_memory_provider_params_handle_t hParams, int hDevice) {
+    (void)hParams;
+    (void)hDevice;
+    LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfCUDAMemoryProviderParamsSetMemoryType(
+    umf_cuda_memory_provider_params_handle_t hParams,
+    umf_usm_memory_type_t memoryType) {
+    (void)hParams;
+    (void)memoryType;
+    LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfCUDAMemoryProviderParamsSetAllocFlags(
+    umf_cuda_memory_provider_params_handle_t hParams, unsigned int flags) {
+    (void)hParams;
+    (void)flags;
+    LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfCUDAMemoryProviderParamsSetName(
+    umf_cuda_memory_provider_params_handle_t hParams, const char *name) {
+    (void)hParams;
+    (void)name;
+    LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+const umf_memory_provider_ops_t *umfCUDAMemoryProviderOps(void) {
+    // not supported
+    LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
+    return NULL;
+}
+
+#endif // !UMF_BUILD_CUDA_PROVIDER
diff --git a/src/provider/provider_cuda_internal.h b/src/provider/provider_cuda_internal.h
new file mode 100644
index 0000000000..92e7d98a37
--- /dev/null
+++ b/src/provider/provider_cuda_internal.h
@@ -0,0 +1,15 @@
+/*
+ *
+ * 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
+ *
+ */
+
+#ifndef UMF_CUDA_PROVIDER_INTERNAL_H
+#define UMF_CUDA_PROVIDER_INTERNAL_H 1
+
+void fini_cu_global_state(void);
+
+#endif /* UMF_CUDA_PROVIDER_INTERNAL_H */
diff --git a/src/provider/provider_devdax_memory.c b/src/provider/provider_devdax_memory.c
index cb5a4af572..6addea3502 100644
--- a/src/provider/provider_devdax_memory.c
+++ b/src/provider/provider_devdax_memory.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -19,17 +19,17 @@
 
 #include "utils_log.h"
 
-#if defined(_WIN32) || defined(UMF_NO_HWLOC)
+#if defined(_WIN32)
 
-umf_memory_provider_ops_t *umfDevDaxMemoryProviderOps(void) {
+const umf_memory_provider_ops_t *umfDevDaxMemoryProviderOps(void) {
     // not supported
     LOG_ERR("DevDax memory provider is disabled!");
     return NULL;
 }
 
 umf_result_t umfDevDaxMemoryProviderParamsCreate(
-    umf_devdax_memory_provider_params_handle_t *hParams, const char *path,
-    size_t size) {
+    const char *path, size_t size,
+    umf_devdax_memory_provider_params_handle_t *hParams) {
     (void)hParams;
     (void)path;
     (void)size;
@@ -62,10 +62,20 @@ umf_result_t umfDevDaxMemoryProviderParamsSetProtection(
     return UMF_RESULT_ERROR_NOT_SUPPORTED;
 }
 
-#else // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+umf_result_t umfDevDaxMemoryProviderParamsSetName(
+    umf_devdax_memory_provider_params_handle_t hParams, const char *name) {
+    (void)hParams;
+    (void)name;
+    LOG_ERR("DevDax memory provider is disabled!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+#else // !defined(_WIN32)
 
 #include "base_alloc_global.h"
+#include "coarse.h"
 #include "libumf.h"
+#include "provider_ctl_stats_type.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
 #include "utils_log.h"
@@ -74,6 +84,8 @@ umf_result_t umfDevDaxMemoryProviderParamsSetProtection(
 
 #define TLS_MSG_BUF_LEN 1024
 
+static const char *DEFAULT_NAME = "DEVDAX";
+
 typedef struct devdax_memory_provider_t {
     char path[PATH_MAX]; // a path to the device DAX
     size_t size;         // size of the file used for memory mapping
@@ -81,13 +93,20 @@ typedef struct devdax_memory_provider_t {
     size_t offset;       // offset in the file used for memory mapping
     utils_mutex_t lock;  // lock of ptr and offset
     unsigned protection; // combination of OS-specific protection flags
+    coarse_t *coarse;    // coarse library handle
+    ctl_stats_t stats;
+    char name[64];
 } devdax_memory_provider_t;
 
+#define CTL_PROVIDER_TYPE devdax_memory_provider_t
+#include "provider_ctl_stats_impl.h"
+
 // DevDax Memory provider settings struct
 typedef struct umf_devdax_memory_provider_params_t {
     char *path;
     size_t size;
     unsigned protection;
+    char name[64];
 } umf_devdax_memory_provider_params_t;
 
 typedef struct devdax_last_native_error_t {
@@ -110,6 +129,9 @@ static __TLS devdax_last_native_error_t TLS_last_native_error;
 #define _UMF_DEVDAX_RESULT_ERROR_PURGE_FORCE_FAILED                            \
     (UMF_DEVDAX_RESULT_ERROR_PURGE_FORCE_FAILED - UMF_DEVDAX_RESULT_SUCCESS)
 
+struct ctl devdax_memory_ctl_root;
+static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT;
+
 static const char *Native_error_str[] = {
     [_UMF_DEVDAX_RESULT_SUCCESS] = "success",
     [_UMF_DEVDAX_RESULT_ERROR_ALLOC_FAILED] = "memory allocation failed",
@@ -125,8 +147,12 @@ static void devdax_store_last_native_error(int32_t native_error,
     TLS_last_native_error.errno_value = errno_value;
 }
 
+static void initialize_devdax_ctl(void) {
+    CTL_REGISTER_MODULE(&devdax_memory_ctl_root, stats);
+}
+
 static umf_result_t
-devdax_translate_params(umf_devdax_memory_provider_params_t *in_params,
+devdax_translate_params(const umf_devdax_memory_provider_params_t *in_params,
                         devdax_memory_provider_t *provider) {
     umf_result_t result;
 
@@ -140,15 +166,20 @@ devdax_translate_params(umf_devdax_memory_provider_params_t *in_params,
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t devdax_initialize(void *params, void **provider) {
+static umf_result_t devdax_allocation_split_cb(void *provider, void *ptr,
+                                               size_t totalSize,
+                                               size_t firstSize);
+static umf_result_t devdax_allocation_merge_cb(void *provider, void *lowPtr,
+                                               void *highPtr, size_t totalSize);
+
+static umf_result_t devdax_initialize(const void *params, void **provider) {
     umf_result_t ret;
 
     if (params == NULL) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    umf_devdax_memory_provider_params_t *in_params =
-        (umf_devdax_memory_provider_params_t *)params;
+    const umf_devdax_memory_provider_params_t *in_params = params;
 
     if (in_params->path == NULL) {
         LOG_ERR("devdax path is missing");
@@ -167,22 +198,45 @@ static umf_result_t devdax_initialize(void *params, void **provider) {
     }
 
     memset(devdax_provider, 0, sizeof(*devdax_provider));
+    snprintf(devdax_provider->name, sizeof(devdax_provider->name), "%s",
+             in_params->name);
+
+    coarse_params_t coarse_params = {0};
+    coarse_params.provider = devdax_provider;
+    coarse_params.page_size = DEVDAX_PAGE_SIZE_2MB;
+    // The alloc callback is not available in case of the devdax provider
+    // because it is a fixed-size memory provider
+    // and the entire devdax memory is added as a single block
+    // to the coarse library.
+    coarse_params.cb.alloc = NULL;
+    coarse_params.cb.free = NULL; // not available for the devdax provider
+    coarse_params.cb.split = devdax_allocation_split_cb;
+    coarse_params.cb.merge = devdax_allocation_merge_cb;
+
+    coarse_t *coarse = NULL;
+    ret = coarse_new(&coarse_params, &coarse);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("coarse_new() failed");
+        goto err_free_devdax_provider;
+    }
+
+    devdax_provider->coarse = coarse;
 
     ret = devdax_translate_params(in_params, devdax_provider);
     if (ret != UMF_RESULT_SUCCESS) {
-        goto err_free_devdax_provider;
+        goto err_coarse_delete;
     }
 
     devdax_provider->size = in_params->size;
     if (utils_copy_path(in_params->path, devdax_provider->path, PATH_MAX)) {
-        goto err_free_devdax_provider;
+        goto err_coarse_delete;
     }
 
     int fd = utils_devdax_open(in_params->path);
     if (fd == -1) {
         LOG_ERR("cannot open the device DAX: %s", in_params->path);
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_free_devdax_provider;
+        goto err_coarse_delete;
     }
 
     bool is_dax = false;
@@ -196,23 +250,26 @@ static umf_result_t devdax_initialize(void *params, void **provider) {
         LOG_PDEBUG("mapping the devdax failed (path=%s, size=%zu)",
                    in_params->path, devdax_provider->size);
         ret = UMF_RESULT_ERROR_UNKNOWN;
-        goto err_free_devdax_provider;
+        goto err_coarse_delete;
     }
 
     if (!is_dax) {
         LOG_ERR("mapping the devdax with MAP_SYNC failed: %s", in_params->path);
         ret = UMF_RESULT_ERROR_UNKNOWN;
-
-        if (devdax_provider->base) {
-            utils_munmap(devdax_provider->base, devdax_provider->size);
-        }
-
-        goto err_free_devdax_provider;
+        goto err_unmap_devdax;
     }
 
     LOG_DEBUG("devdax memory mapped (path=%s, size=%zu, addr=%p)",
               in_params->path, devdax_provider->size, devdax_provider->base);
 
+    // add the entire devdax memory as a single block
+    ret = coarse_add_memory_fixed(coarse, devdax_provider->base,
+                                  devdax_provider->size);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("adding memory block failed");
+        goto err_unmap_devdax;
+    }
+
     if (utils_mutex_init(&devdax_provider->lock) == NULL) {
         LOG_ERR("lock init failed");
         ret = UMF_RESULT_ERROR_UNKNOWN;
@@ -224,103 +281,56 @@ static umf_result_t devdax_initialize(void *params, void **provider) {
     return UMF_RESULT_SUCCESS;
 
 err_unmap_devdax:
-    utils_munmap(devdax_provider->base, devdax_provider->size);
+    if (devdax_provider->base) {
+        utils_munmap(devdax_provider->base, devdax_provider->size);
+    }
+err_coarse_delete:
+    coarse_delete(devdax_provider->coarse);
 err_free_devdax_provider:
     umf_ba_global_free(devdax_provider);
     return ret;
 }
 
-static void devdax_finalize(void *provider) {
+static umf_result_t devdax_finalize(void *provider) {
     devdax_memory_provider_t *devdax_provider = provider;
+    umf_result_t ret = UMF_RESULT_SUCCESS;
     utils_mutex_destroy_not_free(&devdax_provider->lock);
-    utils_munmap(devdax_provider->base, devdax_provider->size);
-    umf_ba_global_free(devdax_provider);
-}
-
-static int devdax_alloc_aligned(size_t length, size_t alignment, void *base,
-                                size_t size, utils_mutex_t *lock,
-                                void **out_addr, size_t *offset) {
-    assert(out_addr);
-
-    if (utils_mutex_lock(lock)) {
-        LOG_ERR("locking file offset failed");
-        return -1;
-    }
-
-    uintptr_t ptr = (uintptr_t)base + *offset;
-    uintptr_t rest_of_div = alignment ? (ptr % alignment) : 0;
-
-    if (alignment > 0 && rest_of_div > 0) {
-        ptr += alignment - rest_of_div;
-    }
-
-    size_t new_offset = ptr - (uintptr_t)base + length;
-
-    if (new_offset > size) {
-        utils_mutex_unlock(lock);
-        LOG_ERR("cannot allocate more memory than the device DAX size: %zu",
-                size);
-        return -1;
+    if (utils_munmap(devdax_provider->base, devdax_provider->size)) {
+        LOG_PERR("unmapping the devdax memory failed (path: %s, size: %zu)",
+                 devdax_provider->path, devdax_provider->size);
+        ret = UMF_RESULT_ERROR_UNKNOWN;
     }
 
-    *offset = new_offset;
-    *out_addr = (void *)ptr;
-
-    utils_mutex_unlock(lock);
-
-    return 0;
+    coarse_delete(devdax_provider->coarse);
+    umf_ba_global_free(devdax_provider);
+    return ret;
 }
 
 static umf_result_t devdax_alloc(void *provider, size_t size, size_t alignment,
                                  void **resultPtr) {
-    int ret;
-
-    // alignment must be a power of two and a multiple or a divider of the page size
-    if (alignment && ((alignment & (alignment - 1)) ||
-                      ((alignment % DEVDAX_PAGE_SIZE_2MB) &&
-                       (DEVDAX_PAGE_SIZE_2MB % alignment)))) {
-        LOG_ERR("wrong alignment: %zu (not a power of 2 or a multiple or a "
-                "divider of the page size (%zu))",
-                alignment, DEVDAX_PAGE_SIZE_2MB);
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    if (IS_NOT_ALIGNED(alignment, DEVDAX_PAGE_SIZE_2MB)) {
-        alignment = ALIGN_UP(alignment, DEVDAX_PAGE_SIZE_2MB);
-    }
-
     devdax_memory_provider_t *devdax_provider =
         (devdax_memory_provider_t *)provider;
-
-    void *addr = NULL;
-    errno = 0;
-    ret = devdax_alloc_aligned(size, alignment, devdax_provider->base,
-                               devdax_provider->size, &devdax_provider->lock,
-                               &addr, &devdax_provider->offset);
-    if (ret) {
-        devdax_store_last_native_error(UMF_DEVDAX_RESULT_ERROR_ALLOC_FAILED, 0);
-        LOG_ERR("memory allocation failed");
-        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    umf_result_t ret =
+        coarse_alloc(devdax_provider->coarse, size, alignment, resultPtr);
+    if (ret == UMF_RESULT_SUCCESS) {
+        provider_ctl_stats_alloc(devdax_provider, size);
     }
-
-    *resultPtr = addr;
-
-    return UMF_RESULT_SUCCESS;
+    return ret;
 }
 
-static void devdax_get_last_native_error(void *provider, const char **ppMessage,
-                                         int32_t *pError) {
+static umf_result_t devdax_get_last_native_error(void *provider,
+                                                 const char **ppMessage,
+                                                 int32_t *pError) {
     (void)provider; // unused
 
     if (ppMessage == NULL || pError == NULL) {
-        assert(0);
-        return;
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
     *pError = TLS_last_native_error.native_error;
     if (TLS_last_native_error.errno_value == 0) {
         *ppMessage = Native_error_str[*pError - UMF_DEVDAX_RESULT_SUCCESS];
-        return;
+        return UMF_RESULT_SUCCESS;
     }
 
     const char *msg;
@@ -341,6 +351,7 @@ static void devdax_get_last_native_error(void *provider, const char **ppMessage,
                    TLS_last_native_error.msg_buff + pos, TLS_MSG_BUF_LEN - pos);
 
     *ppMessage = TLS_last_native_error.msg_buff;
+    return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t devdax_get_recommended_page_size(void *provider,
@@ -354,7 +365,7 @@ static umf_result_t devdax_get_recommended_page_size(void *provider,
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t devdax_get_min_page_size(void *provider, void *ptr,
+static umf_result_t devdax_get_min_page_size(void *provider, const void *ptr,
                                              size_t *page_size) {
     (void)ptr; // unused
 
@@ -383,14 +394,31 @@ static umf_result_t devdax_purge_force(void *provider, void *ptr, size_t size) {
     return UMF_RESULT_SUCCESS;
 }
 
-static const char *devdax_get_name(void *provider) {
-    (void)provider; // unused
-    return "DEVDAX";
+static umf_result_t devdax_get_name(void *provider, const char **name) {
+    if (!name) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    if (provider == NULL) {
+        *name = DEFAULT_NAME;
+        return UMF_RESULT_SUCCESS;
+    }
+    devdax_memory_provider_t *devdax_provider =
+        (devdax_memory_provider_t *)provider;
+    *name = devdax_provider->name;
+    return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t devdax_allocation_split(void *provider, void *ptr,
                                             size_t totalSize,
                                             size_t firstSize) {
+    devdax_memory_provider_t *devdax_provider =
+        (devdax_memory_provider_t *)provider;
+    return coarse_split(devdax_provider->coarse, ptr, totalSize, firstSize);
+}
+
+static umf_result_t devdax_allocation_split_cb(void *provider, void *ptr,
+                                               size_t totalSize,
+                                               size_t firstSize) {
     (void)provider;
     (void)ptr;
     (void)totalSize;
@@ -400,6 +428,14 @@ static umf_result_t devdax_allocation_split(void *provider, void *ptr,
 
 static umf_result_t devdax_allocation_merge(void *provider, void *lowPtr,
                                             void *highPtr, size_t totalSize) {
+    devdax_memory_provider_t *devdax_provider =
+        (devdax_memory_provider_t *)provider;
+    return coarse_merge(devdax_provider->coarse, lowPtr, highPtr, totalSize);
+}
+
+static umf_result_t devdax_allocation_merge_cb(void *provider, void *lowPtr,
+                                               void *highPtr,
+                                               size_t totalSize) {
     (void)provider;
     (void)lowPtr;
     (void)highPtr;
@@ -429,7 +465,7 @@ 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);
+    strncpy(devdax_ipc_data->path, devdax_provider->path, PATH_MAX);
     devdax_ipc_data->path[PATH_MAX - 1] = '\0';
     devdax_ipc_data->protection = devdax_provider->protection;
     devdax_ipc_data->offset =
@@ -534,32 +570,54 @@ static umf_result_t devdax_close_ipc_handle(void *provider, void *ptr,
     return UMF_RESULT_SUCCESS;
 }
 
+static umf_result_t devdax_ctl(void *provider,
+                               umf_ctl_query_source_t operationType,
+                               const char *name, void *arg, size_t size,
+                               umf_ctl_query_type_t query_type, va_list args) {
+    utils_init_once(&ctl_initialized, initialize_devdax_ctl);
+    return ctl_query(&devdax_memory_ctl_root, provider, operationType, name,
+                     query_type, arg, size, args);
+}
+
+static umf_result_t devdax_free(void *provider, void *ptr, size_t size) {
+    devdax_memory_provider_t *devdax_provider =
+        (devdax_memory_provider_t *)provider;
+    umf_result_t ret = coarse_free(devdax_provider->coarse, ptr, size);
+    if (ret == UMF_RESULT_SUCCESS) {
+        provider_ctl_stats_free(devdax_provider, size);
+    }
+    return ret;
+}
+
 static umf_memory_provider_ops_t UMF_DEVDAX_MEMORY_PROVIDER_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = devdax_initialize,
     .finalize = devdax_finalize,
     .alloc = devdax_alloc,
+    .free = devdax_free,
     .get_last_native_error = devdax_get_last_native_error,
     .get_recommended_page_size = devdax_get_recommended_page_size,
     .get_min_page_size = devdax_get_min_page_size,
     .get_name = devdax_get_name,
-    .ext.purge_lazy = devdax_purge_lazy,
-    .ext.purge_force = devdax_purge_force,
-    .ext.allocation_merge = devdax_allocation_merge,
-    .ext.allocation_split = devdax_allocation_split,
-    .ipc.get_ipc_handle_size = devdax_get_ipc_handle_size,
-    .ipc.get_ipc_handle = devdax_get_ipc_handle,
-    .ipc.put_ipc_handle = devdax_put_ipc_handle,
-    .ipc.open_ipc_handle = devdax_open_ipc_handle,
-    .ipc.close_ipc_handle = devdax_close_ipc_handle};
-
-umf_memory_provider_ops_t *umfDevDaxMemoryProviderOps(void) {
+    .ext_purge_lazy = devdax_purge_lazy,
+    .ext_purge_force = devdax_purge_force,
+    .ext_allocation_merge = devdax_allocation_merge,
+    .ext_allocation_split = devdax_allocation_split,
+    .ext_get_ipc_handle_size = devdax_get_ipc_handle_size,
+    .ext_get_ipc_handle = devdax_get_ipc_handle,
+    .ext_put_ipc_handle = devdax_put_ipc_handle,
+    .ext_open_ipc_handle = devdax_open_ipc_handle,
+    .ext_close_ipc_handle = devdax_close_ipc_handle,
+    .ext_ctl = devdax_ctl,
+};
+
+const umf_memory_provider_ops_t *umfDevDaxMemoryProviderOps(void) {
     return &UMF_DEVDAX_MEMORY_PROVIDER_OPS;
 }
 
 umf_result_t umfDevDaxMemoryProviderParamsCreate(
-    umf_devdax_memory_provider_params_handle_t *hParams, const char *path,
-    size_t size) {
+    const char *path, size_t size,
+    umf_devdax_memory_provider_params_handle_t *hParams) {
     libumfInit();
     if (hParams == NULL) {
         LOG_ERR("DevDax Memory Provider params handle is NULL");
@@ -579,6 +637,9 @@ umf_result_t umfDevDaxMemoryProviderParamsCreate(
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
+    strncpy(params->name, DEFAULT_NAME, sizeof(params->name) - 1);
+    params->name[sizeof(params->name) - 1] = '\0';
+
     params->path = NULL;
     params->size = 0;
     params->protection = UMF_PROTECTION_READ | UMF_PROTECTION_WRITE;
@@ -663,4 +724,22 @@ umf_result_t umfDevDaxMemoryProviderParamsSetProtection(
     return UMF_RESULT_SUCCESS;
 }
 
-#endif // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+umf_result_t umfDevDaxMemoryProviderParamsSetName(
+    umf_devdax_memory_provider_params_handle_t hParams, const char *name) {
+    if (hParams == NULL) {
+        LOG_ERR("DevDax Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (name == NULL) {
+        LOG_ERR("name is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    strncpy(hParams->name, name, sizeof(hParams->name) - 1);
+    hParams->name[sizeof(hParams->name) - 1] = '\0';
+
+    return UMF_RESULT_SUCCESS;
+}
+
+#endif // !defined(_WIN32)
diff --git a/src/provider/provider_file_memory.c b/src/provider/provider_file_memory.c
index 7c9ee38564..d666a2fd71 100644
--- a/src/provider/provider_file_memory.c
+++ b/src/provider/provider_file_memory.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -20,16 +20,16 @@
 
 #include "utils_log.h"
 
-#if defined(_WIN32) || defined(UMF_NO_HWLOC)
+#if defined(_WIN32)
 
-umf_memory_provider_ops_t *umfFileMemoryProviderOps(void) {
+const umf_memory_provider_ops_t *umfFileMemoryProviderOps(void) {
     // not supported
     LOG_ERR("File memory provider is disabled!");
     return NULL;
 }
 
 umf_result_t umfFileMemoryProviderParamsCreate(
-    umf_file_memory_provider_params_handle_t *hParams, const char *path) {
+    const char *path, umf_file_memory_provider_params_handle_t *hParams) {
     (void)hParams;
     (void)path;
     LOG_ERR("File memory provider is disabled!");
@@ -68,11 +68,21 @@ umf_result_t umfFileMemoryProviderParamsSetVisibility(
     return UMF_RESULT_ERROR_NOT_SUPPORTED;
 }
 
-#else // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+umf_result_t umfFileMemoryProviderParamsSetName(
+    umf_file_memory_provider_params_handle_t hParams, const char *name) {
+    (void)hParams;
+    (void)name;
+    LOG_ERR("File memory provider is disabled!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+#else // !defined(_WIN32)
 
 #include "base_alloc_global.h"
+#include "coarse.h"
 #include "critnib.h"
 #include "libumf.h"
+#include "provider_ctl_stats_type.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
 #include "utils_log.h"
@@ -81,6 +91,8 @@ umf_result_t umfFileMemoryProviderParamsSetVisibility(
 
 #define TLS_MSG_BUF_LEN 1024
 
+static const char *DEFAULT_NAME = "FILE";
+
 typedef struct file_memory_provider_t {
     utils_mutex_t lock; // lock for file parameters (size and offsets)
 
@@ -106,16 +118,25 @@ typedef struct file_memory_provider_t {
     // A critnib map storing (ptr, fd_offset + 1) pairs. We add 1 to fd_offset
     // in order to be able to store fd_offset equal 0, because
     // critnib_get() returns value or NULL, so a value cannot equal 0.
-    // It is needed mainly in the get_ipc_handle and open_ipc_handle hooks
+    // It is needed mainly in the ipc_get_handle and ipc_open_handle hooks
     // to mmap a specific part of a file.
     critnib *fd_offset_map;
+
+    coarse_t *coarse; // coarse library handle
+
+    ctl_stats_t stats;
+    char name[64];
 } file_memory_provider_t;
 
+#define CTL_PROVIDER_TYPE file_memory_provider_t
+#include "provider_ctl_stats_impl.h"
+
 // File Memory Provider settings struct
 typedef struct umf_file_memory_provider_params_t {
     char *path;
     unsigned protection;
     umf_memory_visibility_t visibility;
+    char name[64];
 } umf_file_memory_provider_params_t;
 
 typedef struct file_last_native_error_t {
@@ -136,6 +157,21 @@ static __TLS file_last_native_error_t TLS_last_native_error;
 #define _UMF_FILE_RESULT_ERROR_PURGE_FORCE_FAILED                              \
     (UMF_FILE_RESULT_ERROR_PURGE_FORCE_FAILED - UMF_FILE_RESULT_SUCCESS)
 
+struct ctl file_memory_ctl_root;
+static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT;
+
+static umf_result_t file_post_initialize(void *provider);
+static umf_result_t
+CTL_RUNNABLE_HANDLER(post_initialize)(void *ctx, umf_ctl_query_source_t source,
+                                      void *arg, size_t size,
+                                      umf_ctl_index_utlist_t *indexes) {
+    (void)source;
+    (void)arg;
+    (void)size;
+    (void)indexes;
+    return file_post_initialize(ctx);
+}
+
 static const char *Native_error_str[] = {
     [_UMF_FILE_RESULT_SUCCESS] = "success",
     [_UMF_FILE_RESULT_ERROR_ALLOC_FAILED] = "memory allocation failed",
@@ -149,8 +185,18 @@ static void file_store_last_native_error(int32_t native_error,
     TLS_last_native_error.errno_value = errno_value;
 }
 
+static void initialize_file_ctl(void) {
+    CTL_REGISTER_MODULE(&file_memory_ctl_root, stats);
+    file_memory_ctl_root.root[file_memory_ctl_root.first_free++] =
+        (umf_ctl_node_t){
+            .name = "post_initialize",
+            .type = CTL_NODE_LEAF,
+            .runnable_cb = CTL_RUNNABLE_HANDLER(post_initialize),
+        };
+}
+
 static umf_result_t
-file_translate_params(umf_file_memory_provider_params_t *in_params,
+file_translate_params(const umf_file_memory_provider_params_t *in_params,
                       file_memory_provider_t *provider) {
     umf_result_t result;
 
@@ -174,15 +220,22 @@ file_translate_params(umf_file_memory_provider_params_t *in_params,
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t file_initialize(void *params, void **provider) {
+static umf_result_t file_alloc_cb(void *provider, size_t size, size_t alignment,
+                                  void **resultPtr);
+static umf_result_t file_allocation_split_cb(void *provider, void *ptr,
+                                             size_t totalSize,
+                                             size_t firstSize);
+static umf_result_t file_allocation_merge_cb(void *provider, void *lowPtr,
+                                             void *highPtr, size_t totalSize);
+
+static umf_result_t file_initialize(const void *params, void **provider) {
     umf_result_t ret;
 
     if (params == NULL) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    umf_file_memory_provider_params_t *in_params =
-        (umf_file_memory_provider_params_t *)params;
+    const umf_file_memory_provider_params_t *in_params = params;
 
     if (in_params->path == NULL) {
         LOG_ERR("file path is missing");
@@ -196,6 +249,8 @@ static umf_result_t file_initialize(void *params, void **provider) {
     }
 
     memset(file_provider, 0, sizeof(*file_provider));
+    snprintf(file_provider->name, sizeof(file_provider->name), "%s",
+             in_params->name);
 
     ret = file_translate_params(in_params, file_provider);
     if (ret != UMF_RESULT_SUCCESS) {
@@ -241,59 +296,100 @@ static umf_result_t file_initialize(void *params, void **provider) {
         file_provider->page_size = utils_get_page_size();
     }
 
+    coarse_params_t coarse_params = {0};
+    coarse_params.provider = file_provider;
+    coarse_params.page_size = file_provider->page_size;
+    coarse_params.cb.alloc = file_alloc_cb;
+    coarse_params.cb.free = NULL; // not available for the file provider
+    coarse_params.cb.split = file_allocation_split_cb;
+    coarse_params.cb.merge = file_allocation_merge_cb;
+
+    coarse_t *coarse = NULL;
+    ret = coarse_new(&coarse_params, &coarse);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("coarse_new() failed");
+        goto err_close_fd;
+    }
+
+    file_provider->coarse = coarse;
+
+    *provider = file_provider;
+    return UMF_RESULT_SUCCESS;
+
+err_close_fd:
+    utils_close_fd(file_provider->fd);
+err_free_file_provider:
+    umf_ba_global_free(file_provider);
+    return ret;
+}
+
+static umf_result_t file_post_initialize(void *provider) {
+    umf_result_t ret = UMF_RESULT_SUCCESS;
+    file_memory_provider_t *file_provider = provider;
+
+    assert(provider);
+
     if (utils_mutex_init(&file_provider->lock) == NULL) {
         LOG_ERR("lock init failed");
         ret = UMF_RESULT_ERROR_UNKNOWN;
-        goto err_close_fd;
+        goto err_coarse_delete;
     }
 
-    file_provider->fd_offset_map = critnib_new();
+    file_provider->fd_offset_map = critnib_new(NULL, NULL);
     if (!file_provider->fd_offset_map) {
         LOG_ERR("creating the map of file descriptor offsets failed");
         ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
         goto err_mutex_destroy_not_free;
     }
 
-    file_provider->mmaps = critnib_new();
+    file_provider->mmaps = critnib_new(NULL, NULL);
     if (!file_provider->mmaps) {
         LOG_ERR("creating the map of memory mappings failed");
         ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
         goto err_delete_fd_offset_map;
     }
 
-    *provider = file_provider;
-
     return UMF_RESULT_SUCCESS;
 
 err_delete_fd_offset_map:
     critnib_delete(file_provider->fd_offset_map);
 err_mutex_destroy_not_free:
     utils_mutex_destroy_not_free(&file_provider->lock);
-err_close_fd:
-    utils_close_fd(file_provider->fd);
-err_free_file_provider:
+err_coarse_delete:
+    coarse_delete(file_provider->coarse);
+    if (utils_close_fd(file_provider->fd)) {
+        LOG_PERR("closing file descriptor %d failed", file_provider->fd);
+    }
     umf_ba_global_free(file_provider);
     return ret;
 }
 
-static void file_finalize(void *provider) {
+static umf_result_t file_finalize(void *provider) {
     file_memory_provider_t *file_provider = provider;
 
     uintptr_t key = 0;
     uintptr_t rkey = 0;
     void *rvalue = NULL;
-    while (1 ==
-           critnib_find(file_provider->mmaps, key, FIND_G, &rkey, &rvalue)) {
+    umf_result_t ret = UMF_RESULT_SUCCESS;
+    while (1 == critnib_find(file_provider->mmaps, key, FIND_G, &rkey, &rvalue,
+                             NULL)) {
         utils_munmap((void *)rkey, (size_t)rvalue);
-        critnib_remove(file_provider->mmaps, rkey);
+        critnib_remove(file_provider->mmaps, rkey, NULL);
         key = rkey;
     }
 
     utils_mutex_destroy_not_free(&file_provider->lock);
-    utils_close_fd(file_provider->fd);
+
+    if (utils_close_fd(file_provider->fd)) {
+        LOG_PERR("closing file descriptor %d failed", file_provider->fd);
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+    }
     critnib_delete(file_provider->fd_offset_map);
     critnib_delete(file_provider->mmaps);
+    coarse_delete(file_provider->coarse);
     umf_ba_global_free(file_provider);
+
+    return ret;
 }
 
 static umf_result_t file_mmap_aligned(file_memory_provider_t *file_provider,
@@ -373,8 +469,12 @@ static umf_result_t file_mmap_aligned(file_memory_provider_t *file_provider,
         "inserted a value to the map of memory mapping (addr=%p, size=%zu)",
         ptr, extended_size);
 
-    file_provider->base_mmap = ptr;
-    file_provider->size_mmap = extended_size;
+    // align the new pointer
+    uintptr_t aligned_ptr = ALIGN_UP_SAFE((uintptr_t)ptr, alignment);
+    size_t aligned_size = extended_size - (aligned_ptr - (uintptr_t)ptr);
+
+    file_provider->base_mmap = (void *)aligned_ptr;
+    file_provider->size_mmap = aligned_size;
     file_provider->offset_mmap = 0;
 
     return UMF_RESULT_SUCCESS;
@@ -394,6 +494,8 @@ static umf_result_t file_alloc_aligned(file_memory_provider_t *file_provider,
         return UMF_RESULT_ERROR_UNKNOWN;
     }
 
+    assert(file_provider->offset_mmap <= file_provider->size_mmap);
+
     if (file_provider->size_mmap - file_provider->offset_mmap < size) {
         umf_result = file_mmap_aligned(file_provider, size, alignment);
         if (umf_result != UMF_RESULT_SUCCESS) {
@@ -419,7 +521,8 @@ static umf_result_t file_alloc_aligned(file_memory_provider_t *file_provider,
     size_t new_offset_fd =
         file_provider->offset_fd + new_offset_mmap - file_provider->offset_mmap;
 
-    if (file_provider->size_mmap - new_offset_mmap < size) {
+    // new_offset_mmap can be greater than file_provider->size_mmap
+    if (file_provider->size_mmap < size + new_offset_mmap) {
         umf_result = file_mmap_aligned(file_provider, size, alignment);
         if (umf_result != UMF_RESULT_SUCCESS) {
             utils_mutex_unlock(&file_provider->lock);
@@ -451,11 +554,24 @@ static umf_result_t file_alloc_aligned(file_memory_provider_t *file_provider,
 
 static umf_result_t file_alloc(void *provider, size_t size, size_t alignment,
                                void **resultPtr) {
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    umf_result_t ret =
+        coarse_alloc(file_provider->coarse, size, alignment, resultPtr);
+    if (ret == UMF_RESULT_SUCCESS) {
+        provider_ctl_stats_alloc(file_provider, size);
+    }
+    return ret;
+}
+
+static umf_result_t file_alloc_cb(void *provider, size_t size, size_t alignment,
+                                  void **resultPtr) {
     umf_result_t umf_result;
     int ret;
 
     file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
 
+    *resultPtr = NULL;
+
     // alignment must be a power of two and a multiple or a divider of the page size
     if (alignment && ((alignment & (alignment - 1)) ||
                       ((alignment % file_provider->page_size) &&
@@ -488,26 +604,33 @@ static umf_result_t file_alloc(void *provider, size_t size, size_t alignment,
         LOG_ERR("inserting a value to the file descriptor offset map failed "
                 "(addr=%p, offset=%zu)",
                 addr, alloc_offset_fd);
+        // We cannot undo the file_alloc_aligned() call here,
+        // because the file memory provider does not support the free operation.
+        return UMF_RESULT_ERROR_UNKNOWN;
     }
 
+    LOG_DEBUG("inserted a value to the file descriptor offset map (addr=%p, "
+              "offset=%zu)",
+              addr, alloc_offset_fd);
+
     *resultPtr = addr;
 
     return UMF_RESULT_SUCCESS;
 }
 
-static void file_get_last_native_error(void *provider, const char **ppMessage,
-                                       int32_t *pError) {
+static umf_result_t file_get_last_native_error(void *provider,
+                                               const char **ppMessage,
+                                               int32_t *pError) {
     (void)provider; // unused
 
     if (ppMessage == NULL || pError == NULL) {
-        assert(0);
-        return;
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
     *pError = TLS_last_native_error.native_error;
     if (TLS_last_native_error.errno_value == 0) {
         *ppMessage = Native_error_str[*pError - UMF_FILE_RESULT_SUCCESS];
-        return;
+        return UMF_RESULT_SUCCESS;
     }
 
     const char *msg;
@@ -528,6 +651,7 @@ static void file_get_last_native_error(void *provider, const char **ppMessage,
                    TLS_last_native_error.msg_buff + pos, TLS_MSG_BUF_LEN - pos);
 
     *ppMessage = TLS_last_native_error.msg_buff;
+    return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t file_get_recommended_page_size(void *provider, size_t size,
@@ -541,7 +665,7 @@ static umf_result_t file_get_recommended_page_size(void *provider, size_t size,
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t file_get_min_page_size(void *provider, void *ptr,
+static umf_result_t file_get_min_page_size(void *provider, const void *ptr,
                                            size_t *page_size) {
     (void)ptr; // unused
 
@@ -571,15 +695,28 @@ static umf_result_t file_purge_force(void *provider, void *ptr, size_t size) {
     return UMF_RESULT_SUCCESS;
 }
 
-static const char *file_get_name(void *provider) {
-    (void)provider; // unused
-    return "FILE";
+static umf_result_t file_get_name(void *provider, const char **name) {
+    if (!name) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    if (provider == NULL) {
+        *name = DEFAULT_NAME;
+        return UMF_RESULT_SUCCESS;
+    }
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    *name = file_provider->name;
+    return UMF_RESULT_SUCCESS;
 }
 
-// This function is supposed to be thread-safe, so it should NOT be called concurrently
-// with file_allocation_merge() with the same pointer.
 static umf_result_t file_allocation_split(void *provider, void *ptr,
                                           size_t totalSize, size_t firstSize) {
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    return coarse_split(file_provider->coarse, ptr, totalSize, firstSize);
+}
+
+static umf_result_t file_allocation_split_cb(void *provider, void *ptr,
+                                             size_t totalSize,
+                                             size_t firstSize) {
     (void)totalSize;
 
     file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
@@ -587,31 +724,45 @@ static umf_result_t file_allocation_split(void *provider, void *ptr,
         return UMF_RESULT_SUCCESS;
     }
 
-    void *value = critnib_get(file_provider->fd_offset_map, (uintptr_t)ptr);
+    void *value =
+        critnib_get(file_provider->fd_offset_map, (uintptr_t)ptr, NULL);
     if (value == NULL) {
-        LOG_ERR("file_allocation_split(): getting a value from the file "
-                "descriptor offset map failed (addr=%p)",
+        LOG_ERR("getting a value from the file descriptor offset map failed "
+                "(addr=%p)",
                 ptr);
         return UMF_RESULT_ERROR_UNKNOWN;
     }
 
+    LOG_DEBUG("split the value from the file descriptor offset map (addr=%p) "
+              "from size %zu to %zu + %zu",
+              ptr, totalSize, firstSize, totalSize - firstSize);
+
     uintptr_t new_key = (uintptr_t)ptr + firstSize;
     void *new_value = (void *)((uintptr_t)value + firstSize);
     int ret = critnib_insert(file_provider->fd_offset_map, new_key, new_value,
                              0 /* update */);
     if (ret) {
-        LOG_ERR("file_allocation_split(): inserting a value to the file "
-                "descriptor offset map failed (addr=%p, offset=%zu)",
+        LOG_ERR("inserting a value to the file descriptor offset map failed "
+                "(addr=%p, offset=%zu)",
                 (void *)new_key, (size_t)new_value - 1);
         return UMF_RESULT_ERROR_UNKNOWN;
     }
 
+    LOG_DEBUG("inserted a value to the file descriptor offset map (addr=%p, "
+              "offset=%zu)",
+              (void *)new_key, (size_t)new_value - 1);
+
     return UMF_RESULT_SUCCESS;
 }
 
-// It should NOT be called concurrently with file_allocation_split() with the same pointer.
 static umf_result_t file_allocation_merge(void *provider, void *lowPtr,
                                           void *highPtr, size_t totalSize) {
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    return coarse_merge(file_provider->coarse, lowPtr, highPtr, totalSize);
+}
+
+static umf_result_t file_allocation_merge_cb(void *provider, void *lowPtr,
+                                             void *highPtr, size_t totalSize) {
     (void)lowPtr;
     (void)totalSize;
 
@@ -621,14 +772,18 @@ static umf_result_t file_allocation_merge(void *provider, void *lowPtr,
     }
 
     void *value =
-        critnib_remove(file_provider->fd_offset_map, (uintptr_t)highPtr);
+        critnib_remove(file_provider->fd_offset_map, (uintptr_t)highPtr, NULL);
     if (value == NULL) {
-        LOG_ERR("file_allocation_merge(): removing a value from the file "
-                "descriptor offset map failed (addr=%p)",
+        LOG_ERR("removing a value from the file descriptor offset map failed "
+                "(addr=%p)",
                 highPtr);
         return UMF_RESULT_ERROR_UNKNOWN;
     }
 
+    LOG_DEBUG("removed a value from the file descriptor offset map (addr=%p) - "
+              "merged with %p",
+              highPtr, lowPtr);
+
     return UMF_RESULT_SUCCESS;
 }
 
@@ -660,18 +815,17 @@ static umf_result_t file_get_ipc_handle(void *provider, const void *ptr,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    void *value = critnib_get(file_provider->fd_offset_map, (uintptr_t)ptr);
+    void *value =
+        critnib_get(file_provider->fd_offset_map, (uintptr_t)ptr, NULL);
     if (value == NULL) {
-        LOG_ERR("file_get_ipc_handle(): getting a value from the IPC cache "
-                "failed (addr=%p)",
-                ptr);
+        LOG_ERR("getting a value from the IPC cache failed (addr=%p)", ptr);
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
     file_ipc_data_t *file_ipc_data = (file_ipc_data_t *)providerIpcData;
     file_ipc_data->offset_fd = (size_t)value - 1;
     file_ipc_data->size = size;
-    strncpy(file_ipc_data->path, file_provider->path, PATH_MAX - 1);
+    strncpy(file_ipc_data->path, file_provider->path, PATH_MAX);
     file_ipc_data->path[PATH_MAX - 1] = '\0';
     file_ipc_data->protection = file_provider->protection;
     file_ipc_data->visibility = file_provider->visibility;
@@ -776,31 +930,52 @@ static umf_result_t file_close_ipc_handle(void *provider, void *ptr,
     return UMF_RESULT_SUCCESS;
 }
 
+static umf_result_t file_ctl(void *provider,
+                             umf_ctl_query_source_t operationType,
+                             const char *name, void *arg, size_t size,
+                             umf_ctl_query_type_t query_type, va_list args) {
+    utils_init_once(&ctl_initialized, initialize_file_ctl);
+    return ctl_query(&file_memory_ctl_root, provider, operationType, name,
+                     query_type, arg, size, args);
+}
+
+static umf_result_t file_free(void *provider, void *ptr, size_t size) {
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    umf_result_t ret = coarse_free(file_provider->coarse, ptr, size);
+    if (ret == UMF_RESULT_SUCCESS) {
+        provider_ctl_stats_free(file_provider, size);
+    }
+    return ret;
+}
+
 static umf_memory_provider_ops_t UMF_FILE_MEMORY_PROVIDER_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = file_initialize,
     .finalize = file_finalize,
     .alloc = file_alloc,
+    .free = file_free,
     .get_last_native_error = file_get_last_native_error,
     .get_recommended_page_size = file_get_recommended_page_size,
     .get_min_page_size = file_get_min_page_size,
     .get_name = file_get_name,
-    .ext.purge_lazy = file_purge_lazy,
-    .ext.purge_force = file_purge_force,
-    .ext.allocation_merge = file_allocation_merge,
-    .ext.allocation_split = file_allocation_split,
-    .ipc.get_ipc_handle_size = file_get_ipc_handle_size,
-    .ipc.get_ipc_handle = file_get_ipc_handle,
-    .ipc.put_ipc_handle = file_put_ipc_handle,
-    .ipc.open_ipc_handle = file_open_ipc_handle,
-    .ipc.close_ipc_handle = file_close_ipc_handle};
-
-umf_memory_provider_ops_t *umfFileMemoryProviderOps(void) {
+    .ext_purge_lazy = file_purge_lazy,
+    .ext_purge_force = file_purge_force,
+    .ext_allocation_merge = file_allocation_merge,
+    .ext_allocation_split = file_allocation_split,
+    .ext_get_ipc_handle_size = file_get_ipc_handle_size,
+    .ext_get_ipc_handle = file_get_ipc_handle,
+    .ext_put_ipc_handle = file_put_ipc_handle,
+    .ext_open_ipc_handle = file_open_ipc_handle,
+    .ext_close_ipc_handle = file_close_ipc_handle,
+    .ext_ctl = file_ctl,
+};
+
+const umf_memory_provider_ops_t *umfFileMemoryProviderOps(void) {
     return &UMF_FILE_MEMORY_PROVIDER_OPS;
 }
 
 umf_result_t umfFileMemoryProviderParamsCreate(
-    umf_file_memory_provider_params_handle_t *hParams, const char *path) {
+    const char *path, umf_file_memory_provider_params_handle_t *hParams) {
     libumfInit();
     if (hParams == NULL) {
         LOG_ERR("File Memory Provider params handle is NULL");
@@ -822,6 +997,8 @@ umf_result_t umfFileMemoryProviderParamsCreate(
     params->path = NULL;
     params->protection = UMF_PROTECTION_READ | UMF_PROTECTION_WRITE;
     params->visibility = UMF_MEM_MAP_PRIVATE;
+    strncpy(params->name, DEFAULT_NAME, sizeof(params->name) - 1);
+    params->name[sizeof(params->name) - 1] = '\0';
 
     umf_result_t res = umfFileMemoryProviderParamsSetPath(params, path);
     if (res != UMF_RESULT_SUCCESS) {
@@ -903,4 +1080,22 @@ umf_result_t umfFileMemoryProviderParamsSetVisibility(
     return UMF_RESULT_SUCCESS;
 }
 
-#endif // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+umf_result_t umfFileMemoryProviderParamsSetName(
+    umf_file_memory_provider_params_handle_t hParams, const char *name) {
+    if (hParams == NULL) {
+        LOG_ERR("File Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (name == NULL) {
+        LOG_ERR("name is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    strncpy(hParams->name, name, sizeof(hParams->name) - 1);
+    hParams->name[sizeof(hParams->name) - 1] = '\0';
+
+    return UMF_RESULT_SUCCESS;
+}
+
+#endif // !defined(_WIN32)
diff --git a/src/provider/provider_fixed_memory.c b/src/provider/provider_fixed_memory.c
new file mode 100644
index 0000000000..4e8f22e4fb
--- /dev/null
+++ b/src/provider/provider_fixed_memory.c
@@ -0,0 +1,437 @@
+/*
+ * 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
+*/
+
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <umf.h>
+#include <umf/memory_provider_ops.h>
+#include <umf/providers/provider_fixed_memory.h>
+
+#include "base_alloc_global.h"
+#include "coarse.h"
+#include "libumf.h"
+#include "provider_ctl_stats_type.h"
+#include "umf/base.h"
+#include "utils_common.h"
+#include "utils_concurrency.h"
+#include "utils_log.h"
+
+#define TLS_MSG_BUF_LEN 1024
+
+static const char *DEFAULT_NAME = "FIXED";
+
+typedef struct fixed_memory_provider_t {
+    void *base;       // base address of memory
+    size_t size;      // size of the memory region
+    coarse_t *coarse; // coarse library handle
+    ctl_stats_t stats;
+    char name[64];
+} fixed_memory_provider_t;
+
+// Fixed Memory provider settings struct
+typedef struct umf_fixed_memory_provider_params_t {
+    void *ptr;
+    size_t size;
+    char name[64];
+} umf_fixed_memory_provider_params_t;
+
+typedef struct fixed_last_native_error_t {
+    int32_t native_error;
+    int errno_value;
+    char msg_buff[TLS_MSG_BUF_LEN];
+} fixed_last_native_error_t;
+
+static __TLS fixed_last_native_error_t TLS_last_native_error;
+
+// helper values used only in the Native_error_str array
+#define _UMF_FIXED_RESULT_SUCCESS                                              \
+    (UMF_FIXED_RESULT_SUCCESS - UMF_FIXED_RESULT_SUCCESS)
+#define _UMF_FIXED_RESULT_ERROR_PURGE_FORCE_FAILED                             \
+    (UMF_FIXED_RESULT_ERROR_PURGE_FORCE_FAILED - UMF_FIXED_RESULT_SUCCESS)
+
+#define CTL_PROVIDER_TYPE fixed_memory_provider_t
+#include "provider_ctl_stats_impl.h"
+
+struct ctl fixed_memory_ctl_root;
+static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT;
+
+static umf_result_t fixed_post_initialize(void *provider);
+static umf_result_t
+CTL_RUNNABLE_HANDLER(post_initialize)(void *ctx, umf_ctl_query_source_t source,
+                                      void *arg, size_t size,
+                                      umf_ctl_index_utlist_t *indexes) {
+    (void)source;
+    (void)arg;
+    (void)size;
+    (void)indexes;
+    return fixed_post_initialize(ctx);
+}
+
+static void initialize_fixed_ctl(void) {
+    CTL_REGISTER_MODULE(&fixed_memory_ctl_root, stats);
+    fixed_memory_ctl_root.root[fixed_memory_ctl_root.first_free++] =
+        (umf_ctl_node_t){
+            .name = "post_initialize",
+            .type = CTL_NODE_LEAF,
+            .runnable_cb = CTL_RUNNABLE_HANDLER(post_initialize),
+        };
+}
+
+static const char *Native_error_str[] = {
+    [_UMF_FIXED_RESULT_SUCCESS] = "success",
+    [_UMF_FIXED_RESULT_ERROR_PURGE_FORCE_FAILED] = "force purging failed"};
+
+static void fixed_store_last_native_error(int32_t native_error,
+                                          int errno_value) {
+    TLS_last_native_error.native_error = native_error;
+    TLS_last_native_error.errno_value = errno_value;
+}
+
+static umf_result_t fixed_allocation_split_cb(void *provider, void *ptr,
+                                              size_t totalSize,
+                                              size_t firstSize) {
+    (void)provider;
+    (void)ptr;
+    (void)totalSize;
+    (void)firstSize;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t fixed_allocation_merge_cb(void *provider, void *lowPtr,
+                                              void *highPtr, size_t totalSize) {
+    (void)provider;
+    (void)lowPtr;
+    (void)highPtr;
+    (void)totalSize;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t fixed_initialize(const void *params, void **provider) {
+    umf_result_t ret;
+
+    if (params == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    const umf_fixed_memory_provider_params_t *in_params = params;
+
+    fixed_memory_provider_t *fixed_provider =
+        umf_ba_global_alloc(sizeof(*fixed_provider));
+    if (!fixed_provider) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    memset(fixed_provider, 0, sizeof(*fixed_provider));
+    snprintf(fixed_provider->name, sizeof(fixed_provider->name), "%s",
+             in_params->name);
+
+    coarse_params_t coarse_params = {0};
+    coarse_params.provider = fixed_provider;
+    coarse_params.page_size = utils_get_page_size();
+    // The alloc callback is not available in case of the fixed provider
+    // because it is a fixed-size memory provider
+    // and the entire memory is added as a single block
+    // to the coarse library.
+    coarse_params.cb.alloc = NULL;
+    coarse_params.cb.free = NULL; // not available for the fixed provider
+    coarse_params.cb.split = fixed_allocation_split_cb;
+    coarse_params.cb.merge = fixed_allocation_merge_cb;
+
+    coarse_t *coarse = NULL;
+    ret = coarse_new(&coarse_params, &coarse);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("coarse_new() failed");
+        goto err_free_fixed_provider;
+    }
+
+    fixed_provider->coarse = coarse;
+
+    fixed_provider->base = in_params->ptr;
+    fixed_provider->size = in_params->size;
+
+    *provider = fixed_provider;
+
+    return UMF_RESULT_SUCCESS;
+
+err_free_fixed_provider:
+    umf_ba_global_free(fixed_provider);
+    return ret;
+}
+
+static umf_result_t fixed_finalize(void *provider) {
+    fixed_memory_provider_t *fixed_provider = provider;
+    coarse_delete(fixed_provider->coarse);
+    umf_ba_global_free(fixed_provider);
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t fixed_alloc(void *provider, size_t size, size_t alignment,
+                                void **resultPtr) {
+    fixed_memory_provider_t *fixed_provider =
+        (fixed_memory_provider_t *)provider;
+
+    umf_result_t ret =
+        coarse_alloc(fixed_provider->coarse, size, alignment, resultPtr);
+
+    if (ret == UMF_RESULT_SUCCESS) {
+        provider_ctl_stats_alloc(fixed_provider, size);
+    }
+
+    return ret;
+}
+
+static umf_result_t fixed_get_last_native_error(void *provider,
+                                                const char **ppMessage,
+                                                int32_t *pError) {
+    (void)provider; // unused
+
+    if (ppMessage == NULL || pError == NULL) {
+        assert(0);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    *pError = TLS_last_native_error.native_error;
+    if (TLS_last_native_error.errno_value == 0) {
+        *ppMessage = Native_error_str[*pError - UMF_FIXED_RESULT_SUCCESS];
+        return UMF_RESULT_SUCCESS;
+    }
+
+    const char *msg;
+    size_t len;
+    size_t pos = 0;
+
+    msg = Native_error_str[*pError - UMF_FIXED_RESULT_SUCCESS];
+    len = strlen(msg);
+    memcpy(TLS_last_native_error.msg_buff + pos, msg, len + 1);
+    pos += len;
+
+    msg = ": ";
+    len = strlen(msg);
+    memcpy(TLS_last_native_error.msg_buff + pos, msg, len + 1);
+    pos += len;
+
+    utils_strerror(TLS_last_native_error.errno_value,
+                   TLS_last_native_error.msg_buff + pos, TLS_MSG_BUF_LEN - pos);
+
+    *ppMessage = TLS_last_native_error.msg_buff;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t fixed_get_recommended_page_size(void *provider, size_t size,
+                                                    size_t *page_size) {
+    (void)provider; // unused
+    (void)size;     // unused
+
+    *page_size = utils_get_page_size();
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t fixed_get_min_page_size(void *provider, const void *ptr,
+                                            size_t *page_size) {
+    (void)ptr; // unused
+
+    return fixed_get_recommended_page_size(provider, 0, page_size);
+}
+
+static umf_result_t fixed_purge_lazy(void *provider, void *ptr, size_t size) {
+    (void)provider; // unused
+    (void)ptr;      // unused
+    (void)size;     // unused
+    // purge_lazy is unsupported in case of the fixed memory provider
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+static umf_result_t fixed_purge_force(void *provider, void *ptr, size_t size) {
+    (void)provider; // unused
+    errno = 0;
+    if (utils_purge(ptr, size, UMF_PURGE_FORCE)) {
+        fixed_store_last_native_error(UMF_FIXED_RESULT_ERROR_PURGE_FORCE_FAILED,
+                                      errno);
+        LOG_PERR("force purging failed");
+        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    }
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t fixed_get_name(void *provider, const char **name) {
+    if (!name) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    if (provider == NULL) {
+        *name = DEFAULT_NAME;
+        return UMF_RESULT_SUCCESS;
+    }
+    fixed_memory_provider_t *fixed_provider =
+        (fixed_memory_provider_t *)provider;
+    *name = fixed_provider->name;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t fixed_allocation_split(void *provider, void *ptr,
+                                           size_t totalSize, size_t firstSize) {
+    fixed_memory_provider_t *fixed_provider =
+        (fixed_memory_provider_t *)provider;
+    return coarse_split(fixed_provider->coarse, ptr, totalSize, firstSize);
+}
+
+static umf_result_t fixed_allocation_merge(void *provider, void *lowPtr,
+                                           void *highPtr, size_t totalSize) {
+    fixed_memory_provider_t *fixed_provider =
+        (fixed_memory_provider_t *)provider;
+    return coarse_merge(fixed_provider->coarse, lowPtr, highPtr, totalSize);
+}
+
+static umf_result_t fixed_free(void *provider, void *ptr, size_t size) {
+    fixed_memory_provider_t *fixed_provider =
+        (fixed_memory_provider_t *)provider;
+
+    umf_result_t ret = coarse_free(fixed_provider->coarse, ptr, size);
+
+    if (ret == UMF_RESULT_SUCCESS) {
+        provider_ctl_stats_free(fixed_provider, size);
+    }
+
+    return ret;
+}
+
+static umf_result_t fixed_post_initialize(void *provider) {
+    fixed_memory_provider_t *fixed_provider =
+        (fixed_memory_provider_t *)provider;
+    assert(provider);
+
+    umf_result_t ret = coarse_add_memory_fixed(
+        fixed_provider->coarse, fixed_provider->base, fixed_provider->size);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("adding memory block failed");
+        coarse_delete(fixed_provider->coarse);
+        umf_ba_global_free(fixed_provider);
+        return ret;
+    }
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t fixed_ctl(void *provider,
+                              umf_ctl_query_source_t operationType,
+                              const char *name, void *arg, size_t size,
+                              umf_ctl_query_type_t query_type, va_list args) {
+    utils_init_once(&ctl_initialized, initialize_fixed_ctl);
+    return ctl_query(&fixed_memory_ctl_root, provider, operationType, name,
+                     query_type, arg, size, args);
+}
+
+static umf_memory_provider_ops_t UMF_FIXED_MEMORY_PROVIDER_OPS = {
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
+    .initialize = fixed_initialize,
+    .finalize = fixed_finalize,
+    .alloc = fixed_alloc,
+    .free = fixed_free,
+    .get_last_native_error = fixed_get_last_native_error,
+    .get_recommended_page_size = fixed_get_recommended_page_size,
+    .get_min_page_size = fixed_get_min_page_size,
+    .get_name = fixed_get_name,
+    .ext_purge_lazy = fixed_purge_lazy,
+    .ext_purge_force = fixed_purge_force,
+    .ext_allocation_merge = fixed_allocation_merge,
+    .ext_allocation_split = fixed_allocation_split,
+    .ext_get_ipc_handle_size = NULL,
+    .ext_get_ipc_handle = NULL,
+    .ext_put_ipc_handle = NULL,
+    .ext_open_ipc_handle = NULL,
+    .ext_close_ipc_handle = NULL,
+    .ext_ctl = fixed_ctl,
+};
+
+const umf_memory_provider_ops_t *umfFixedMemoryProviderOps(void) {
+    return &UMF_FIXED_MEMORY_PROVIDER_OPS;
+}
+
+umf_result_t umfFixedMemoryProviderParamsCreate(
+    void *ptr, size_t size,
+    umf_fixed_memory_provider_params_handle_t *hParams) {
+    libumfInit();
+    if (hParams == NULL) {
+        LOG_ERR("Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_fixed_memory_provider_params_handle_t params =
+        umf_ba_global_alloc(sizeof(*params));
+    if (params == NULL) {
+        LOG_ERR("Allocating memory for the Memory Provider params failed");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    strncpy(params->name, DEFAULT_NAME, sizeof(params->name) - 1);
+    params->name[sizeof(params->name) - 1] = '\0';
+
+    umf_result_t ret = umfFixedMemoryProviderParamsSetMemory(params, ptr, size);
+    if (ret != UMF_RESULT_SUCCESS) {
+        umf_ba_global_free(params);
+        return ret;
+    }
+
+    *hParams = params;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfFixedMemoryProviderParamsDestroy(
+    umf_fixed_memory_provider_params_handle_t hParams) {
+    if (hParams != NULL) {
+        umf_ba_global_free(hParams);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfFixedMemoryProviderParamsSetMemory(
+    umf_fixed_memory_provider_params_handle_t hParams, void *ptr, size_t size) {
+
+    if (hParams == NULL) {
+        LOG_ERR("Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (ptr == NULL) {
+        LOG_ERR("Memory pointer is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (size == 0) {
+        LOG_ERR("Size must be greater than 0");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->ptr = ptr;
+    hParams->size = size;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfFixedMemoryProviderParamsSetName(
+    umf_fixed_memory_provider_params_handle_t hParams, const char *name) {
+    if (hParams == NULL) {
+        LOG_ERR("Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (name == NULL) {
+        LOG_ERR("name is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    strncpy(hParams->name, name, sizeof(hParams->name) - 1);
+    hParams->name[sizeof(hParams->name) - 1] = '\0';
+
+    return UMF_RESULT_SUCCESS;
+}
diff --git a/src/provider/provider_level_zero.c b/src/provider/provider_level_zero.c
index 5f9c85a86d..7e9f322316 100644
--- a/src/provider/provider_level_zero.c
+++ b/src/provider/provider_level_zero.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -14,99 +14,59 @@
 #include <umf/memory_provider_ops.h>
 #include <umf/providers/provider_level_zero.h>
 
+#include "memory_provider_internal.h"
+#include "provider_ctl_stats_type.h"
+#include "provider_level_zero_internal.h"
+#include "provider_tracking.h"
+#include "utils_load_library.h"
 #include "utils_log.h"
 
-#if defined(UMF_NO_LEVEL_ZERO_PROVIDER)
-
-umf_result_t umfLevelZeroMemoryProviderParamsCreate(
-    umf_level_zero_memory_provider_params_handle_t *hParams) {
-    (void)hParams;
-    LOG_ERR("L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is "
-            "OFF)");
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-umf_result_t umfLevelZeroMemoryProviderParamsDestroy(
-    umf_level_zero_memory_provider_params_handle_t hParams) {
-    (void)hParams;
-    LOG_ERR("L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is "
-            "OFF)");
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-umf_result_t umfLevelZeroMemoryProviderParamsSetContext(
-    umf_level_zero_memory_provider_params_handle_t hParams,
-    ze_context_handle_t hContext) {
-    (void)hParams;
-    (void)hContext;
-    LOG_ERR("L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is "
-            "OFF)");
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-umf_result_t umfLevelZeroMemoryProviderParamsSetDevice(
-    umf_level_zero_memory_provider_params_handle_t hParams,
-    ze_device_handle_t hDevice) {
-    (void)hParams;
-    (void)hDevice;
-    LOG_ERR("L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is "
-            "OFF)");
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-umf_result_t umfLevelZeroMemoryProviderParamsSetMemoryType(
-    umf_level_zero_memory_provider_params_handle_t hParams,
-    umf_usm_memory_type_t memoryType) {
-    (void)hParams;
-    (void)memoryType;
-    LOG_ERR("L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is "
-            "OFF)");
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-umf_result_t umfLevelZeroMemoryProviderParamsSetResidentDevices(
-    umf_level_zero_memory_provider_params_handle_t hParams,
-    ze_device_handle_t *hDevices, uint32_t deviceCount) {
-    (void)hParams;
-    (void)hDevices;
-    (void)deviceCount;
-    LOG_ERR("L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is "
-            "OFF)");
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
+static void *ze_lib_handle = NULL;
 
-umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void) {
-    // not supported
-    LOG_ERR("L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is "
-            "OFF)");
-    return NULL;
+void fini_ze_global_state(void) {
+    if (ze_lib_handle) {
+        utils_close_library(ze_lib_handle);
+        ze_lib_handle = NULL;
+    }
 }
 
-#else // !defined(UMF_NO_LEVEL_ZERO_PROVIDER)
+#if UMF_BUILD_LEVEL_ZERO_PROVIDER
 
 #include "base_alloc_global.h"
 #include "libumf.h"
+#include "provider_level_zero_internal.h"
 #include "utils_assert.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
-#include "utils_load_library.h"
 #include "utils_log.h"
 #include "utils_sanitizers.h"
 #include "ze_api.h"
 
 // Level Zero Memory Provider settings struct
 typedef struct umf_level_zero_memory_provider_params_t {
-    ze_context_handle_t
-        level_zero_context_handle; ///< Handle to the Level Zero context
-    ze_device_handle_t
-        level_zero_device_handle; ///< Handle to the Level Zero device
+    // Handle to the Level Zero context
+    ze_context_handle_t level_zero_context_handle;
 
-    umf_usm_memory_type_t memory_type; ///< Allocation memory type
+    // Handle to the Level Zero device
+    ze_device_handle_t level_zero_device_handle;
 
-    ze_device_handle_t *
-        resident_device_handles; ///< Array of devices for which the memory should be made resident
-    uint32_t
-        resident_device_count; ///< Number of devices for which the memory should be made resident
+    // Allocation memory type
+    umf_usm_memory_type_t memory_type;
+
+    // Array of devices for which the memory should be made resident
+    ze_device_handle_t *resident_device_handles;
+
+    // Number of devices for which the memory should be made resident
+    uint32_t resident_device_count;
+
+    // Memory free policy
+    umf_level_zero_memory_provider_free_policy_t freePolicy;
+
+    // Memory exchange policy 0 = IPC (default), 1 = import/export
+    int use_import_export_for_IPC;
+
+    uint32_t device_ordinal;
+    char name[64];
 } umf_level_zero_memory_provider_params_t;
 
 typedef struct ze_memory_provider_t {
@@ -114,23 +74,37 @@ typedef struct ze_memory_provider_t {
     ze_device_handle_t device;
     ze_memory_type_t memory_type;
 
+    utils_rwlock_t resident_device_rwlock;
     ze_device_handle_t *resident_device_handles;
     uint32_t resident_device_count;
+    uint32_t resident_device_capacity;
 
     ze_device_properties_t device_properties;
+
+    ze_driver_memory_free_policy_ext_flags_t freePolicyFlags;
+
+    // Memory exchange policy 0 = IPC (default), 1 = import/export
+    int use_import_export_for_IPC;
+
+    size_t min_page_size;
+
+    uint32_t device_ordinal;
+    char name[64];
+
+    ctl_stats_t stats;
 } ze_memory_provider_t;
 
 typedef struct ze_ops_t {
     ze_result_t (*zeMemAllocHost)(ze_context_handle_t,
                                   const ze_host_mem_alloc_desc_t *, size_t,
-                                  size_t, void *);
+                                  size_t, void **);
     ze_result_t (*zeMemAllocDevice)(ze_context_handle_t,
                                     const ze_device_mem_alloc_desc_t *, size_t,
-                                    size_t, ze_device_handle_t, void *);
+                                    size_t, ze_device_handle_t, void **);
     ze_result_t (*zeMemAllocShared)(ze_context_handle_t,
                                     const ze_device_mem_alloc_desc_t *,
                                     const ze_host_mem_alloc_desc_t *, size_t,
-                                    size_t, ze_device_handle_t, void *);
+                                    size_t, ze_device_handle_t, void **);
     ze_result_t (*zeMemFree)(ze_context_handle_t, void *);
     ze_result_t (*zeMemGetIpcHandle)(ze_context_handle_t, const void *,
                                      ze_ipc_mem_handle_t *);
@@ -142,19 +116,86 @@ typedef struct ze_ops_t {
     ze_result_t (*zeContextMakeMemoryResident)(ze_context_handle_t,
                                                ze_device_handle_t, void *,
                                                size_t);
+    ze_result_t (*zeContextEvictMemory)(ze_context_handle_t, ze_device_handle_t,
+                                        void *, size_t);
     ze_result_t (*zeDeviceGetProperties)(ze_device_handle_t,
                                          ze_device_properties_t *);
+    ze_result_t (*zeMemFreeExt)(ze_context_handle_t,
+                                ze_memory_free_ext_desc_t *, void *);
+    ze_result_t (*zeMemGetAllocProperties)(ze_context_handle_t, const void *,
+                                           ze_memory_allocation_properties_t *,
+                                           ze_device_handle_t *);
 } ze_ops_t;
 
 static ze_ops_t g_ze_ops;
 static UTIL_ONCE_FLAG ze_is_initialized = UTIL_ONCE_FLAG_INIT;
 static bool Init_ze_global_state_failed;
 static __TLS ze_result_t TLS_last_native_error;
+static const char *DEFAULT_NAME = "LEVEL_ZERO";
 
 static void store_last_native_error(int32_t native_error) {
     TLS_last_native_error = native_error;
 }
 
+#define CTL_PROVIDER_TYPE ze_memory_provider_t
+#include "provider_ctl_stats_impl.h"
+
+struct ctl ze_memory_ctl_root;
+static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT;
+
+static ze_relaxed_allocation_limits_exp_desc_t relaxed_device_allocation_desc =
+    {.stype = ZE_STRUCTURE_TYPE_RELAXED_ALLOCATION_LIMITS_EXP_DESC,
+     .pNext = NULL,
+     .flags = ZE_RELAXED_ALLOCATION_LIMITS_EXP_FLAG_MAX_SIZE};
+
+static ze_external_memory_export_desc_t memory_export_desc = {
+    .stype = ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_EXPORT_DESC,
+    .pNext = NULL,
+    .flags = ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_WIN32};
+
+static umf_result_t CTL_READ_HANDLER(use_import_export_for_IPC)(
+    void *ctx, umf_ctl_query_source_t source, void *arg, size_t size,
+    umf_ctl_index_utlist_t *indexes) {
+    (void)source, (void)indexes;
+
+    if (arg == NULL || size != sizeof(int)) {
+        LOG_ERR("arg is NULL or size is not valid");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    int *arg_out = arg;
+    ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)ctx;
+    *arg_out = ze_provider->use_import_export_for_IPC;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t CTL_WRITE_HANDLER(use_import_export_for_IPC)(
+    void *ctx, umf_ctl_query_source_t source, void *arg, size_t size,
+    umf_ctl_index_utlist_t *indexes) {
+    (void)source, (void)indexes;
+
+    if (arg == NULL || size != sizeof(int)) {
+        LOG_ERR("arg is NULL or size is not valid");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    int arg_in = *(int *)arg;
+    ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)ctx;
+    ze_provider->use_import_export_for_IPC = arg_in;
+    return UMF_RESULT_SUCCESS;
+}
+
+static const struct ctl_argument
+    CTL_ARG(use_import_export_for_IPC) = CTL_ARG_INT;
+
+static const umf_ctl_node_t CTL_NODE(params)[] = {
+    CTL_LEAF_RW(use_import_export_for_IPC), CTL_NODE_END};
+
+static void initialize_ze_ctl(void) {
+    CTL_REGISTER_MODULE(&ze_memory_ctl_root, params);
+    CTL_REGISTER_MODULE(&ze_memory_ctl_root, stats);
+}
+
 static umf_result_t ze2umf_result(ze_result_t result) {
     switch (result) {
     case ZE_RESULT_SUCCESS:
@@ -169,53 +210,105 @@ static umf_result_t ze2umf_result(ze_result_t result) {
     }
 }
 
+static umf_usm_memory_type_t ze2umf_memory_type(ze_memory_type_t memory_type) {
+    switch (memory_type) {
+    case ZE_MEMORY_TYPE_HOST:
+        return UMF_MEMORY_TYPE_HOST;
+    case ZE_MEMORY_TYPE_DEVICE:
+        return UMF_MEMORY_TYPE_DEVICE;
+    case ZE_MEMORY_TYPE_SHARED:
+        return UMF_MEMORY_TYPE_SHARED;
+    default:
+        return UMF_MEMORY_TYPE_UNKNOWN;
+    }
+}
+
+static ze_memory_type_t umf2ze_memory_type(umf_usm_memory_type_t memory_type) {
+    switch (memory_type) {
+    case UMF_MEMORY_TYPE_HOST:
+        return ZE_MEMORY_TYPE_HOST;
+    case UMF_MEMORY_TYPE_DEVICE:
+        return ZE_MEMORY_TYPE_DEVICE;
+    case UMF_MEMORY_TYPE_SHARED:
+        return ZE_MEMORY_TYPE_SHARED;
+    default:
+        return ZE_MEMORY_TYPE_UNKNOWN;
+    }
+}
+
 static void init_ze_global_state(void) {
+
+    const char *lib_name = getenv("UMF_ZE_LOADER_LIB_NAME");
+    if (lib_name != NULL && lib_name[0] != '\0') {
+        LOG_INFO("Using custom ze_loader library name: %s", lib_name);
+    } else {
 #ifdef _WIN32
-    const char *lib_name = "ze_loader.dll";
+        lib_name = "ze_loader.dll";
 #else
-    const char *lib_name = "libze_loader.so";
+        lib_name = "libze_loader.so.1";
 #endif
-    // check if Level Zero shared library is already loaded
-    // we pass 0 as a handle to search the global symbol table
+        LOG_DEBUG("Using default ze_loader library name: %s", lib_name);
+    }
+    // The Level Zero shared library should be already loaded by the user
+    // of the Level Zero provider. UMF just want to reuse it
+    // and increase the reference count to the Level Zero shared library.
+    void *lib_handle =
+        utils_open_library(lib_name, UMF_UTIL_OPEN_LIBRARY_NO_LOAD);
+    if (!lib_handle) {
+        LOG_FATAL("Failed to open Level Zero shared library");
+        Init_ze_global_state_failed = true;
+        return;
+    }
+
     *(void **)&g_ze_ops.zeMemAllocHost =
-        utils_get_symbol_addr(0, "zeMemAllocHost", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemAllocHost", lib_name);
     *(void **)&g_ze_ops.zeMemAllocDevice =
-        utils_get_symbol_addr(0, "zeMemAllocDevice", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemAllocDevice", lib_name);
     *(void **)&g_ze_ops.zeMemAllocShared =
-        utils_get_symbol_addr(0, "zeMemAllocShared", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemAllocShared", lib_name);
     *(void **)&g_ze_ops.zeMemFree =
-        utils_get_symbol_addr(0, "zeMemFree", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemFree", lib_name);
     *(void **)&g_ze_ops.zeMemGetIpcHandle =
-        utils_get_symbol_addr(0, "zeMemGetIpcHandle", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemGetIpcHandle", lib_name);
     *(void **)&g_ze_ops.zeMemPutIpcHandle =
-        utils_get_symbol_addr(0, "zeMemPutIpcHandle", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemPutIpcHandle", lib_name);
     *(void **)&g_ze_ops.zeMemOpenIpcHandle =
-        utils_get_symbol_addr(0, "zeMemOpenIpcHandle", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemOpenIpcHandle", lib_name);
     *(void **)&g_ze_ops.zeMemCloseIpcHandle =
-        utils_get_symbol_addr(0, "zeMemCloseIpcHandle", lib_name);
-    *(void **)&g_ze_ops.zeContextMakeMemoryResident =
-        utils_get_symbol_addr(0, "zeContextMakeMemoryResident", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemCloseIpcHandle", lib_name);
+    *(void **)&g_ze_ops.zeContextMakeMemoryResident = utils_get_symbol_addr(
+        lib_handle, "zeContextMakeMemoryResident", lib_name);
+    *(void **)&g_ze_ops.zeContextEvictMemory =
+        utils_get_symbol_addr(lib_handle, "zeContextEvictMemory", lib_name);
     *(void **)&g_ze_ops.zeDeviceGetProperties =
-        utils_get_symbol_addr(0, "zeDeviceGetProperties", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeDeviceGetProperties", lib_name);
+    *(void **)&g_ze_ops.zeMemFreeExt =
+        utils_get_symbol_addr(lib_handle, "zeMemFreeExt", lib_name);
+    *(void **)&g_ze_ops.zeMemGetAllocProperties =
+        utils_get_symbol_addr(lib_handle, "zeMemGetAllocProperties", lib_name);
 
     if (!g_ze_ops.zeMemAllocHost || !g_ze_ops.zeMemAllocDevice ||
         !g_ze_ops.zeMemAllocShared || !g_ze_ops.zeMemFree ||
         !g_ze_ops.zeMemGetIpcHandle || !g_ze_ops.zeMemOpenIpcHandle ||
         !g_ze_ops.zeMemCloseIpcHandle ||
         !g_ze_ops.zeContextMakeMemoryResident ||
-        !g_ze_ops.zeDeviceGetProperties) {
+        !g_ze_ops.zeContextEvictMemory || !g_ze_ops.zeDeviceGetProperties ||
+        !g_ze_ops.zeMemGetAllocProperties) {
         // g_ze_ops.zeMemPutIpcHandle can be NULL because it was introduced
         // starting from Level Zero 1.6
-        LOG_ERR("Required Level Zero symbols not found.");
+        LOG_FATAL("Required Level Zero symbols not found.");
         Init_ze_global_state_failed = true;
+        utils_close_library(lib_handle);
+        return;
     }
+    ze_lib_handle = lib_handle;
 }
 
 umf_result_t umfLevelZeroMemoryProviderParamsCreate(
     umf_level_zero_memory_provider_params_handle_t *hParams) {
     libumfInit();
     if (!hParams) {
-        LOG_ERR("Level zero memory provider params handle is NULL");
+        LOG_ERR("Level Zero memory provider params handle is NULL");
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
@@ -232,6 +325,11 @@ umf_result_t umfLevelZeroMemoryProviderParamsCreate(
     params->memory_type = UMF_MEMORY_TYPE_UNKNOWN;
     params->resident_device_handles = NULL;
     params->resident_device_count = 0;
+    params->freePolicy = UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFAULT;
+    params->use_import_export_for_IPC = 0; // disabled by default - use IPC
+    params->device_ordinal = 0;
+    strncpy(params->name, DEFAULT_NAME, sizeof(params->name) - 1);
+    params->name[sizeof(params->name) - 1] = '\0';
 
     *hParams = params;
 
@@ -249,12 +347,12 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetContext(
     umf_level_zero_memory_provider_params_handle_t hParams,
     ze_context_handle_t hContext) {
     if (!hParams) {
-        LOG_ERR("Level zero memory provider params handle is NULL");
+        LOG_ERR("Level Zero memory provider params handle is NULL");
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
     if (!hContext) {
-        LOG_ERR("Level zero context handle is NULL");
+        LOG_ERR("Level Zero context handle is NULL");
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
@@ -267,7 +365,7 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetDevice(
     umf_level_zero_memory_provider_params_handle_t hParams,
     ze_device_handle_t hDevice) {
     if (!hParams) {
-        LOG_ERR("Level zero memory provider params handle is NULL");
+        LOG_ERR("Level Zero memory provider params handle is NULL");
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
@@ -280,7 +378,7 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetMemoryType(
     umf_level_zero_memory_provider_params_handle_t hParams,
     umf_usm_memory_type_t memoryType) {
     if (!hParams) {
-        LOG_ERR("Level zero memory provider params handle is NULL");
+        LOG_ERR("Level Zero memory provider params handle is NULL");
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
@@ -289,115 +387,90 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetMemoryType(
     return UMF_RESULT_SUCCESS;
 }
 
-umf_result_t umfLevelZeroMemoryProviderParamsSetResidentDevices(
+umf_result_t umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(
     umf_level_zero_memory_provider_params_handle_t hParams,
-    ze_device_handle_t *hDevices, uint32_t deviceCount) {
+    uint32_t deviceOrdinal) {
     if (!hParams) {
-        LOG_ERR("Level zero memory provider params handle is NULL");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    if (deviceCount && !hDevices) {
-        LOG_ERR("Resident devices array is NULL, but deviceCount is not zero");
+        LOG_ERR("Level Zero memory provider params handle is NULL");
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
-
-    hParams->resident_device_handles = hDevices;
-    hParams->resident_device_count = deviceCount;
+    hParams->device_ordinal = deviceOrdinal;
 
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t ze_memory_provider_initialize(void *params,
-                                                  void **provider) {
-    if (params == NULL) {
+umf_result_t umfLevelZeroMemoryProviderParamsSetName(
+    umf_level_zero_memory_provider_params_handle_t hParams, const char *name) {
+    if (!hParams) {
+        LOG_ERR("Level Zero memory provider params handle is NULL");
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    umf_level_zero_memory_provider_params_handle_t ze_params =
-        (umf_level_zero_memory_provider_params_handle_t)params;
-
-    if (!ze_params->level_zero_context_handle) {
-        LOG_ERR("Level Zero context handle is NULL");
+    if (!name) {
+        LOG_ERR("name is NULL");
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    if ((ze_params->memory_type == UMF_MEMORY_TYPE_HOST) ==
-        (ze_params->level_zero_device_handle != NULL)) {
-        LOG_ERR("Level Zero device handle is NULL");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    strncpy(hParams->name, name, sizeof(hParams->name) - 1);
+    hParams->name[sizeof(hParams->name) - 1] = '\0';
 
-    if ((bool)ze_params->resident_device_count &&
-        (ze_params->resident_device_handles == NULL)) {
-        LOG_ERR("Resident devices handles array is NULL, but device_count is "
-                "not zero");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    return UMF_RESULT_SUCCESS;
+}
 
-    utils_init_once(&ze_is_initialized, init_ze_global_state);
-    if (Init_ze_global_state_failed) {
-        LOG_ERR("Loading Level Zero symbols failed");
-        return UMF_RESULT_ERROR_UNKNOWN;
+umf_result_t umfLevelZeroMemoryProviderParamsSetResidentDevices(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    ze_device_handle_t *hDevices, uint32_t deviceCount) {
+    if (!hParams) {
+        LOG_ERR("Level Zero memory provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
-
-    ze_memory_provider_t *ze_provider =
-        umf_ba_global_alloc(sizeof(ze_memory_provider_t));
-    if (!ze_provider) {
-        LOG_ERR("Cannot allocate memory for Level Zero Memory Provider");
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    if (deviceCount > 0 && hDevices == NULL) {
+        LOG_ERR("Resident devices array is NULL, but deviceCount is not zero");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    ze_provider->context = ze_params->level_zero_context_handle;
-    ze_provider->device = ze_params->level_zero_device_handle;
-    ze_provider->memory_type = (ze_memory_type_t)ze_params->memory_type;
-
-    if (ze_provider->device) {
-        umf_result_t ret = ze2umf_result(g_ze_ops.zeDeviceGetProperties(
-            ze_provider->device, &ze_provider->device_properties));
-
-        if (ret != UMF_RESULT_SUCCESS) {
-            LOG_ERR("Cannot get device properties");
-            umf_ba_global_free(ze_provider);
-            return ret;
+    for (uint32_t first_idx = 0; first_idx < deviceCount; first_idx++) {
+        for (uint32_t second_idx = 0; second_idx < first_idx; second_idx++) {
+            if (hDevices[first_idx] == hDevices[second_idx]) {
+                LOG_ERR("resident devices are not unique, idx: %u and "
+                        "idx: %u both point to device: %p",
+                        first_idx, second_idx, (void *)hDevices[first_idx]);
+                return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+            }
         }
-    } else {
-        memset(&ze_provider->device_properties, 0,
-               sizeof(ze_provider->device_properties));
     }
 
-    if (ze_params->resident_device_count) {
-        ze_provider->resident_device_handles = umf_ba_global_alloc(
-            sizeof(ze_device_handle_t) * ze_params->resident_device_count);
-        if (!ze_provider->resident_device_handles) {
-            LOG_ERR("Cannot allocate memory for resident devices");
-            umf_ba_global_free(ze_provider);
-            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-        }
+    hParams->resident_device_handles = hDevices;
+    hParams->resident_device_count = deviceCount;
 
-        ze_provider->resident_device_count = ze_params->resident_device_count;
+    return UMF_RESULT_SUCCESS;
+}
 
-        for (uint32_t i = 0; i < ze_provider->resident_device_count; i++) {
-            ze_provider->resident_device_handles[i] =
-                ze_params->resident_device_handles[i];
-        }
-    } else {
-        ze_provider->resident_device_handles = NULL;
-        ze_provider->resident_device_count = 0;
+umf_result_t umfLevelZeroMemoryProviderParamsSetFreePolicy(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    umf_level_zero_memory_provider_free_policy_t policy) {
+    if (!hParams) {
+        LOG_ERR("Level Zero memory provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    *provider = ze_provider;
-
+    hParams->freePolicy = policy;
     return UMF_RESULT_SUCCESS;
 }
 
-static void ze_memory_provider_finalize(void *provider) {
-    ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)provider;
-    umf_ba_global_free(ze_provider->resident_device_handles);
-
-    umf_ba_global_free(provider);
+static ze_driver_memory_free_policy_ext_flags_t
+umfFreePolicyToZePolicy(umf_level_zero_memory_provider_free_policy_t policy) {
+    switch (policy) {
+    case UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFAULT:
+        return 0;
+    case UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_BLOCKING_FREE:
+        return ZE_DRIVER_MEMORY_FREE_POLICY_EXT_FLAG_BLOCKING_FREE;
+    case UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFER_FREE:
+        return ZE_DRIVER_MEMORY_FREE_POLICY_EXT_FLAG_DEFER_FREE;
+    default:
+        return 0;
+    }
 }
-
 static bool use_relaxed_allocation(ze_memory_provider_t *ze_provider,
                                    size_t size) {
     assert(ze_provider);
@@ -407,18 +480,51 @@ static bool use_relaxed_allocation(ze_memory_provider_t *ze_provider,
     return size > ze_provider->device_properties.maxMemAllocSize;
 }
 
-static ze_relaxed_allocation_limits_exp_desc_t relaxed_device_allocation_desc =
-    {.stype = ZE_STRUCTURE_TYPE_RELAXED_ALLOCATION_LIMITS_EXP_DESC,
-     .pNext = NULL,
-     .flags = ZE_RELAXED_ALLOCATION_LIMITS_EXP_FLAG_MAX_SIZE};
+static umf_result_t ze_memory_provider_free_helper(void *provider, void *ptr,
+                                                   size_t bytes,
+                                                   int update_stats) {
+    if (ptr == NULL) {
+        return UMF_RESULT_SUCCESS;
+    }
 
-static umf_result_t ze_memory_provider_alloc(void *provider, size_t size,
-                                             size_t alignment,
-                                             void **resultPtr) {
-    ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)provider;
+    ze_memory_provider_t *ze_provider = provider;
+    umf_result_t ret;
+    if (ze_provider->freePolicyFlags == 0) {
+        ret = ze2umf_result(g_ze_ops.zeMemFree(ze_provider->context, ptr));
+    } else {
+        ze_memory_free_ext_desc_t desc = {
+            .stype = ZE_STRUCTURE_TYPE_MEMORY_FREE_EXT_DESC,
+            .pNext = NULL,
+            .freePolicy = ze_provider->freePolicyFlags};
+
+        ret = ze2umf_result(
+            g_ze_ops.zeMemFreeExt(ze_provider->context, &desc, ptr));
+    }
+
+    if (ret != UMF_RESULT_SUCCESS) {
+        return ret;
+    }
+
+    if (update_stats) {
+        provider_ctl_stats_free(ze_provider, bytes);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t ze_memory_provider_free(void *provider, void *ptr,
+                                            size_t bytes) {
+    return ze_memory_provider_free_helper(provider, ptr, bytes, 1);
+}
+
+static umf_result_t ze_memory_provider_alloc_helper(void *provider, size_t size,
+                                                    size_t alignment,
+                                                    int update_stats,
+                                                    void **resultPtr) {
+    ze_memory_provider_t *ze_provider = provider;
 
     ze_result_t ze_result = ZE_RESULT_SUCCESS;
-    switch (ze_provider->memory_type) {
+    switch (ze2umf_memory_type(ze_provider->memory_type)) {
     case UMF_MEMORY_TYPE_HOST: {
         ze_host_mem_alloc_desc_t host_desc = {
             .stype = ZE_STRUCTURE_TYPE_HOST_MEM_ALLOC_DESC,
@@ -431,12 +537,29 @@ static umf_result_t ze_memory_provider_alloc(void *provider, size_t size,
     case UMF_MEMORY_TYPE_DEVICE: {
         ze_device_mem_alloc_desc_t dev_desc = {
             .stype = ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC,
-            .pNext = use_relaxed_allocation(ze_provider, size)
-                         ? &relaxed_device_allocation_desc
-                         : NULL,
+            .pNext = NULL,
             .flags = 0,
-            .ordinal = 0 // TODO
-        };
+            .ordinal = ze_provider->device_ordinal};
+        void *lastNext = &dev_desc.pNext;
+
+        ze_relaxed_allocation_limits_exp_desc_t
+            relaxed_device_allocation_desc_copy =
+                relaxed_device_allocation_desc;
+        if (use_relaxed_allocation(ze_provider, size)) {
+            // add relaxed allocation desc to the pNext chain
+            *(void **)lastNext = &relaxed_device_allocation_desc_copy;
+            lastNext = &relaxed_device_allocation_desc_copy.pNext;
+        }
+
+        // check if the allocation should use import / export mechanism
+        ze_external_memory_export_desc_t memory_export_desc_copy =
+            memory_export_desc;
+        if (ze_provider->use_import_export_for_IPC == 1) {
+            // add external memory export desc to the pNext chain
+            *(void **)lastNext = &memory_export_desc_copy;
+            lastNext = &memory_export_desc_copy.pNext;
+        }
+
         ze_result = g_ze_ops.zeMemAllocDevice(ze_provider->context, &dev_desc,
                                               size, alignment,
                                               ze_provider->device, resultPtr);
@@ -453,8 +576,7 @@ static umf_result_t ze_memory_provider_alloc(void *provider, size_t size,
                          ? &relaxed_device_allocation_desc
                          : NULL,
             .flags = 0,
-            .ordinal = 0 // TODO
-        };
+            .ordinal = ze_provider->device_ordinal};
         ze_result = g_ze_ops.zeMemAllocShared(ze_provider->context, &dev_desc,
                                               &host_desc, size, alignment,
                                               ze_provider->device, resultPtr);
@@ -468,61 +590,236 @@ static umf_result_t ze_memory_provider_alloc(void *provider, size_t size,
     }
 
     if (ze_result != ZE_RESULT_SUCCESS) {
+        LOG_ERR(
+            "failed to allocate memory, type: %d, size: %lu, alignment: %lu, "
+            "result: %d",
+            ze_provider->memory_type, size, alignment, ze_result);
         return ze2umf_result(ze_result);
     }
 
+    utils_read_lock(&ze_provider->resident_device_rwlock);
     for (uint32_t i = 0; i < ze_provider->resident_device_count; i++) {
         ze_result = g_ze_ops.zeContextMakeMemoryResident(
             ze_provider->context, ze_provider->resident_device_handles[i],
             *resultPtr, size);
         if (ze_result != ZE_RESULT_SUCCESS) {
+            utils_read_unlock(&ze_provider->resident_device_rwlock);
+            LOG_ERR("making resident allocation %p of size: %lu on device %p "
+                    "failed with 0x%x",
+                    *resultPtr, size,
+                    (void *)ze_provider->resident_device_handles[i], ze_result);
+            umf_result_t free_result =
+                ze_memory_provider_free(ze_provider, *resultPtr, size);
+            if (free_result != UMF_RESULT_SUCCESS) {
+                LOG_ERR("failed to free memory with: 0x%x after failed making "
+                        "resident, free fail ignored",
+                        free_result);
+            }
             return ze2umf_result(ze_result);
         }
+        LOG_DEBUG("allocation %p of size: %lu made resident on device %p",
+                  *resultPtr, size,
+                  (void *)ze_provider->resident_device_handles[i]);
     }
+    utils_read_unlock(&ze_provider->resident_device_rwlock);
 
-    return ze2umf_result(ze_result);
+    if (update_stats) {
+        provider_ctl_stats_alloc(ze_provider, size);
+    }
+    return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t ze_memory_provider_free(void *provider, void *ptr,
-                                            size_t bytes) {
-    (void)bytes;
+static umf_result_t ze_memory_provider_alloc(void *provider, size_t size,
+                                             size_t alignment,
+                                             void **resultPtr) {
+    return ze_memory_provider_alloc_helper(provider, size, alignment, 1,
+                                           resultPtr);
+}
 
-    if (ptr == NULL) {
-        return UMF_RESULT_SUCCESS;
+static umf_result_t query_min_page_size(ze_memory_provider_t *ze_provider,
+                                        size_t *min_page_size) {
+    assert(min_page_size);
+
+    void *ptr;
+    umf_result_t result =
+        ze_memory_provider_alloc_helper(ze_provider, 1, 0, 0, &ptr);
+    if (result != UMF_RESULT_SUCCESS) {
+        return result;
     }
 
-    ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)provider;
-    ze_result_t ze_result = g_ze_ops.zeMemFree(ze_provider->context, ptr);
-    return ze2umf_result(ze_result);
-}
+    ze_memory_allocation_properties_t properties = {
+        .stype = ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES};
+    ze_result_t ze_result = g_ze_ops.zeMemGetAllocProperties(
+        ze_provider->context, ptr, &properties, NULL);
 
-static void ze_memory_provider_get_last_native_error(void *provider,
-                                                     const char **ppMessage,
-                                                     int32_t *pError) {
-    (void)provider;
+    *min_page_size = properties.pageSize;
+    LOG_DEBUG("Querying minimum page size, got: %lu", properties.pageSize);
 
-    if (ppMessage == NULL || pError == NULL) {
-        ASSERT(0);
-        return;
-    }
+    ze_memory_provider_free_helper(ze_provider, ptr, 1, 0);
 
-    *pError = TLS_last_native_error;
+    return ze2umf_result(ze_result);
 }
 
-static umf_result_t ze_memory_provider_get_min_page_size(void *provider,
-                                                         void *ptr,
-                                                         size_t *pageSize) {
-    (void)provider;
-    (void)ptr;
-
-    // TODO
-    *pageSize = 1024 * 64;
+static umf_result_t ze_memory_provider_finalize(void *provider) {
+    ze_memory_provider_t *ze_provider = provider;
+    if (ze_provider->resident_device_handles != NULL) {
+        umf_ba_global_free(ze_provider->resident_device_handles);
+    }
+    utils_rwlock_destroy_not_free(&ze_provider->resident_device_rwlock);
+    umf_ba_global_free(provider);
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t ze_memory_provider_purge_lazy(void *provider, void *ptr,
-                                                  size_t size) {
-    (void)provider;
+static umf_result_t ze_memory_provider_initialize(const void *params,
+                                                  void **provider) {
+    if (params == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    const umf_level_zero_memory_provider_params_t *ze_params = params;
+
+    if (!ze_params->level_zero_context_handle) {
+        LOG_ERR("Level Zero context handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if ((ze_params->memory_type == UMF_MEMORY_TYPE_HOST) ==
+        (ze_params->level_zero_device_handle != NULL)) {
+        LOG_ERR("Level Zero device handle should be set only for device and "
+                "shared memory types");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (ze_params->resident_device_count > 0 &&
+        ze_params->resident_device_handles == NULL) {
+        LOG_ERR("Device handler should be non-NULL if device_count: %d is "
+                "greater than 0",
+                ze_params->resident_device_count);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    utils_init_once(&ze_is_initialized, init_ze_global_state);
+    if (Init_ze_global_state_failed) {
+        LOG_FATAL("Loading Level Zero symbols failed");
+        return UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
+    }
+
+    ze_memory_provider_t *ze_provider =
+        umf_ba_global_alloc(sizeof(ze_memory_provider_t));
+    if (!ze_provider) {
+        LOG_ERR("Cannot allocate memory for Level Zero Memory Provider");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+    memset(ze_provider, 0, sizeof(*ze_provider));
+    snprintf(ze_provider->name, sizeof(ze_provider->name), "%s",
+             ze_params->name);
+
+    ze_provider->context = ze_params->level_zero_context_handle;
+    ze_provider->device = ze_params->level_zero_device_handle;
+    ze_provider->memory_type = umf2ze_memory_type(ze_params->memory_type);
+    ze_provider->freePolicyFlags =
+        umfFreePolicyToZePolicy(ze_params->freePolicy);
+    ze_provider->use_import_export_for_IPC =
+        ze_params->use_import_export_for_IPC;
+    ze_provider->min_page_size = 0;
+    ze_provider->device_ordinal = ze_params->device_ordinal;
+
+    memset(&ze_provider->device_properties, 0,
+           sizeof(ze_provider->device_properties));
+    ze_provider->device_properties.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;
+
+    if (ze_provider->device) {
+        umf_result_t ret = ze2umf_result(g_ze_ops.zeDeviceGetProperties(
+            ze_provider->device, &ze_provider->device_properties));
+
+        if (ret != UMF_RESULT_SUCCESS) {
+            LOG_ERR("Cannot get device properties");
+            umf_ba_global_free(ze_provider);
+            return ret;
+        }
+    }
+
+    if (utils_rwlock_init(&ze_provider->resident_device_rwlock) != 0) {
+        LOG_ERR("Cannot initialize resident device rwlock");
+        umf_ba_global_free(ze_provider);
+        return UMF_RESULT_ERROR_OUT_OF_RESOURCES;
+    }
+
+    ze_provider->resident_device_count = ze_params->resident_device_count;
+    ze_provider->resident_device_capacity = ze_params->resident_device_count;
+
+    if (ze_params->resident_device_count > 0) {
+        ze_provider->resident_device_handles = umf_ba_global_alloc(
+            sizeof(ze_device_handle_t) * ze_params->resident_device_count);
+        if (ze_provider->resident_device_handles == NULL) {
+            LOG_ERR("Cannot allocate memory for resident devices");
+            utils_rwlock_destroy_not_free(&ze_provider->resident_device_rwlock);
+            umf_ba_global_free(ze_provider);
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        }
+
+        memcpy(ze_provider->resident_device_handles,
+               ze_params->resident_device_handles,
+               sizeof(ze_device_handle_t) * ze_params->resident_device_count);
+
+        LOG_INFO("L0 memory provider: %p have %d resident device(s)",
+                 (void *)ze_provider, ze_params->resident_device_count);
+    } else {
+        LOG_INFO("L0 memory provider has no resident devices");
+    }
+
+    const umf_result_t result =
+        query_min_page_size(ze_provider, &ze_provider->min_page_size);
+    if (result != UMF_RESULT_SUCCESS) {
+        ze_memory_provider_finalize(ze_provider);
+        return result;
+    }
+
+    *provider = ze_provider;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t
+ze_memory_provider_get_last_native_error(void *provider, const char **ppMessage,
+                                         int32_t *pError) {
+    (void)provider;
+
+    if (ppMessage == NULL || pError == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    *pError = TLS_last_native_error;
+
+    return UMF_RESULT_ERROR_NOT_SUPPORTED; // TODO: see #1385
+}
+
+static umf_result_t ze_memory_provider_get_min_page_size(void *provider,
+                                                         const void *ptr,
+                                                         size_t *pageSize) {
+    ze_memory_provider_t *ze_provider = provider;
+
+    if (!ptr) {
+        *pageSize = ze_provider->min_page_size;
+        return UMF_RESULT_SUCCESS;
+    }
+
+    ze_memory_allocation_properties_t properties = {
+        .stype = ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES};
+    ze_result_t ze_result = g_ze_ops.zeMemGetAllocProperties(
+        ze_provider->context, ptr, &properties, NULL);
+    if (ze_result != ZE_RESULT_SUCCESS) {
+        return ze2umf_result(ze_result);
+    }
+
+    *pageSize = properties.pageSize;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t ze_memory_provider_purge_lazy(void *provider, void *ptr,
+                                                  size_t size) {
+    (void)provider;
     (void)ptr;
     (void)size;
 
@@ -543,17 +840,22 @@ static umf_result_t ze_memory_provider_purge_force(void *provider, void *ptr,
 static umf_result_t
 ze_memory_provider_get_recommended_page_size(void *provider, size_t size,
                                              size_t *pageSize) {
-    (void)provider;
     (void)size;
-
-    // TODO
-    *pageSize = 1024 * 64;
-    return UMF_RESULT_SUCCESS;
+    return ze_memory_provider_get_min_page_size(provider, NULL, pageSize);
 }
 
-static const char *ze_memory_provider_get_name(void *provider) {
-    (void)provider;
-    return "LEVEL_ZERO";
+static umf_result_t ze_memory_provider_get_name(void *provider,
+                                                const char **name) {
+    if (!name) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    if (provider == NULL) {
+        *name = DEFAULT_NAME;
+        return UMF_RESULT_SUCCESS;
+    }
+    ze_memory_provider_t *ze_provider = provider;
+    *name = ze_provider->name;
+    return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t ze_memory_provider_allocation_merge(void *hProvider,
@@ -584,6 +886,7 @@ static umf_result_t ze_memory_provider_allocation_split(void *provider,
 
 typedef struct ze_ipc_data_t {
     int pid;
+    size_t size;
     ze_ipc_mem_handle_t ze_handle;
 } ze_ipc_data_t;
 
@@ -599,20 +902,46 @@ static umf_result_t ze_memory_provider_get_ipc_handle(void *provider,
                                                       const void *ptr,
                                                       size_t size,
                                                       void *providerIpcData) {
-    (void)size;
-
     ze_result_t ze_result;
     ze_ipc_data_t *ze_ipc_data = (ze_ipc_data_t *)providerIpcData;
     struct ze_memory_provider_t *ze_provider =
         (struct ze_memory_provider_t *)provider;
 
-    ze_result = g_ze_ops.zeMemGetIpcHandle(ze_provider->context, ptr,
-                                           &ze_ipc_data->ze_handle);
-    if (ze_result != ZE_RESULT_SUCCESS) {
-        LOG_ERR("zeMemGetIpcHandle() failed.");
-        return ze2umf_result(ze_result);
+    if (ze_provider->use_import_export_for_IPC == 0) {
+        // default - IPC API
+        ze_result = g_ze_ops.zeMemGetIpcHandle(ze_provider->context, ptr,
+                                               &ze_ipc_data->ze_handle);
+        if (ze_result != ZE_RESULT_SUCCESS) {
+            LOG_ERR("zeMemGetIpcHandle() failed.");
+            return ze2umf_result(ze_result);
+        }
+    } else {
+        // import / export API (NOTE this requires additional flags enabled
+        // during the memory allocation)
+        ze_external_memory_export_fd_t fd_desc = {
+            .stype = ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_EXPORT_FD,
+            .pNext = NULL,
+            .flags = ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_WIN32,
+            .fd = 0};
+
+        ze_memory_allocation_properties_t mem_alloc_props = {
+            .stype = ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES,
+            .pNext = &fd_desc,
+            .type = 0,
+            .id = 0,
+            .pageSize = 0};
+
+        ze_result = g_ze_ops.zeMemGetAllocProperties(ze_provider->context, ptr,
+                                                     &mem_alloc_props, NULL);
+        if (ze_result != ZE_RESULT_SUCCESS) {
+            LOG_ERR("zeMemGetAllocProperties() failed.");
+            return ze2umf_result(ze_result);
+        }
+
+        memcpy(&ze_ipc_data->ze_handle, &fd_desc.fd, sizeof(fd_desc.fd));
     }
 
+    ze_ipc_data->size = size;
     ze_ipc_data->pid = utils_getpid();
 
     return UMF_RESULT_SUCCESS;
@@ -663,14 +992,41 @@ static umf_result_t ze_memory_provider_open_ipc_handle(void *provider,
         memcpy(&ze_ipc_handle, &fd_local, sizeof(fd_local));
     }
 
-    ze_result = g_ze_ops.zeMemOpenIpcHandle(
-        ze_provider->context, ze_provider->device, ze_ipc_handle, 0, ptr);
-    if (fd_local != -1) {
-        (void)utils_close_fd(fd_local);
-    }
-    if (ze_result != ZE_RESULT_SUCCESS) {
-        LOG_ERR("zeMemOpenIpcHandle() failed.");
-        return ze2umf_result(ze_result);
+    if (ze_provider->use_import_export_for_IPC == 0) {
+        // default - IPC API
+        ze_result = g_ze_ops.zeMemOpenIpcHandle(
+            ze_provider->context, ze_provider->device, ze_ipc_handle, 0, ptr);
+        if (fd_local != -1) {
+            (void)utils_close_fd(fd_local);
+        }
+        if (ze_result != ZE_RESULT_SUCCESS) {
+            LOG_ERR("zeMemOpenIpcHandle() failed.");
+            return ze2umf_result(ze_result);
+        }
+    } else {
+        // import / export API
+        ze_external_memory_import_fd_t import_fd = {
+            .stype = ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMPORT_FD,
+            .pNext = NULL,
+            .flags = ZE_EXTERNAL_MEMORY_TYPE_FLAG_DMA_BUF,
+            .fd = fd_local};
+
+        ze_device_mem_alloc_desc_t alloc_desc = {
+            .stype = ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC,
+            .pNext = &import_fd,
+            .flags = 0,
+            .ordinal = 0};
+        ze_result = g_ze_ops.zeMemAllocDevice(ze_provider->context, &alloc_desc,
+                                              ze_ipc_data->size, 0,
+                                              ze_provider->device, ptr);
+        if (fd_local != -1) {
+            (void)utils_close_fd(fd_local);
+        }
+
+        if (ze_result != ZE_RESULT_SUCCESS) {
+            LOG_ERR("zeMemAllocDevice() failed.");
+            return ze2umf_result(ze_result);
+        }
     }
 
     return UMF_RESULT_SUCCESS;
@@ -693,29 +1049,360 @@ ze_memory_provider_close_ipc_handle(void *provider, void *ptr, size_t size) {
     return UMF_RESULT_SUCCESS;
 }
 
-static struct umf_memory_provider_ops_t UMF_LEVEL_ZERO_MEMORY_PROVIDER_OPS = {
-    .version = UMF_VERSION_CURRENT,
+static umf_result_t ze_ctl(void *hProvider,
+                           umf_ctl_query_source_t operationType,
+                           const char *name, void *arg, size_t size,
+                           umf_ctl_query_type_t query_type, va_list args) {
+    utils_init_once(&ctl_initialized, initialize_ze_ctl);
+    return ctl_query(&ze_memory_ctl_root, hProvider, operationType, name,
+                     query_type, arg, size, args);
+}
+
+static umf_result_t ze_memory_provider_get_allocation_properties(
+    void *provider, const void *ptr,
+    umf_memory_property_id_t memory_property_id, void *value) {
+
+    // unused
+    (void)ptr;
+
+    struct ze_memory_provider_t *ze_provider =
+        (struct ze_memory_provider_t *)provider;
+
+    switch (memory_property_id) {
+    case UMF_MEMORY_PROPERTY_POINTER_TYPE:
+        *(umf_usm_memory_type_t *)value =
+            ze2umf_memory_type(ze_provider->memory_type);
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_PROPERTY_CONTEXT:
+        *(ze_context_handle_t *)value = ze_provider->context;
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_PROPERTY_DEVICE:
+        *(ze_device_handle_t *)value = ze_provider->device;
+        return UMF_RESULT_SUCCESS;
+
+    default:
+        break;
+    }
+
+    return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+}
+
+static umf_result_t ze_memory_provider_get_allocation_properties_size(
+    void *provider, umf_memory_property_id_t memory_property_id, size_t *size) {
+
+    // unused
+    (void)provider;
+
+    switch (memory_property_id) {
+    case UMF_MEMORY_PROPERTY_POINTER_TYPE:
+        *size = sizeof(umf_usm_memory_type_t);
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_PROPERTY_CONTEXT:
+        *size = sizeof(ze_context_handle_t);
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_PROPERTY_DEVICE:
+        *size = sizeof(ze_device_handle_t);
+        return UMF_RESULT_SUCCESS;
+
+    default:
+        break;
+    }
+
+    return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+}
+
+struct ze_memory_provider_resident_device_change_data {
+    bool is_adding;
+    ze_device_handle_t peer_device;
+    ze_memory_provider_t *source_memory_provider;
+    uint32_t success_changes;
+    uint32_t failed_changes;
+};
+
+static int ze_memory_provider_resident_device_change_helper(uintptr_t key,
+                                                            void *value,
+                                                            void *privdata) {
+    struct ze_memory_provider_resident_device_change_data *change_data =
+        privdata;
+    tracker_alloc_info_t *info = value;
+    if (info->props.provider->provider_priv !=
+        (void *)change_data->source_memory_provider) {
+        LOG_DEBUG("ze_memory_provider_resident_device_change found not our "
+                  "pointer %p",
+                  (void *)key);
+        return 0;
+    }
+
+    assert(info->props.base == (void *)key);
+
+    ze_result_t result;
+    if (change_data->is_adding) {
+        result = g_ze_ops.zeContextMakeMemoryResident(
+            change_data->source_memory_provider->context,
+            change_data->peer_device, info->props.base, info->props.base_size);
+    } else {
+        result = g_ze_ops.zeContextEvictMemory(
+            change_data->source_memory_provider->context,
+            change_data->peer_device, info->props.base, info->props.base_size);
+    }
+
+    if (result != ZE_RESULT_SUCCESS) {
+        LOG_ERR(
+            "ze_memory_provider_resident_device_change found our pointer "
+            "%p but failed to make it resident on device: %p due to err: %d",
+            (void *)key, (void *)change_data->peer_device, result);
+        ++change_data->failed_changes;
+        store_last_native_error(result);
+        return 1;
+    }
+
+    LOG_DEBUG("ze_memory_provider_resident_device_change found our pointer %p "
+              "and made it resident on device: %p",
+              (void *)key, (void *)change_data->peer_device);
+    ++change_data->success_changes;
+    return 0;
+}
+
+umf_result_t umfLevelZeroMemoryProviderResidentDeviceChange(
+    umf_memory_provider_handle_t provider, ze_device_handle_t device,
+    bool is_adding) {
+    ze_memory_provider_t *ze_provider = umfMemoryProviderGetPriv(provider);
+
+    LOG_INFO("%s resident device %p, src_provider: %p, existing peers "
+             "count: %d",
+             (is_adding ? "adding" : "removing"), (void *)device,
+             (void *)provider, ze_provider->resident_device_count);
+
+    uint32_t existing_peer_index = 0;
+    utils_write_lock(&ze_provider->resident_device_rwlock);
+    for (; existing_peer_index < ze_provider->resident_device_count;
+         ++existing_peer_index) {
+        if (ze_provider->resident_device_handles[existing_peer_index] ==
+            device) {
+            break;
+        }
+    }
+
+    if (ze_provider->resident_device_count == 0 ||
+        existing_peer_index == ze_provider->resident_device_count) {
+        // not found
+        if (!is_adding) {
+            utils_write_unlock(&ze_provider->resident_device_rwlock);
+            LOG_ERR("trying to remove resident device %p but the device "
+                    "is currently not a peer of provider: %p",
+                    (void *)device, (void *)provider);
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+        // adding case
+        if (ze_provider->resident_device_count ==
+            ze_provider->resident_device_capacity) {
+            const uint32_t new_capacity =
+                ze_provider->resident_device_capacity + 1;
+            ze_device_handle_t *new_handles =
+                umf_ba_global_alloc(sizeof(ze_device_handle_t) * new_capacity);
+            if (new_handles == NULL) {
+                utils_write_unlock(&ze_provider->resident_device_rwlock);
+                LOG_ERR("enlarging resident devices array from %u to %u failed "
+                        "due to no memory",
+                        ze_provider->resident_device_capacity, new_capacity);
+                return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+            }
+            LOG_DEBUG("enlarging resident devices array from %u to %u",
+                      ze_provider->resident_device_capacity, new_capacity);
+            if (ze_provider->resident_device_count > 0) {
+                ASSERT(ze_provider->resident_device_handles != NULL);
+                memcpy(new_handles, ze_provider->resident_device_handles,
+                       sizeof(ze_device_handle_t) *
+                           ze_provider->resident_device_count);
+            }
+            umf_ba_global_free(ze_provider->resident_device_handles);
+            ze_provider->resident_device_handles = new_handles;
+            ze_provider->resident_device_capacity = new_capacity;
+        }
+        ze_provider->resident_device_handles[existing_peer_index] = device;
+        ++ze_provider->resident_device_count;
+
+    } else {
+        // found
+        if (is_adding) {
+            utils_write_unlock(&ze_provider->resident_device_rwlock);
+            LOG_ERR("trying to add resident device: %p but the device is "
+                    "already a peer of provider: %p",
+                    (void *)device, (void *)provider);
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+        // removing case, put last in place of removed one
+        --ze_provider->resident_device_count;
+        ze_provider->resident_device_handles[existing_peer_index] =
+            ze_provider
+                ->resident_device_handles[ze_provider->resident_device_count];
+    }
+    utils_write_unlock(&ze_provider->resident_device_rwlock);
+
+    struct ze_memory_provider_resident_device_change_data privData = {
+        .is_adding = is_adding,
+        .peer_device = device,
+        .source_memory_provider = ze_provider,
+        .success_changes = 0,
+        .failed_changes = 0,
+    };
+
+    // This is "hacky" and it will not work if someone uses pool without tracker
+    // or just use provider without pool. It can be solved by keeping track of
+    // allocations by the provider like in os_provider.
+    umf_result_t result = umfMemoryTrackerIterateAll(
+        &ze_memory_provider_resident_device_change_helper, &privData);
+    if (result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("umfMemoryTrackerIterateAll failed during resident device "
+                "change with result: %d numFailed: %d, numSuccess: %d",
+                result, privData.success_changes, privData.failed_changes);
+        return result;
+    }
+
+    if (privData.failed_changes > 0) {
+        LOG_ERR("umfMemoryTrackerIterateAll did not manage to do some change "
+                "numFailed: %d, numSuccess: %d",
+                privData.success_changes, privData.failed_changes);
+        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    }
+
+    LOG_INFO("ze_memory_provider_resident_device_change done, numSuccess: %d",
+             privData.success_changes);
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_memory_provider_ops_t UMF_LEVEL_ZERO_MEMORY_PROVIDER_OPS = {
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = ze_memory_provider_initialize,
     .finalize = ze_memory_provider_finalize,
     .alloc = ze_memory_provider_alloc,
+    .free = ze_memory_provider_free,
     .get_last_native_error = ze_memory_provider_get_last_native_error,
     .get_recommended_page_size = ze_memory_provider_get_recommended_page_size,
     .get_min_page_size = ze_memory_provider_get_min_page_size,
     .get_name = ze_memory_provider_get_name,
-    .ext.free = ze_memory_provider_free,
-    .ext.purge_lazy = ze_memory_provider_purge_lazy,
-    .ext.purge_force = ze_memory_provider_purge_force,
-    .ext.allocation_merge = ze_memory_provider_allocation_merge,
-    .ext.allocation_split = ze_memory_provider_allocation_split,
-    .ipc.get_ipc_handle_size = ze_memory_provider_get_ipc_handle_size,
-    .ipc.get_ipc_handle = ze_memory_provider_get_ipc_handle,
-    .ipc.put_ipc_handle = ze_memory_provider_put_ipc_handle,
-    .ipc.open_ipc_handle = ze_memory_provider_open_ipc_handle,
-    .ipc.close_ipc_handle = ze_memory_provider_close_ipc_handle,
+    .ext_purge_lazy = ze_memory_provider_purge_lazy,
+    .ext_purge_force = ze_memory_provider_purge_force,
+    .ext_allocation_merge = ze_memory_provider_allocation_merge,
+    .ext_allocation_split = ze_memory_provider_allocation_split,
+    .ext_get_ipc_handle_size = ze_memory_provider_get_ipc_handle_size,
+    .ext_get_ipc_handle = ze_memory_provider_get_ipc_handle,
+    .ext_put_ipc_handle = ze_memory_provider_put_ipc_handle,
+    .ext_open_ipc_handle = ze_memory_provider_open_ipc_handle,
+    .ext_close_ipc_handle = ze_memory_provider_close_ipc_handle,
+    .ext_ctl = ze_ctl,
+    .ext_get_allocation_properties =
+        ze_memory_provider_get_allocation_properties,
+    .ext_get_allocation_properties_size =
+        ze_memory_provider_get_allocation_properties_size,
 };
 
-umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void) {
+const umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void) {
     return &UMF_LEVEL_ZERO_MEMORY_PROVIDER_OPS;
 }
 
-#endif // !defined(UMF_NO_LEVEL_ZERO_PROVIDER)
+#else // !UMF_BUILD_LEVEL_ZERO_PROVIDER
+
+umf_result_t umfLevelZeroMemoryProviderParamsCreate(
+    umf_level_zero_memory_provider_params_handle_t *hParams) {
+    (void)hParams;
+    LOG_ERR("L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is "
+            "OFF)");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfLevelZeroMemoryProviderParamsDestroy(
+    umf_level_zero_memory_provider_params_handle_t hParams) {
+    (void)hParams;
+    LOG_ERR("L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is "
+            "OFF)");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfLevelZeroMemoryProviderParamsSetContext(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    ze_context_handle_t hContext) {
+    (void)hParams;
+    (void)hContext;
+    LOG_ERR("L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is "
+            "OFF)");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfLevelZeroMemoryProviderParamsSetDevice(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    ze_device_handle_t hDevice) {
+    (void)hParams;
+    (void)hDevice;
+    LOG_ERR("L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is "
+            "OFF)");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfLevelZeroMemoryProviderParamsSetMemoryType(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    umf_usm_memory_type_t memoryType) {
+    (void)hParams;
+    (void)memoryType;
+    LOG_ERR("L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is "
+            "OFF)");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfLevelZeroMemoryProviderParamsSetResidentDevices(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    ze_device_handle_t *hDevices, uint32_t deviceCount) {
+    (void)hParams;
+    (void)hDevices;
+    (void)deviceCount;
+    LOG_ERR("L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is "
+            "OFF)");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfLevelZeroMemoryProviderParamsSetFreePolicy(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    umf_level_zero_memory_provider_free_policy_t policy) {
+    (void)hParams;
+    (void)policy;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    uint32_t deviceOrdinal) {
+    (void)hParams;
+    (void)deviceOrdinal;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfLevelZeroMemoryProviderParamsSetName(
+    umf_level_zero_memory_provider_params_handle_t hParams, const char *name) {
+    (void)hParams;
+    (void)name;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+const umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void) {
+    // not supported
+    LOG_ERR("L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is "
+            "OFF)");
+    return NULL;
+}
+
+umf_result_t umfLevelZeroMemoryProviderResidentDeviceChange(
+    umf_memory_provider_handle_t provider, ze_device_handle_t device,
+    bool is_adding) {
+    (void)provider;
+    (void)device;
+    (void)is_adding;
+    LOG_ERR("L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is "
+            "OFF)");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+#endif // !UMF_BUILD_LEVEL_ZERO_PROVIDER
diff --git a/src/provider/provider_level_zero_internal.h b/src/provider/provider_level_zero_internal.h
new file mode 100644
index 0000000000..58f130f0cf
--- /dev/null
+++ b/src/provider/provider_level_zero_internal.h
@@ -0,0 +1,15 @@
+/*
+ *
+ * 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
+ *
+ */
+
+#ifndef UMF_LEVEL_ZERO_PROVIDER_INTERNAL_H
+#define UMF_LEVEL_ZERO_PROVIDER_INTERNAL_H 1
+
+void fini_ze_global_state(void);
+
+#endif /* UMF_LEVEL_ZERO_PROVIDER_INTERNAL_H */
diff --git a/src/provider/provider_os_memory.c b/src/provider/provider_os_memory.c
index 4c19944a96..edaf315dc4 100644
--- a/src/provider/provider_os_memory.c
+++ b/src/provider/provider_os_memory.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -14,94 +14,31 @@
 #include <string.h>
 
 #include <umf.h>
+#include <umf/base.h>
+#include <umf/memory_provider.h>
 #include <umf/memory_provider_ops.h>
 #include <umf/providers/provider_os_memory.h>
 
-// OS Memory Provider requires HWLOC
-#if defined(UMF_NO_HWLOC)
-
-umf_memory_provider_ops_t *umfOsMemoryProviderOps(void) { return NULL; }
-
-umf_result_t umfOsMemoryProviderParamsCreate(
-    umf_os_memory_provider_params_handle_t *hParams) {
-    (void)hParams;
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-umf_result_t umfOsMemoryProviderParamsDestroy(
-    umf_os_memory_provider_params_handle_t hParams) {
-    (void)hParams;
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-umf_result_t umfOsMemoryProviderParamsSetProtection(
-    umf_os_memory_provider_params_handle_t hParams, unsigned protection) {
-    (void)hParams;
-    (void)protection;
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-umf_result_t umfOsMemoryProviderParamsSetVisibility(
-    umf_os_memory_provider_params_handle_t hParams,
-    umf_memory_visibility_t visibility) {
-    (void)hParams;
-    (void)visibility;
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-umf_result_t umfOsMemoryProviderParamsSetShmName(
-    umf_os_memory_provider_params_handle_t hParams, const char *shm_name) {
-    (void)hParams;
-    (void)shm_name;
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-umf_result_t umfOsMemoryProviderParamsSetNumaList(
-    umf_os_memory_provider_params_handle_t hParams, unsigned *numa_list,
-    unsigned numa_list_len) {
-    (void)hParams;
-    (void)numa_list;
-    (void)numa_list_len;
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-umf_result_t umfOsMemoryProviderParamsSetNumaMode(
-    umf_os_memory_provider_params_handle_t hParams, umf_numa_mode_t numa_mode) {
-    (void)hParams;
-    (void)numa_mode;
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-umf_result_t umfOsMemoryProviderParamsSetPartSize(
-    umf_os_memory_provider_params_handle_t hParams, size_t part_size) {
-    (void)hParams;
-    (void)part_size;
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-umf_result_t umfOsMemoryProviderParamsSetPartitions(
-    umf_os_memory_provider_params_handle_t hParams,
-    umf_numa_split_partition_t *partitions, unsigned partitions_len) {
-    (void)hParams;
-    (void)partitions;
-    (void)partitions_len;
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
-#else // !defined(UMF_NO_HWLOC)
-
 #include "base_alloc_global.h"
 #include "critnib.h"
+#include "ctl/ctl_internal.h"
 #include "libumf.h"
 #include "provider_os_memory_internal.h"
+#include "topology.h"
+#include "utils_assert.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
 #include "utils_log.h"
 
+#define CTL_PROVIDER_TYPE os_memory_provider_t
+#include "provider_ctl_stats_impl.h"
+
 #define NODESET_STR_BUF_LEN 1024
 
 #define TLS_MSG_BUF_LEN 1024
 
+static const char *DEFAULT_NAME = "OS";
+
 typedef struct umf_os_memory_provider_params_t {
     // Combination of 'umf_mem_protection_flags_t' flags
     unsigned protection;
@@ -126,6 +63,7 @@ typedef struct umf_os_memory_provider_params_t {
     umf_numa_split_partition_t *partitions;
     /// len of the partitions array
     unsigned partitions_len;
+    char name[64];
 } umf_os_memory_provider_params_t;
 
 typedef struct os_last_native_error_t {
@@ -166,6 +104,31 @@ static const char *Native_error_str[] = {
         "HWLOC topology discovery failed",
 };
 
+struct ctl os_memory_ctl_root;
+
+static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT;
+
+static umf_result_t
+CTL_READ_HANDLER(ipc_enabled)(void *ctx, umf_ctl_query_source_t source,
+                              void *arg, size_t size,
+                              umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)size;
+
+    int *arg_out = arg;
+    os_memory_provider_t *os_provider = (os_memory_provider_t *)ctx;
+    *arg_out = os_provider->IPC_enabled;
+    return UMF_RESULT_SUCCESS;
+}
+
+static const umf_ctl_node_t CTL_NODE(params)[] = {CTL_LEAF_RO(ipc_enabled),
+                                                  CTL_NODE_END};
+
+static void initialize_os_ctl(void) {
+    CTL_REGISTER_MODULE(&os_memory_ctl_root, params);
+    CTL_REGISTER_MODULE(&os_memory_ctl_root, stats);
+}
+
 static void os_store_last_native_error(int32_t native_error, int errno_value) {
     TLS_last_native_error.native_error = native_error;
     TLS_last_native_error.errno_value = errno_value;
@@ -229,7 +192,8 @@ static umf_result_t initialize_nodeset(os_memory_provider_t *os_provider,
         hwloc_bitmap_free(out_nodeset[i]);
     }
 err_free_list:
-    umf_ba_global_free(*out_nodeset);
+    // free the array of bitmap pointers
+    umf_ba_global_free(out_nodeset);
     os_provider->nodeset_len = 0;
     return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
 }
@@ -286,7 +250,8 @@ static hwloc_membind_policy_t translate_numa_mode(umf_numa_mode_t mode,
 
 //return 1 if umf will bind memory directly to single NUMA node, based on internal algorithm
 //return 0 if umf will just set numa memory policy, and kernel will decide where to allocate memory
-static int dedicated_node_bind(umf_os_memory_provider_params_t *in_params) {
+static int
+dedicated_node_bind(const umf_os_memory_provider_params_t *in_params) {
     if (in_params->numa_mode == UMF_NUMA_MODE_INTERLEAVE) {
         return in_params->part_size > 0;
     }
@@ -336,7 +301,7 @@ static int validate_and_copy_shm_name(const char *in_shm_name,
 }
 
 static umf_result_t
-create_fd_for_mmap(umf_os_memory_provider_params_t *in_params,
+create_fd_for_mmap(const umf_os_memory_provider_params_t *in_params,
                    os_memory_provider_t *provider) {
     umf_result_t result;
 
@@ -359,7 +324,7 @@ create_fd_for_mmap(umf_os_memory_provider_params_t *in_params,
                                        provider->shm_name)) {
             LOG_ERR("invalid name of a shared memory file: %s",
                     in_params->shm_name);
-            return -1;
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
         }
 
         /* create a new shared memory file */
@@ -370,7 +335,7 @@ create_fd_for_mmap(umf_os_memory_provider_params_t *in_params,
                     "memory mapping failed",
                     in_params->shm_name, provider->max_size_fd);
             provider->shm_name[0] = '\0'; // zero shm_name
-            return -1;
+            return UMF_RESULT_ERROR_UNKNOWN;
         }
 
         LOG_DEBUG("created the shared memory file /dev/shm/%s of size %zu",
@@ -407,7 +372,7 @@ create_fd_for_mmap(umf_os_memory_provider_params_t *in_params,
 }
 
 static umf_result_t
-validatePartitions(umf_os_memory_provider_params_t *params) {
+validatePartitions(const umf_os_memory_provider_params_t *params) {
 
     if (params->partitions_len == 0) {
         return UMF_RESULT_SUCCESS;
@@ -434,11 +399,12 @@ validatePartitions(umf_os_memory_provider_params_t *params) {
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t os_get_min_page_size(void *provider, void *ptr,
+static umf_result_t os_get_min_page_size(void *provider, const void *ptr,
                                          size_t *page_size);
 
-static umf_result_t validatePartSize(os_memory_provider_t *provider,
-                                     umf_os_memory_provider_params_t *params) {
+static umf_result_t
+validatePartSize(os_memory_provider_t *provider,
+                 const umf_os_memory_provider_params_t *params) {
     size_t page_size;
     os_get_min_page_size(provider, NULL, &page_size);
     if (ALIGN_UP(params->part_size, page_size) < params->part_size) {
@@ -459,7 +425,7 @@ static void free_bitmaps(os_memory_provider_t *provider) {
 
 static umf_result_t
 initializePartitions(os_memory_provider_t *provider,
-                     umf_os_memory_provider_params_t *in_params) {
+                     const umf_os_memory_provider_params_t *in_params) {
     if (provider->mode != UMF_NUMA_MODE_SPLIT) {
         return UMF_RESULT_SUCCESS;
     }
@@ -500,8 +466,9 @@ initializePartitions(os_memory_provider_t *provider,
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t translate_params(umf_os_memory_provider_params_t *in_params,
-                                     os_memory_provider_t *provider) {
+static umf_result_t
+translate_params(const umf_os_memory_provider_params_t *in_params,
+                 os_memory_provider_t *provider) {
     umf_result_t result;
 
     result = utils_translate_mem_protection_flags(in_params->protection,
@@ -568,15 +535,14 @@ static umf_result_t translate_params(umf_os_memory_provider_params_t *in_params,
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t os_initialize(void *params, void **provider) {
+static umf_result_t os_initialize(const void *params, void **provider) {
     umf_result_t ret;
 
     if (params == NULL) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    umf_os_memory_provider_params_t *in_params =
-        (umf_os_memory_provider_params_t *)params;
+    const umf_os_memory_provider_params_t *in_params = params;
 
     if (in_params->visibility == UMF_MEM_MAP_SHARED &&
         in_params->numa_mode != UMF_NUMA_MODE_DEFAULT) {
@@ -593,28 +559,23 @@ static umf_result_t os_initialize(void *params, void **provider) {
     }
 
     memset(os_provider, 0, sizeof(*os_provider));
+    snprintf(os_provider->name, sizeof(os_provider->name), "%s",
+             in_params->name);
 
-    int r = hwloc_topology_init(&os_provider->topo);
-    if (r) {
-        LOG_ERR("HWLOC topology init failed");
-        ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-        goto err_free_os_provider;
-    }
-
-    r = hwloc_topology_load(os_provider->topo);
-    if (r) {
+    os_provider->topo = umfGetTopologyReduced();
+    if (!os_provider->topo) {
         os_store_last_native_error(UMF_OS_RESULT_ERROR_TOPO_DISCOVERY_FAILED,
                                    0);
         LOG_ERR("HWLOC topology discovery failed");
         ret = UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
-        goto err_destroy_hwloc_topology;
+        goto err_free_os_provider;
     }
 
-    os_provider->fd_offset_map = critnib_new();
+    os_provider->fd_offset_map = critnib_new(NULL, NULL);
     if (!os_provider->fd_offset_map) {
         LOG_ERR("creating file descriptor offset map failed");
         ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-        goto err_destroy_hwloc_topology;
+        goto err_free_os_provider;
     }
 
     ret = translate_params(in_params, os_provider);
@@ -650,21 +611,18 @@ static umf_result_t os_initialize(void *params, void **provider) {
     }
 
     *provider = os_provider;
-
     return UMF_RESULT_SUCCESS;
 
 err_destroy_bitmaps:
     free_bitmaps(os_provider);
 err_destroy_critnib:
     critnib_delete(os_provider->fd_offset_map);
-err_destroy_hwloc_topology:
-    hwloc_topology_destroy(os_provider->topo);
 err_free_os_provider:
     umf_ba_global_free(os_provider);
     return ret;
 }
 
-static void os_finalize(void *provider) {
+static umf_result_t os_finalize(void *provider) {
     os_memory_provider_t *os_provider = provider;
 
     if (os_provider->fd > 0) {
@@ -682,8 +640,9 @@ static void os_finalize(void *provider) {
     if (os_provider->nodeset_str_buf) {
         umf_ba_global_free(os_provider->nodeset_str_buf);
     }
-    hwloc_topology_destroy(os_provider->topo);
+
     umf_ba_global_free(os_provider);
+    return UMF_RESULT_SUCCESS;
 }
 
 // TODO: this function should be re-enabled when CTL is implemented
@@ -934,7 +893,7 @@ static membind_t membindFirst(os_memory_provider_t *provider, void *addr,
 
     if (provider->mode == UMF_NUMA_MODE_INTERLEAVE) {
         assert(provider->part_size != 0);
-        size_t s = utils_fetch_and_add64(&provider->alloc_sum, size);
+        size_t s = utils_fetch_and_add_u64(&provider->alloc_sum, size);
         membind.node = (s / provider->part_size) % provider->nodeset_len;
         membind.bitmap = provider->nodeset[membind.node];
         membind.bind_size = ALIGN_UP(provider->part_size, membind.page_size);
@@ -1080,6 +1039,7 @@ static umf_result_t os_alloc(void *provider, size_t size, size_t alignment,
 
     *resultPtr = addr;
 
+    provider_ctl_stats_alloc(os_provider, size);
     return UMF_RESULT_SUCCESS;
 
 err_unmap:
@@ -1095,7 +1055,7 @@ static umf_result_t os_free(void *provider, void *ptr, size_t size) {
     os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
 
     if (os_provider->fd > 0) {
-        critnib_remove(os_provider->fd_offset_map, (uintptr_t)ptr);
+        critnib_remove(os_provider->fd_offset_map, (uintptr_t)ptr, NULL);
     }
 
     errno = 0;
@@ -1107,22 +1067,24 @@ static umf_result_t os_free(void *provider, void *ptr, size_t size) {
         return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
     }
 
+    provider_ctl_stats_free(os_provider, size);
+
     return UMF_RESULT_SUCCESS;
 }
 
-static void os_get_last_native_error(void *provider, const char **ppMessage,
-                                     int32_t *pError) {
+static umf_result_t os_get_last_native_error(void *provider,
+                                             const char **ppMessage,
+                                             int32_t *pError) {
     (void)provider; // unused
 
     if (ppMessage == NULL || pError == NULL) {
-        assert(0);
-        return;
+        return UMF_RESULT_SUCCESS;
     }
 
     *pError = TLS_last_native_error.native_error;
     if (TLS_last_native_error.errno_value == 0) {
         *ppMessage = Native_error_str[*pError - UMF_OS_RESULT_SUCCESS];
-        return;
+        return UMF_RESULT_SUCCESS;
     }
 
     const char *msg;
@@ -1143,6 +1105,7 @@ static void os_get_last_native_error(void *provider, const char **ppMessage,
                    TLS_last_native_error.msg_buff + pos, TLS_MSG_BUF_LEN - pos);
 
     *ppMessage = TLS_last_native_error.msg_buff;
+    return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t os_get_recommended_page_size(void *provider, size_t size,
@@ -1155,7 +1118,7 @@ static umf_result_t os_get_recommended_page_size(void *provider, size_t size,
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t os_get_min_page_size(void *provider, void *ptr,
+static umf_result_t os_get_min_page_size(void *provider, const void *ptr,
                                          size_t *page_size) {
     (void)ptr; // unused
 
@@ -1189,9 +1152,17 @@ static umf_result_t os_purge_force(void *provider, void *ptr, size_t size) {
     return UMF_RESULT_SUCCESS;
 }
 
-static const char *os_get_name(void *provider) {
-    (void)provider; // unused
-    return "OS";
+static umf_result_t os_get_name(void *provider, const char **name) {
+    if (!name) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    if (provider == NULL) {
+        *name = DEFAULT_NAME;
+        return UMF_RESULT_SUCCESS;
+    }
+    os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
+    *name = os_provider->name;
+    return UMF_RESULT_SUCCESS;
 }
 
 // This function is supposed to be thread-safe, so it should NOT be called concurrently
@@ -1205,7 +1176,7 @@ static umf_result_t os_allocation_split(void *provider, void *ptr,
         return UMF_RESULT_SUCCESS;
     }
 
-    void *value = critnib_get(os_provider->fd_offset_map, (uintptr_t)ptr);
+    void *value = critnib_get(os_provider->fd_offset_map, (uintptr_t)ptr, NULL);
     if (value == NULL) {
         LOG_ERR("os_allocation_split(): getting a value from the file "
                 "descriptor offset map failed (addr=%p)",
@@ -1239,7 +1210,7 @@ static umf_result_t os_allocation_merge(void *provider, void *lowPtr,
     }
 
     void *value =
-        critnib_remove(os_provider->fd_offset_map, (uintptr_t)highPtr);
+        critnib_remove(os_provider->fd_offset_map, (uintptr_t)highPtr, NULL);
     if (value == NULL) {
         LOG_ERR("os_allocation_merge(): removing a value from the file "
                 "descriptor offset map failed (addr=%p)",
@@ -1284,11 +1255,9 @@ static umf_result_t os_get_ipc_handle(void *provider, const void *ptr,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    void *value = critnib_get(os_provider->fd_offset_map, (uintptr_t)ptr);
+    void *value = critnib_get(os_provider->fd_offset_map, (uintptr_t)ptr, NULL);
     if (value == NULL) {
-        LOG_ERR("os_get_ipc_handle(): getting a value from the IPC cache "
-                "failed (addr=%p)",
-                ptr);
+        LOG_ERR("getting a value from the IPC cache failed (addr=%p)", ptr);
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
@@ -1373,7 +1342,8 @@ static umf_result_t os_open_ipc_handle(void *provider, void *providerIpcData,
                       os_ipc_data->visibility, fd, os_ipc_data->fd_offset);
     if (*ptr == NULL) {
         os_store_last_native_error(UMF_OS_RESULT_ERROR_ALLOC_FAILED, errno);
-        LOG_PERR("memory mapping failed");
+        LOG_PERR("memory mapping failed: %zu bytes at fd=%d, offset=%zu",
+                 os_ipc_data->size, fd, os_ipc_data->fd_offset);
         ret = UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
     }
 
@@ -1403,27 +1373,38 @@ static umf_result_t os_close_ipc_handle(void *provider, void *ptr,
     return UMF_RESULT_SUCCESS;
 }
 
+static umf_result_t os_ctl(void *hProvider,
+                           umf_ctl_query_source_t operationType,
+                           const char *name, void *arg, size_t size,
+                           umf_ctl_query_type_t query_type, va_list args) {
+    utils_init_once(&ctl_initialized, initialize_os_ctl);
+    return ctl_query(&os_memory_ctl_root, hProvider, operationType, name,
+                     query_type, arg, size, args);
+}
+
 static umf_memory_provider_ops_t UMF_OS_MEMORY_PROVIDER_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = os_initialize,
     .finalize = os_finalize,
     .alloc = os_alloc,
+    .free = os_free,
     .get_last_native_error = os_get_last_native_error,
     .get_recommended_page_size = os_get_recommended_page_size,
     .get_min_page_size = os_get_min_page_size,
     .get_name = os_get_name,
-    .ext.free = os_free,
-    .ext.purge_lazy = os_purge_lazy,
-    .ext.purge_force = os_purge_force,
-    .ext.allocation_merge = os_allocation_merge,
-    .ext.allocation_split = os_allocation_split,
-    .ipc.get_ipc_handle_size = os_get_ipc_handle_size,
-    .ipc.get_ipc_handle = os_get_ipc_handle,
-    .ipc.put_ipc_handle = os_put_ipc_handle,
-    .ipc.open_ipc_handle = os_open_ipc_handle,
-    .ipc.close_ipc_handle = os_close_ipc_handle};
-
-umf_memory_provider_ops_t *umfOsMemoryProviderOps(void) {
+    .ext_purge_lazy = os_purge_lazy,
+    .ext_purge_force = os_purge_force,
+    .ext_allocation_merge = os_allocation_merge,
+    .ext_allocation_split = os_allocation_split,
+    .ext_get_ipc_handle_size = os_get_ipc_handle_size,
+    .ext_get_ipc_handle = os_get_ipc_handle,
+    .ext_put_ipc_handle = os_put_ipc_handle,
+    .ext_open_ipc_handle = os_open_ipc_handle,
+    .ext_close_ipc_handle = os_close_ipc_handle,
+    .ext_ctl = os_ctl,
+};
+
+const umf_memory_provider_ops_t *umfOsMemoryProviderOps(void) {
     return &UMF_OS_MEMORY_PROVIDER_OPS;
 }
 
@@ -1451,6 +1432,8 @@ umf_result_t umfOsMemoryProviderParamsCreate(
     params->part_size = 0;
     params->partitions = NULL;
     params->partitions_len = 0;
+    strncpy(params->name, DEFAULT_NAME, sizeof(params->name) - 1);
+    params->name[sizeof(params->name) - 1] = '\0';
 
     *hParams = params;
 
@@ -1607,4 +1590,21 @@ umf_result_t umfOsMemoryProviderParamsSetPartitions(
     return UMF_RESULT_SUCCESS;
 }
 
-#endif // !defined(UMF_NO_HWLOC)
+umf_result_t
+umfOsMemoryProviderParamsSetName(umf_os_memory_provider_params_handle_t hParams,
+                                 const char *name) {
+    if (hParams == NULL) {
+        LOG_ERR("OS memory provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (name == NULL) {
+        LOG_ERR("name is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    strncpy(hParams->name, name, sizeof(hParams->name) - 1);
+    hParams->name[sizeof(hParams->name) - 1] = '\0';
+
+    return UMF_RESULT_SUCCESS;
+}
diff --git a/src/provider/provider_os_memory_internal.h b/src/provider/provider_os_memory_internal.h
index faf0de2473..3648d4a88f 100644
--- a/src/provider/provider_os_memory_internal.h
+++ b/src/provider/provider_os_memory_internal.h
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -10,7 +10,6 @@
 
 #include <limits.h>
 #include <stdbool.h>
-
 #if defined(_WIN32) && !defined(NAME_MAX)
 #include <stdlib.h>
 #define NAME_MAX _MAX_FNAME
@@ -23,6 +22,8 @@
 #include "utils_common.h"
 #include "utils_concurrency.h"
 
+#include "provider_ctl_stats_type.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -58,7 +59,7 @@ typedef struct os_memory_provider_t {
     int numa_flags; // combination of hwloc flags
 
     size_t part_size;
-    size_t alloc_sum; // sum of all allocations - used for manual interleaving
+    uint64_t alloc_sum; // sum of all allocations - used for manual interleaving
 
     struct {
         unsigned weight;
@@ -68,6 +69,10 @@ typedef struct os_memory_provider_t {
     size_t partitions_weight_sum;
 
     hwloc_topology_t topo;
+
+    char name[64];
+
+    ctl_stats_t stats;
 } os_memory_provider_t;
 
 #ifdef __cplusplus
diff --git a/src/provider/provider_tracking.c b/src/provider/provider_tracking.c
index e726feefb0..573e9bb357 100644
--- a/src/provider/provider_tracking.c
+++ b/src/provider/provider_tracking.c
@@ -1,72 +1,343 @@
 /*
  *
- * 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 "provider_tracking.h"
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <umf/memory_pool.h>
+#include <umf/memory_provider.h>
+#include <umf/memory_provider_gpu.h>
+#include <umf/memory_provider_ops.h>
+
 #include "base_alloc_global.h"
 #include "critnib.h"
 #include "ipc_cache.h"
 #include "ipc_internal.h"
+#include "memory_pool_internal.h"
+#include "memory_properties_internal.h"
+#include "memory_provider_internal.h"
+#include "provider_tracking.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
 #include "utils_log.h"
 
-#include <umf/memory_pool.h>
-#include <umf/memory_provider.h>
-#include <umf/memory_provider_ops.h>
-
-#include <assert.h>
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+// TODO: we need to support an arbitrary amount of layers in the future
+#define MAX_LEVELS_OF_ALLOC_SEGMENT_MAP 8
 
 uint64_t IPC_HANDLE_ID = 0;
 
-typedef struct tracker_value_t {
-    umf_memory_pool_handle_t pool;
+uint64_t unique_alloc_id = 0; // requires atomic access
+
+struct umf_memory_tracker_t {
+    umf_ba_pool_t *alloc_info_allocator;
+    // Multilevel maps are needed to support the case
+    // when one memory pool acts as a memory provider
+    // for another memory pool (nested memory pooling).
+    critnib *alloc_segments_map[MAX_LEVELS_OF_ALLOC_SEGMENT_MAP];
+    utils_mutex_t splitMergeMutex;
+    umf_ba_pool_t *ipc_info_allocator;
+    critnib *ipc_segments_map;
+};
+
+typedef struct tracker_ipc_info_t {
+    umf_memory_properties_t props;
     size_t size;
-} tracker_value_t;
+    umf_memory_provider_handle_t provider;
+    ipc_opened_cache_value_t *ipc_cache_value;
+} tracker_ipc_info_t;
+
+// Get the most nested (on the highest level) allocation segment in the map with the `ptr` key.
+// If `no_children` is set to 1, the function will return the entry
+// only if it has no children on the higher level.
+// The function returns the entry if found, otherwise NULL.
+static tracker_alloc_info_t *get_most_nested_alloc_segment(
+    umf_memory_tracker_handle_t hTracker, const void *ptr, int *_level,
+    uintptr_t *_parent_key, tracker_alloc_info_t **_parent_value,
+    void **_ref_value, void **_ref_parent_value, int no_children) {
 
-static umf_result_t umfMemoryTrackerAdd(umf_memory_tracker_handle_t hTracker,
-                                        umf_memory_pool_handle_t pool,
-                                        const void *ptr, size_t size) {
+    assert(ptr);
+    assert(_ref_value);
+    if (_parent_value) {
+        assert(_ref_parent_value);
+    }
+
+    tracker_alloc_info_t *parent_value = NULL;
+    tracker_alloc_info_t *rvalue = NULL;
+    uintptr_t parent_key = 0;
+    uintptr_t rkey = 0;
+    uint64_t rsize = 0;
+    size_t n_children = 0;
+    int level = 0;
+    int found = 0;
+
+    void *ref_value = NULL;
+    void *ref_parent_value = NULL;
+
+    do {
+        assert(level < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP);
+        found =
+            critnib_find(hTracker->alloc_segments_map[level], (uintptr_t)ptr,
+                         FIND_LE, (void *)&rkey, (void **)&rvalue, &ref_value);
+        if (!found) {
+            assert(ref_value == NULL);
+            break;
+        }
+
+        if (rvalue == NULL) {
+            if (ref_value) {
+                critnib_release(hTracker->alloc_segments_map[level], ref_value);
+            }
+            parent_value = NULL;
+            parent_key = 0;
+            rkey = 0;
+            rsize = 0;
+            level = 0;
+            found = 0;
+            ref_value = NULL;
+            ref_parent_value = NULL;
+            continue;
+        }
+
+        utils_atomic_load_acquire_u64((uint64_t *)&rvalue->props.base_size,
+                                      &rsize);
+        utils_atomic_load_acquire_size_t(&rvalue->n_children, &n_children);
+        if (found && ((uintptr_t)ptr < rkey + rsize) && n_children) {
+            if (level == MAX_LEVELS_OF_ALLOC_SEGMENT_MAP - 1) {
+                break;
+            }
+
+            level++;
+
+            if (_parent_key) {
+                parent_key = rkey;
+            }
+
+            if (_parent_value) {
+                parent_value = rvalue;
+                // If we return the parent value, we have to return also its reference.
+                // If it is already set, we have to release the previous one first.
+                if (ref_parent_value) {
+                    assert(level >= 2);
+                    // release the previous reference to the parent value
+                    critnib_release(hTracker->alloc_segments_map[level - 2],
+                                    ref_parent_value);
+                }
+                ref_parent_value = ref_value;
+            } else if (ref_value) {
+                // If we do not return the parent value,
+                // we have to release the current 'ref_value' reference
+                // before it will be overwritten in the next critnib_find() call.
+                assert(level >= 1);
+                critnib_release(hTracker->alloc_segments_map[level - 1],
+                                ref_value);
+                ref_value = NULL;
+            }
+        }
+    } while (found && ((uintptr_t)ptr < rkey + rsize) && n_children);
+
+    if (!rvalue || rkey != (uintptr_t)ptr) {
+        return NULL;
+    }
+
+    if (no_children && (n_children > 0)) {
+        return NULL;
+    }
+
+    if (_level) {
+        *_level = level;
+    }
+    if (_parent_key) {
+        *_parent_key = parent_key;
+    }
+    if (_parent_value) {
+        *_ref_parent_value = ref_parent_value;
+        *_parent_value = parent_value;
+    }
+
+    assert(!no_children || rvalue->n_children == 0);
+    assert(ref_value);
+    *_ref_value = ref_value;
+
+    return rvalue;
+}
+
+static umf_result_t
+umfMemoryTrackerAddAtLevel(umf_memory_tracker_handle_t hTracker, int level,
+                           umf_memory_pool_handle_t pool, const void *ptr,
+                           size_t size, uintptr_t parent_key,
+                           tracker_alloc_info_t *parent_value,
+                           void *ref_parent_value) {
     assert(ptr);
 
-    tracker_value_t *value = umf_ba_alloc(hTracker->tracker_allocator);
+    umf_result_t umf_result = UMF_RESULT_ERROR_UNKNOWN;
+
+    tracker_alloc_info_t *value = umf_ba_alloc(hTracker->alloc_info_allocator);
     if (value == NULL) {
-        LOG_ERR("failed to allocate tracker value, ptr=%p, size=%zu", ptr,
+        LOG_ERR("failed to allocate a tracker value, ptr=%p, size=%zu", ptr,
                 size);
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    value->pool = pool;
-    value->size = size;
+    // get provider
+    umf_memory_provider_handle_t provider = NULL;
+    umfPoolGetMemoryProvider(pool, &provider);
 
-    int ret = critnib_insert(hTracker->map, (uintptr_t)ptr, value, 0);
+    // get memory type
+    umf_usm_memory_type_t memory_type = UMF_MEMORY_TYPE_UNKNOWN;
+    if (provider && provider->ops.ext_get_allocation_properties) {
+        provider->ops.ext_get_allocation_properties(
+            provider->provider_priv, ptr, UMF_MEMORY_PROPERTY_POINTER_TYPE,
+            &memory_type);
+    }
 
+    memset(&value->props, 0, sizeof(umf_memory_properties_t));
+    value->props.id = utils_atomic_increment_u64(&unique_alloc_id);
+    value->props.base = (void *)ptr;
+    value->props.base_size = size;
+    value->props.pool = pool;
+    value->props.provider = provider;
+    value->props.memory_type = memory_type;
+
+    value->n_children = 0;
+#if !defined(NDEBUG) && defined(UMF_DEVELOPER_MODE)
+    value->is_freed = 0;
+#endif
+
+    assert(level < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP);
+    int ret = critnib_insert(hTracker->alloc_segments_map[level],
+                             (uintptr_t)ptr, value, 0);
     if (ret == 0) {
-        LOG_DEBUG(
-            "memory region is added, tracker=%p, ptr=%p, pool=%p, size=%zu",
-            (void *)hTracker, ptr, (void *)pool, size);
+        LOG_DEBUG("memory region is added, tracker=%p, level=%i, pool=%p, "
+                  "ptr=%p, size=%zu",
+                  (void *)hTracker, level, (void *)pool, ptr, size);
+
+        if (parent_value) {
+            size_t n_children =
+                utils_atomic_increment_size_t(&parent_value->n_children) + 1;
+            LOG_DEBUG(
+                "child #%zu added to memory region: tracker=%p, level=%i, "
+                "pool=%p, ptr=%p, size=%zu",
+                n_children, (void *)hTracker, level - 1,
+                (void *)parent_value->props.pool, (void *)parent_key,
+                parent_value->props.base_size);
+            assert(ref_parent_value);
+            critnib_release(hTracker->alloc_segments_map[level - 1],
+                            ref_parent_value);
+        }
         return UMF_RESULT_SUCCESS;
     }
+    if (ret == ENOMEM) {
+        umf_result = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
 
-    LOG_ERR("failed to insert tracker value, ret=%d, ptr=%p, pool=%p, size=%zu",
-            ret, ptr, (void *)pool, size);
+    LOG_ERR(
+        "failed to insert the tracker value: pool=%p, ptr=%p, size=%zu, ret=%d",
+        (void *)pool, ptr, size, ret);
 
-    umf_ba_free(hTracker->tracker_allocator, value);
+    umf_ba_free(hTracker->alloc_info_allocator, value);
 
-    if (ret == ENOMEM) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    return umf_result;
+}
+
+static umf_result_t umfMemoryTrackerAdd(umf_memory_tracker_handle_t hTracker,
+                                        umf_memory_pool_handle_t pool,
+                                        const void *ptr, size_t size) {
+    assert(ptr);
+
+    tracker_alloc_info_t *parent_value = NULL;
+    tracker_alloc_info_t *rvalue = NULL;
+    uintptr_t parent_key = 0;
+    uintptr_t rkey = 0;
+    uint64_t rsize = 0;
+    size_t n_children = 0;
+    int level = 0;
+    int found = 0;
+
+    void *ref_value = NULL;
+    void *ref_parent_value = NULL;
+
+    // Find the most nested (in the highest level) entry
+    // in the critnib maps that contains the given 'ptr' pointer.
+    do {
+        assert(level < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP);
+        found =
+            critnib_find(hTracker->alloc_segments_map[level], (uintptr_t)ptr,
+                         FIND_LE, (void *)&rkey, (void **)&rvalue, &ref_value);
+        if (!found) {
+            assert(ref_value == NULL);
+            break;
+        }
+
+        if (!rvalue) {
+            if (ref_value) {
+                critnib_release(hTracker->alloc_segments_map[level], ref_value);
+            }
+            parent_value = NULL;
+            parent_key = 0;
+            rkey = 0;
+            rsize = 0;
+            level = 0;
+            found = 0;
+            ref_value = NULL;
+            ref_parent_value = NULL;
+            continue;
+        }
+
+#if !defined(NDEBUG) && defined(UMF_DEVELOPER_MODE)
+        // make sure rvalue is not freed
+        uint64_t is_freed;
+        utils_atomic_load_acquire_u64(&rvalue->is_freed, &is_freed);
+        assert(is_freed != 0xDEADBEEF);
+#endif
+
+        utils_atomic_load_acquire_u64((uint64_t *)&rvalue->props.base_size,
+                                      &rsize);
+
+        if ((uintptr_t)ptr < rkey + rsize) {
+            if (level == MAX_LEVELS_OF_ALLOC_SEGMENT_MAP - 1) {
+                // TODO: we need to support an arbitrary amount of layers in the future
+                LOG_ERR("tracker level is too high, ptr=%p, size=%zu", ptr,
+                        size);
+                return UMF_RESULT_ERROR_OUT_OF_RESOURCES;
+            }
+            if (((uintptr_t)ptr + size) > (rkey + rsize)) {
+                LOG_ERR(
+                    "cannot insert to the tracker value (pool=%p, ptr=%p, "
+                    "size=%zu) "
+                    "that exceeds the parent value (pool=%p, ptr=%p, size=%zu)",
+                    (void *)pool, ptr, size, (void *)rvalue->props.pool,
+                    (void *)rkey, (size_t)rsize);
+                return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+            }
+            parent_key = rkey;
+            parent_value = rvalue;
+            if (ref_parent_value) {
+                assert(level >= 1);
+                critnib_release(hTracker->alloc_segments_map[level - 1],
+                                ref_parent_value);
+            }
+            ref_parent_value = ref_value;
+            level++;
+        }
+        utils_atomic_load_acquire_size_t(&rvalue->n_children, &n_children);
+    } while (found && ((uintptr_t)ptr < rkey + rsize) && n_children);
+
+    if (ref_value && ref_value != ref_parent_value) {
+        critnib_release(hTracker->alloc_segments_map[level], ref_value);
     }
 
-    return UMF_RESULT_ERROR_UNKNOWN;
+    return umfMemoryTrackerAddAtLevel(hTracker, level, pool, ptr, size,
+                                      parent_key, parent_value,
+                                      ref_parent_value);
 }
 
 static umf_result_t umfMemoryTrackerRemove(umf_memory_tracker_handle_t hTracker,
@@ -78,35 +349,243 @@ static umf_result_t umfMemoryTrackerRemove(umf_memory_tracker_handle_t hTracker,
     // Every umfMemoryTrackerAdd(..., ptr, ...) should have a corresponding
     // umfMemoryTrackerRemove call with the same ptr value.
 
-    void *value = critnib_remove(hTracker->map, (uintptr_t)ptr);
+    tracker_alloc_info_t *parent_value = NULL;
+    uintptr_t parent_key = 0;
+    int level = 0;
+
+    // Find the most nested (on the highest level) entry in the map
+    // with the `ptr` key and with no children - only such entry can be removed.
+    void *ref_value = NULL;
+    void *ref_parent_value = NULL;
+    tracker_alloc_info_t *value = get_most_nested_alloc_segment(
+        hTracker, ptr, &level, &parent_key, &parent_value, &ref_value,
+        &ref_parent_value, 1 /* no_children */);
     if (!value) {
-        LOG_ERR("pointer %p not found in the map", ptr);
+        LOG_ERR("pointer %p not found in the alloc_segments_map", ptr);
         return UMF_RESULT_ERROR_UNKNOWN;
     }
 
-    tracker_value_t *v = value;
+    assert(level < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP);
+
+    // release the reference to the value got from get_most_nested_alloc_segment()
+    assert(ref_value);
+    critnib_release(hTracker->alloc_segments_map[level], ref_value);
 
-    LOG_DEBUG("memory region removed: tracker=%p, ptr=%p, size=%zu",
-              (void *)hTracker, ptr, v->size);
+    value = critnib_remove(hTracker->alloc_segments_map[level], (uintptr_t)ptr,
+                           &ref_value);
+    assert(value);
 
-    umf_ba_free(hTracker->tracker_allocator, value);
+    LOG_DEBUG("memory region removed: tracker=%p, level=%i, pool=%p, ptr=%p, "
+              "size=%zu",
+              (void *)hTracker, level, (void *)value->props.pool, ptr,
+              value->props.base_size);
+
+    // release the reference to the value got from critnib_remove()
+    assert(ref_value);
+    critnib_release(hTracker->alloc_segments_map[level], ref_value);
+
+    if (parent_value) {
+        size_t n_children =
+            utils_atomic_decrement_size_t(&parent_value->n_children);
+        LOG_DEBUG(
+            "child #%zu removed from memory region: tracker=%p, level=%i, "
+            "pool=%p, ptr=%p, size=%zu",
+            n_children, (void *)hTracker, level - 1,
+            (void *)parent_value->props.pool, (void *)parent_key,
+            parent_value->props.base_size);
+
+        assert(ref_parent_value);
+        assert(level >= 1);
+        // release the ref_parent_value got from get_most_nested_alloc_segment()
+        critnib_release(hTracker->alloc_segments_map[level - 1],
+                        ref_parent_value);
+    }
 
     return UMF_RESULT_SUCCESS;
 }
 
-umf_memory_pool_handle_t umfMemoryTrackerGetPool(const void *ptr) {
-    umf_alloc_info_t allocInfo = {NULL, 0, NULL};
-    umf_result_t ret = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
-    if (ret != UMF_RESULT_SUCCESS) {
-        return NULL;
+static umf_result_t
+umfMemoryTrackerAddIpcSegment(umf_memory_tracker_handle_t hTracker,
+                              const void *ptr, size_t size,
+                              umf_memory_provider_handle_t provider,
+                              ipc_opened_cache_value_t *cache_entry) {
+    assert(hTracker);
+    assert(provider);
+    assert(cache_entry);
+
+    tracker_ipc_info_t *value = umf_ba_alloc(hTracker->ipc_info_allocator);
+
+    if (value == NULL) {
+        LOG_ERR("failed to allocate tracker_ipc_info_t, ptr=%p, size=%zu", ptr,
+                size);
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    // get memory type
+    umf_usm_memory_type_t memory_type = UMF_MEMORY_TYPE_UNKNOWN;
+    if (provider && provider->ops.ext_get_allocation_properties) {
+        provider->ops.ext_get_allocation_properties(
+            provider->provider_priv, ptr, UMF_MEMORY_PROPERTY_POINTER_TYPE,
+            &memory_type);
+    }
+
+    value->size = size;
+    value->provider = provider;
+    value->ipc_cache_value = cache_entry;
+
+    memset(&value->props, 0, sizeof(umf_memory_properties_t));
+    value->props.id = utils_atomic_increment_u64(&unique_alloc_id);
+    value->props.base = (void *)ptr;
+    value->props.base_size = size;
+    value->props.pool = NULL; // unknown
+    value->props.provider = provider;
+    value->props.memory_type = memory_type;
+
+    int ret =
+        critnib_insert(hTracker->ipc_segments_map, (uintptr_t)ptr, value, 0);
+    if (ret == 0) {
+        LOG_DEBUG("IPC memory region is added, tracker=%p, ptr=%p, size=%zu, "
+                  "provider=%p, cache_entry=%p",
+                  (void *)hTracker, ptr, size, (void *)provider,
+                  (void *)cache_entry);
+        return UMF_RESULT_SUCCESS;
+    }
+
+    LOG_ERR("failed to insert tracker_ipc_info_t, ret=%d, ptr=%p, size=%zu, "
+            "provider=%p, cache_entry=%p",
+            ret, ptr, size, (void *)provider, (void *)cache_entry);
+
+    umf_ba_free(hTracker->ipc_info_allocator, value);
+
+    if (ret == ENOMEM) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    return allocInfo.pool;
+    return UMF_RESULT_ERROR_UNKNOWN;
+}
+
+static umf_result_t
+umfMemoryTrackerRemoveIpcSegment(umf_memory_tracker_handle_t hTracker,
+                                 const void *ptr) {
+    assert(ptr);
+
+    void *ref_value = NULL;
+    void *value =
+        critnib_remove(hTracker->ipc_segments_map, (uintptr_t)ptr, &ref_value);
+    if (!value) {
+        LOG_ERR("pointer %p not found in the ipc_segments_map", ptr);
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    tracker_ipc_info_t *v = value;
+
+    LOG_DEBUG("IPC memory region removed: tracker=%p, ptr=%p, size=%zu, "
+              "provider=%p, cache_entry=%p",
+              (void *)hTracker, ptr, v->size, (void *)v->provider,
+              (void *)v->ipc_cache_value);
+
+    assert(ref_value);
+    critnib_release(hTracker->ipc_segments_map, ref_value);
+
+    return UMF_RESULT_SUCCESS;
 }
 
 umf_result_t umfMemoryTrackerGetAllocInfo(const void *ptr,
-                                          umf_alloc_info_t *pAllocInfo) {
-    assert(pAllocInfo);
+                                          tracker_alloc_info_t **info) {
+    assert(info);
+
+    if (UNLIKELY(ptr == NULL)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (UNLIKELY(TRACKER == NULL)) {
+        LOG_ERR("tracker does not exist");
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+
+    if (UNLIKELY(TRACKER->alloc_segments_map[0] == NULL)) {
+        LOG_ERR("tracker's alloc_segments_map does not exist");
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+
+    tracker_alloc_info_t *top_most_value = NULL;
+    tracker_alloc_info_t *rvalue = NULL;
+    uintptr_t rkey = 0;
+    uint64_t rsize = 0;
+    size_t n_children = 0;
+    int level = 0;
+    int found = 0;
+
+    void *ref_value = NULL;
+    void *ref_top_most_value = NULL;
+    int ref_level = 0;
+
+    do {
+        assert(level < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP);
+        found =
+            critnib_find(TRACKER->alloc_segments_map[level], (uintptr_t)ptr,
+                         FIND_LE, (void *)&rkey, (void **)&rvalue, &ref_value);
+        if (!found) {
+            assert(ref_value == NULL);
+            break;
+        }
+
+        if (!rvalue) {
+            if (ref_value) {
+                critnib_release(TRACKER->alloc_segments_map[level], ref_value);
+            }
+            top_most_value = NULL;
+            rkey = 0;
+            rsize = 0;
+            level = 0;
+            found = 0;
+            ref_value = NULL;
+            ref_top_most_value = NULL;
+            ref_level = 0;
+            continue;
+        }
+
+        utils_atomic_load_acquire_u64((uint64_t *)&rvalue->props.base_size,
+                                      &rsize);
+        utils_atomic_load_acquire_size_t(&rvalue->n_children, &n_children);
+        if (found && (uintptr_t)ptr < rkey + rsize) {
+            top_most_value = rvalue;
+            if (ref_top_most_value) {
+                assert(level >= 1);
+                critnib_release(TRACKER->alloc_segments_map[level - 1],
+                                ref_top_most_value);
+            }
+            ref_top_most_value = ref_value;
+            ref_level = level;
+            if (n_children == 0 ||
+                level == MAX_LEVELS_OF_ALLOC_SEGMENT_MAP - 1) {
+                break;
+            }
+            level++;
+        }
+    } while (found && (uintptr_t)ptr < rkey + rsize && n_children);
+
+    if (!top_most_value) {
+        if (ref_value) {
+            critnib_release(TRACKER->alloc_segments_map[level], ref_value);
+        }
+
+        LOG_DEBUG("pointer %p not found in the tracker, TRACKER=%p", ptr,
+                  (void *)TRACKER);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    *info = top_most_value;
+
+    assert(ref_top_most_value);
+    critnib_release(TRACKER->alloc_segments_map[ref_level], ref_top_most_value);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfMemoryTrackerGetIpcInfo(const void *ptr,
+                                        umf_ipc_info_t *pIpcInfo) {
+    assert(pIpcInfo);
 
     if (ptr == NULL) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
@@ -117,24 +596,36 @@ umf_result_t umfMemoryTrackerGetAllocInfo(const void *ptr,
         return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
 
-    if (TRACKER->map == NULL) {
-        LOG_ERR("tracker's map does not exist");
+    if (TRACKER->ipc_segments_map == NULL) {
+        LOG_ERR("tracker's ipc_segments_map does not exist");
         return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
 
-    uintptr_t rkey;
-    tracker_value_t *rvalue;
-    int found = critnib_find(TRACKER->map, (uintptr_t)ptr, FIND_LE,
-                             (void *)&rkey, (void **)&rvalue);
-    if (!found || (uintptr_t)ptr >= rkey + rvalue->size) {
+    uintptr_t rkey = 0;
+    tracker_ipc_info_t *rvalue = NULL;
+    void *ref_value = NULL;
+    int found = critnib_find(TRACKER->ipc_segments_map, (uintptr_t)ptr, FIND_LE,
+                             (void *)&rkey, (void **)&rvalue, &ref_value);
+
+    if (!found || (found && (rvalue == NULL)) ||
+        ((uintptr_t)ptr >= rkey + rvalue->size)) {
         LOG_DEBUG("pointer %p not found in the tracker, TRACKER=%p", ptr,
                   (void *)TRACKER);
+        if (ref_value) {
+            critnib_release(TRACKER->ipc_segments_map, ref_value);
+        }
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    pAllocInfo->base = (void *)rkey;
-    pAllocInfo->baseSize = rvalue->size;
-    pAllocInfo->pool = rvalue->pool;
+    pIpcInfo->base = (void *)rkey;
+    pIpcInfo->baseSize = rvalue->size;
+    pIpcInfo->provider = rvalue->provider;
+
+    pIpcInfo->props = &rvalue->props;
+
+    if (ref_value) {
+        critnib_release(TRACKER->ipc_segments_map, ref_value);
+    }
 
     return UMF_RESULT_SUCCESS;
 }
@@ -153,35 +644,44 @@ typedef struct umf_tracking_memory_provider_t {
     umf_memory_tracker_handle_t hTracker;
     umf_memory_pool_handle_t pool;
     critnib *ipcCache;
-    ipc_mapped_handle_cache_handle_t hIpcMappedCache;
-
-    // the upstream provider does not support the free() operation
-    bool upstreamDoesNotFree;
+    ipc_opened_cache_handle_t hIpcMappedCache;
 } umf_tracking_memory_provider_t;
 
 typedef struct umf_tracking_memory_provider_t umf_tracking_memory_provider_t;
 
 static umf_result_t trackingAlloc(void *hProvider, size_t size,
-                                  size_t alignment, void **ptr) {
+                                  size_t alignment, void **_ptr) {
     umf_tracking_memory_provider_t *p =
         (umf_tracking_memory_provider_t *)hProvider;
     umf_result_t ret = UMF_RESULT_SUCCESS;
+    void *ptr;
 
     assert(p->hUpstream);
 
-    ret = umfMemoryProviderAlloc(p->hUpstream, size, alignment, ptr);
-    if (ret != UMF_RESULT_SUCCESS || !*ptr) {
+    *_ptr = NULL;
+
+    ret = umfMemoryProviderAlloc(p->hUpstream, size, alignment, &ptr);
+    if (ret != UMF_RESULT_SUCCESS || !ptr) {
         return ret;
     }
 
-    umf_result_t ret2 = umfMemoryTrackerAdd(p->hTracker, p->pool, *ptr, size);
-    if (ret2 != UMF_RESULT_SUCCESS) {
+    ret = umfMemoryTrackerAdd(p->hTracker, p->pool, ptr, size);
+    if (ret != UMF_RESULT_SUCCESS) {
         LOG_ERR("failed to add allocated region to the tracker, ptr = %p, size "
                 "= %zu, ret = %d",
-                *ptr, size, ret2);
+                ptr, size, ret);
+        umf_result_t ret2 = umfMemoryProviderFree(p->hUpstream, ptr, size);
+        if (ret2 != UMF_RESULT_SUCCESS) {
+            LOG_ERR("upstream provider failed to free the memory: ptr = %p, "
+                    "size = %zu, ret = %d",
+                    ptr, size, ret2);
+        }
+        return ret;
     }
 
-    return ret;
+    *_ptr = ptr;
+
+    return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t trackingAllocationSplit(void *hProvider, void *ptr,
@@ -190,31 +690,31 @@ static umf_result_t trackingAllocationSplit(void *hProvider, void *ptr,
     umf_result_t ret = UMF_RESULT_ERROR_UNKNOWN;
     umf_tracking_memory_provider_t *provider =
         (umf_tracking_memory_provider_t *)hProvider;
-
-    tracker_value_t *splitValue =
-        umf_ba_alloc(provider->hTracker->tracker_allocator);
-    if (!splitValue) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    splitValue->pool = provider->pool;
-    splitValue->size = firstSize;
+    tracker_alloc_info_t *parent_value = NULL;
+    uintptr_t parent_key = 0;
 
     int r = utils_mutex_lock(&provider->hTracker->splitMergeMutex);
     if (r) {
         goto err_lock;
     }
 
-    tracker_value_t *value =
-        (tracker_value_t *)critnib_get(provider->hTracker->map, (uintptr_t)ptr);
+    int level = 0;
+    void *ref_value = NULL;
+    void *ref_parent_value = NULL;
+
+    // Find the most nested (on the highest level) entry in the map
+    // with the `ptr` key and with no children - only such entry can be split.
+    tracker_alloc_info_t *value = get_most_nested_alloc_segment(
+        provider->hTracker, ptr, &level, &parent_key, &parent_value, &ref_value,
+        &ref_parent_value, 1 /* no_children */);
     if (!value) {
         LOG_ERR("region for split is not found in the tracker");
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
         goto err;
     }
-    if (value->size != totalSize) {
-        LOG_ERR("tracked size %zu does not match requested size to split: %zu",
-                value->size, totalSize);
+    if (value->props.base_size != totalSize) {
+        LOG_ERR("tracked size=%zu does not match requested size to split: %zu",
+                value->props.base_size, totalSize);
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
         goto err;
     }
@@ -229,36 +729,49 @@ static umf_result_t trackingAllocationSplit(void *hProvider, void *ptr,
     void *highPtr = (void *)(((uintptr_t)ptr) + firstSize);
     size_t secondSize = totalSize - firstSize;
 
+    assert(level < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP);
+
     // We'll have a duplicate entry for the range [highPtr, highValue->size] but this is fine,
     // the value is the same anyway and we forbid removing that range concurrently
-    ret = umfMemoryTrackerAdd(provider->hTracker, provider->pool, highPtr,
-                              secondSize);
+    ret = umfMemoryTrackerAddAtLevel(provider->hTracker, level, provider->pool,
+                                     highPtr, secondSize, parent_key,
+                                     parent_value, ref_parent_value);
     if (ret != UMF_RESULT_SUCCESS) {
-        LOG_ERR("failed to add split region to the tracker, ptr = %p, size "
-                "= %zu, ret = %d",
+        LOG_ERR("failed to add the split region to the tracker, ptr=%p, "
+                "size=%zu, ret=%d",
                 highPtr, secondSize, ret);
+
+        // revert the split
+        (void)umfMemoryProviderAllocationMerge(provider->hUpstream, ptr,
+                                               highPtr, totalSize);
+
         // TODO: what now? should we rollback the split? This can only happen due to ENOMEM
         // so it's unlikely but probably the best solution would be to try to preallocate everything
         // (value and critnib nodes) before calling umfMemoryProviderAllocationSplit.
         goto err;
     }
 
-    int cret = critnib_insert(provider->hTracker->map, (uintptr_t)ptr,
-                              (void *)splitValue, 1 /* update */);
-    // this cannot fail since we know the element exists (nothing to allocate)
-    assert(cret == 0);
-    (void)cret;
+    // update the size of the first part
+    utils_atomic_store_release_u64((uint64_t *)&value->props.base_size,
+                                   firstSize);
+    critnib_release(provider->hTracker->alloc_segments_map[level], ref_value);
 
-    // free the original value
-    umf_ba_free(provider->hTracker->tracker_allocator, value);
     utils_mutex_unlock(&provider->hTracker->splitMergeMutex);
 
+    LOG_DEBUG(
+        "split memory region (level=%i): ptr=%p, totalSize=%zu, firstSize=%zu",
+        level, ptr, totalSize, firstSize);
+
     return UMF_RESULT_SUCCESS;
 
 err:
     utils_mutex_unlock(&provider->hTracker->splitMergeMutex);
+
 err_lock:
-    umf_ba_free(provider->hTracker->tracker_allocator, splitValue);
+    LOG_ERR(
+        "failed to split memory region: ptr=%p, totalSize=%zu, firstSize=%zu",
+        ptr, totalSize, firstSize);
+
     return ret;
 }
 
@@ -268,82 +781,106 @@ static umf_result_t trackingAllocationMerge(void *hProvider, void *lowPtr,
     umf_tracking_memory_provider_t *provider =
         (umf_tracking_memory_provider_t *)hProvider;
 
-    tracker_value_t *mergedValue =
-        umf_ba_alloc(provider->hTracker->tracker_allocator);
-
-    if (!mergedValue) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    mergedValue->pool = provider->pool;
-    mergedValue->size = totalSize;
+    // any different negative values
+    int lowLevel = -2;
+    int highLevel = -1;
 
     int r = utils_mutex_lock(&provider->hTracker->splitMergeMutex);
     if (r) {
         goto err_lock;
     }
 
-    tracker_value_t *lowValue = (tracker_value_t *)critnib_get(
-        provider->hTracker->map, (uintptr_t)lowPtr);
+    void *ref_lowValue = NULL;
+    void *ref_highValue = NULL;
+
+    tracker_alloc_info_t *lowValue = get_most_nested_alloc_segment(
+        provider->hTracker, lowPtr, &lowLevel, NULL, NULL, &ref_lowValue, NULL,
+        0 /* no_children */);
     if (!lowValue) {
-        LOG_ERR("no left value");
+        LOG_FATAL("no left value");
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err;
+        goto err_fatal;
     }
-    tracker_value_t *highValue = (tracker_value_t *)critnib_get(
-        provider->hTracker->map, (uintptr_t)highPtr);
+    if (lowValue->n_children) {
+        LOG_FATAL("left value is used (has children)");
+        ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        goto err_fatal;
+    }
+
+    tracker_alloc_info_t *highValue = get_most_nested_alloc_segment(
+        provider->hTracker, highPtr, &highLevel, NULL, NULL, &ref_highValue,
+        NULL, 0 /* no_children */);
     if (!highValue) {
-        LOG_ERR("no right value");
+        LOG_FATAL("no right value");
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err;
+        goto err_fatal;
     }
-    if (lowValue->pool != highValue->pool) {
-        LOG_ERR("pool mismatch");
+    if (highValue->n_children) {
+        LOG_FATAL("right value is used (has children)");
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err;
+        goto err_fatal;
     }
-    if (lowValue->size + highValue->size != totalSize) {
-        LOG_ERR("lowValue->size + highValue->size != totalSize");
+
+    if (lowLevel != highLevel) {
+        LOG_FATAL("tracker level mismatch");
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err;
+        goto err_fatal;
+    }
+    if (lowValue->props.pool != highValue->props.pool) {
+        LOG_FATAL("pool mismatch");
+        ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        goto err_fatal;
+    }
+    if (lowValue->props.base_size + highValue->props.base_size != totalSize) {
+        LOG_FATAL("lowValue->size + highValue->size != totalSize");
+        ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        goto err_fatal;
     }
 
     ret = umfMemoryProviderAllocationMerge(provider->hUpstream, lowPtr, highPtr,
                                            totalSize);
     if (ret != UMF_RESULT_SUCCESS) {
         LOG_WARN("upstream provider failed to merge regions");
-        goto not_merged;
+        goto cannot_merge;
     }
 
-    // We'll have a duplicate entry for the range [highPtr, highValue->size] but this is fine,
-    // the value is the same anyway and we forbid removing that range concurrently
-    int cret = critnib_insert(provider->hTracker->map, (uintptr_t)lowPtr,
-                              (void *)mergedValue, 1 /* update */);
-    // this cannot fail since we know the element exists (nothing to allocate)
-    assert(cret == 0);
-    (void)cret;
+    // we only need to update the size of the first part
+    utils_atomic_store_release_u64((uint64_t *)&lowValue->props.base_size,
+                                   totalSize);
+
+    size_t low_children = lowValue->n_children;
+    size_t high_children = highValue->n_children;
 
-    // free old value that we just replaced with mergedValue
-    umf_ba_free(provider->hTracker->tracker_allocator, lowValue);
+    critnib_release(provider->hTracker->alloc_segments_map[lowLevel],
+                    ref_lowValue);
+    critnib_release(provider->hTracker->alloc_segments_map[highLevel],
+                    ref_highValue);
 
-    void *erasedhighValue =
-        critnib_remove(provider->hTracker->map, (uintptr_t)highPtr);
-    assert(erasedhighValue == highValue);
+    critnib_remove_release(provider->hTracker->alloc_segments_map[highLevel],
+                           (uintptr_t)highPtr);
 
-    umf_ba_free(provider->hTracker->tracker_allocator, erasedhighValue);
+    LOG_DEBUG("merged memory regions (level=%i): lowPtr=%p (child=%zu), "
+              "highPtr=%p (child=%zu), totalSize=%zu",
+              lowLevel, lowPtr, low_children, highPtr, high_children,
+              totalSize);
 
     utils_mutex_unlock(&provider->hTracker->splitMergeMutex);
 
     return UMF_RESULT_SUCCESS;
 
-err:
-    assert(0);
+err_fatal:
+    LOG_FATAL("failed to merge memory regions: lowPtr=%p (level=%i), "
+              "highPtr=%p (level=%i), totalSize=%zu",
+              lowPtr, lowLevel, highPtr, highLevel, totalSize);
 
-not_merged:
+cannot_merge:
     utils_mutex_unlock(&provider->hTracker->splitMergeMutex);
 
 err_lock:
-    umf_ba_free(provider->hTracker->tracker_allocator, mergedValue);
+    LOG_ERR("failed to merge memory regions: lowPtr=%p (level=%i), highPtr=%p "
+            "(level=%i), totalSize=%zu",
+            lowPtr, lowLevel, highPtr, highLevel, totalSize);
+
     return ret;
 }
 
@@ -368,7 +905,8 @@ static umf_result_t trackingFree(void *hProvider, void *ptr, size_t size) {
         }
     }
 
-    void *value = critnib_remove(p->ipcCache, (uintptr_t)ptr);
+    void *ref_value = NULL;
+    void *value = critnib_remove(p->ipcCache, (uintptr_t)ptr, &ref_value);
     if (value) {
         ipc_cache_value_t *cache_value = (ipc_cache_value_t *)value;
         ret = umfMemoryProviderPutIPCHandle(p->hUpstream,
@@ -378,7 +916,10 @@ static umf_result_t trackingFree(void *hProvider, void *ptr, size_t size) {
                     "size=%zu, ret = %d",
                     ptr, size, ret);
         }
-        umf_ba_global_free(value);
+    }
+
+    if (ref_value) {
+        critnib_release(p->ipcCache, ref_value);
     }
 
     ret = umfMemoryProviderFree(p->hUpstream, ptr, size);
@@ -392,9 +933,8 @@ static umf_result_t trackingFree(void *hProvider, void *ptr, size_t size) {
 
         if (umfMemoryTrackerAdd(p->hTracker, p->pool, ptr, size) !=
             UMF_RESULT_SUCCESS) {
-            LOG_ERR(
-                "cannot add memory back to the tracker, ptr = %p, size = %zu",
-                ptr, size);
+            LOG_ERR("cannot add memory back to the tracker, ptr=%p, size=%zu",
+                    ptr, size);
         }
         return ret;
     }
@@ -402,14 +942,14 @@ static umf_result_t trackingFree(void *hProvider, void *ptr, size_t size) {
     return ret;
 }
 
-static umf_result_t trackingInitialize(void *params, void **ret) {
+static umf_result_t trackingInitialize(const void *params, void **ret) {
     umf_tracking_memory_provider_t *provider =
         umf_ba_global_alloc(sizeof(umf_tracking_memory_provider_t));
     if (!provider) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    *provider = *((umf_tracking_memory_provider_t *)params);
+    *provider = *((const umf_tracking_memory_provider_t *)params);
     if (provider->hUpstream == NULL || provider->hTracker == NULL ||
         provider->pool == NULL || provider->ipcCache == NULL) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
@@ -419,79 +959,75 @@ static umf_result_t trackingInitialize(void *params, void **ret) {
     return UMF_RESULT_SUCCESS;
 }
 
-// TODO clearing the tracker is a temporary solution and should be removed.
-// The tracker should be cleared using the provider's free() operation.
-static void clear_tracker_for_the_pool(umf_memory_tracker_handle_t hTracker,
-                                       umf_memory_pool_handle_t pool,
-                                       bool upstreamDoesNotFree) {
-    uintptr_t rkey;
-    void *rvalue;
+#ifndef NDEBUG
+static void check_if_tracker_is_empty(umf_memory_tracker_handle_t hTracker,
+                                      umf_memory_pool_handle_t pool) {
     size_t n_items = 0;
-    uintptr_t last_key = 0;
-
-    while (1 == critnib_find((critnib *)hTracker->map, last_key, FIND_G, &rkey,
-                             &rvalue)) {
-        tracker_value_t *value = (tracker_value_t *)rvalue;
-        if (value->pool != pool && pool != NULL) {
-            last_key = rkey;
-            continue;
-        }
 
-        n_items++;
+    for (int i = 0; i < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP; i++) {
+        uintptr_t last_key = 0;
+        uintptr_t rkey;
+        tracker_alloc_info_t *rvalue;
+        void *ref_value = NULL;
+
+        while (1 == critnib_find(hTracker->alloc_segments_map[i], last_key,
+                                 FIND_G, &rkey, (void **)&rvalue, &ref_value)) {
+            if (rvalue && ((rvalue->props.pool == pool) || pool == NULL)) {
+                n_items++;
+                LOG_DEBUG(
+                    "found abandoned allocation in the tracking provider: "
+                    "pool=%p, ptr=%p, size=%zu",
+                    (void *)rvalue->props.pool, (void *)rkey,
+                    (size_t)rvalue->props.base_size);
+            }
 
-        void *removed_value = critnib_remove(hTracker->map, rkey);
-        assert(removed_value == rvalue);
-        umf_ba_free(hTracker->tracker_allocator, removed_value);
+            if (ref_value) {
+                critnib_release(hTracker->alloc_segments_map[i], ref_value);
+            }
 
-        last_key = rkey;
+            last_key = rkey;
+        }
     }
 
-#ifndef NDEBUG
-    // print error messages only if provider supports the free() operation
-    if (n_items && !upstreamDoesNotFree) {
-        if (pool) {
-            LOG_ERR(
-                "tracking provider of pool %p is not empty! (%zu items left)",
-                (void *)pool, n_items);
-        } else {
-            LOG_ERR("tracking provider is not empty! (%zu items left)",
-                    n_items);
+    if (n_items) {
+        // Do not log the error if we are running in the proxy library,
+        // because it may need those resources till
+        // the very end of exiting the application.
+        if (!utils_is_running_in_proxy_lib()) {
+            if (pool) {
+                LOG_ERR("tracking provider of pool %p is not empty! (%zu items "
+                        "left)",
+                        (void *)pool, n_items);
+            } else {
+                LOG_ERR("tracking provider is not empty! (%zu items left)",
+                        n_items);
+            }
+
+#ifdef UMF_DEVELOPER_MODE
+            assert(n_items == 0 && "tracking provider is not empty!");
+#endif
         }
     }
-#else  /* DEBUG */
-    (void)upstreamDoesNotFree; // unused in DEBUG build
-    (void)n_items;             // unused in DEBUG build
-#endif /* DEBUG */
-}
-
-static void clear_tracker(umf_memory_tracker_handle_t hTracker) {
-    clear_tracker_for_the_pool(hTracker, NULL, false);
 }
+#endif /* NDEBUG */
 
-static void trackingFinalize(void *provider) {
+static umf_result_t trackingFinalize(void *provider) {
     umf_tracking_memory_provider_t *p =
         (umf_tracking_memory_provider_t *)provider;
 
-    umfIpcHandleMappedCacheDestroy(p->hIpcMappedCache);
+    umfIpcOpenedCacheDestroy(p->hIpcMappedCache);
 
     critnib_delete(p->ipcCache);
 
-    // Do not clear the tracker if we are running in the proxy library,
-    // because it may need those resources till
-    // the very end of exiting the application.
-    if (!utils_is_running_in_proxy_lib()) {
-        clear_tracker_for_the_pool(p->hTracker, p->pool,
-                                   p->upstreamDoesNotFree);
-    }
-
     umf_ba_global_free(provider);
+    return UMF_RESULT_SUCCESS;
 }
 
-static void trackingGetLastError(void *provider, const char **msg,
-                                 int32_t *pError) {
+static umf_result_t trackingGetLastError(void *provider, const char **msg,
+                                         int32_t *pError) {
     umf_tracking_memory_provider_t *p =
         (umf_tracking_memory_provider_t *)provider;
-    umfMemoryProviderGetLastNativeError(p->hUpstream, msg, pError);
+    return umfMemoryProviderGetLastNativeError(p->hUpstream, msg, pError);
 }
 
 static umf_result_t trackingGetRecommendedPageSize(void *provider, size_t size,
@@ -502,7 +1038,7 @@ static umf_result_t trackingGetRecommendedPageSize(void *provider, size_t size,
                                                    pageSize);
 }
 
-static umf_result_t trackingGetMinPageSize(void *provider, void *ptr,
+static umf_result_t trackingGetMinPageSize(void *provider, const void *ptr,
                                            size_t *pageSize) {
     umf_tracking_memory_provider_t *p =
         (umf_tracking_memory_provider_t *)provider;
@@ -521,10 +1057,15 @@ static umf_result_t trackingPurgeForce(void *provider, void *ptr, size_t size) {
     return umfMemoryProviderPurgeForce(p->hUpstream, ptr, size);
 }
 
-static const char *trackingName(void *provider) {
+static umf_result_t trackingName(void *provider, const char **name) {
     umf_tracking_memory_provider_t *p =
         (umf_tracking_memory_provider_t *)provider;
-    return umfMemoryProviderGetName(p->hUpstream);
+    // if ops->get_name is called with null provider it must return default provider name
+    if (!p) {
+        *name = "tracking";
+        return UMF_RESULT_SUCCESS;
+    }
+    return umfMemoryProviderGetName(p->hUpstream, name);
 }
 
 static umf_result_t trackingGetIpcHandleSize(void *provider, size_t *size) {
@@ -547,13 +1088,19 @@ static umf_result_t trackingGetIpcHandle(void *provider, const void *ptr,
     int cached = 0;
     ipc_cache_value_t *cache_value = NULL;
     umf_ipc_data_t *ipcUmfData = getIpcDataFromIpcHandle(providerIpcData);
+    void *ref_value = NULL;
 
     do {
-        void *value = critnib_get(p->ipcCache, (uintptr_t)ptr);
+        void *value = critnib_get(p->ipcCache, (uintptr_t)ptr, &ref_value);
         if (value) { //cache hit
             cache_value = (ipc_cache_value_t *)value;
             cached = 1;
         } else { //cache miss
+            if (ref_value) {
+                critnib_release(p->ipcCache, ref_value);
+                ref_value = NULL;
+            }
+
             ret = umfMemoryProviderGetIPCHandleSize(p->hUpstream, &ipcDataSize);
             if (ret != UMF_RESULT_SUCCESS) {
                 LOG_ERR("upstream provider failed to get the size of IPC "
@@ -576,7 +1123,7 @@ static umf_result_t trackingGetIpcHandle(void *provider, const void *ptr,
                 return ret;
             }
 
-            cache_value->handle_id = utils_atomic_increment(&IPC_HANDLE_ID);
+            cache_value->handle_id = utils_atomic_increment_u64(&IPC_HANDLE_ID);
             cache_value->ipcDataSize = ipcDataSize;
 
             int insRes = critnib_insert(p->ipcCache, (uintptr_t)ptr,
@@ -612,6 +1159,10 @@ static umf_result_t trackingGetIpcHandle(void *provider, const void *ptr,
            cache_value->ipcDataSize);
     ipcUmfData->handle_id = cache_value->handle_id;
 
+    if (ref_value) {
+        critnib_release(p->ipcCache, ref_value);
+    }
+
     return ret;
 }
 
@@ -625,21 +1176,21 @@ static umf_result_t trackingPutIpcHandle(void *provider,
 }
 
 static void
-ipcMappedCacheEvictionCallback(const ipc_mapped_handle_cache_key_t *key,
-                               const ipc_mapped_handle_cache_value_t *value) {
+ipcOpenedCacheEvictionCallback(const ipc_opened_cache_key_t *key,
+                               const ipc_opened_cache_value_t *value) {
     umf_tracking_memory_provider_t *p =
         (umf_tracking_memory_provider_t *)key->local_provider;
-    // umfMemoryTrackerRemove should be called before umfMemoryProviderCloseIPCHandle
+    // umfMemoryTrackerRemoveIpcSegment should be called before umfMemoryProviderCloseIPCHandle
     // to avoid a race condition. If the order would be different, other thread
-    // could allocate the memory at address `ptr` before a call to umfMemoryTrackerRemove
+    // could allocate the memory at address `ptr` before a call to umfMemoryTrackerRemoveIpcSegment
     // resulting in inconsistent state.
     if (value->mapped_base_ptr) {
-        umf_result_t ret =
-            umfMemoryTrackerRemove(p->hTracker, value->mapped_base_ptr);
+        umf_result_t ret = umfMemoryTrackerRemoveIpcSegment(
+            p->hTracker, value->mapped_base_ptr);
         if (ret != UMF_RESULT_SUCCESS) {
             // DO NOT return an error here, because the tracking provider
             // cannot change behaviour of the upstream provider.
-            LOG_ERR("failed to remove the region from the tracker, ptr=%p, "
+            LOG_ERR("failed to remove the region from the IPC tracker, ptr=%p, "
                     "size=%zu, ret = %d",
                     value->mapped_base_ptr, value->mapped_size, ret);
         }
@@ -652,12 +1203,13 @@ ipcMappedCacheEvictionCallback(const ipc_mapped_handle_cache_key_t *key,
     }
 }
 
-static umf_result_t upstreamOpenIPCHandle(umf_tracking_memory_provider_t *p,
-                                          void *providerIpcData,
-                                          size_t bufferSize, void **ptr) {
+static umf_result_t
+upstreamOpenIPCHandle(umf_tracking_memory_provider_t *p, void *providerIpcData,
+                      size_t bufferSize,
+                      ipc_opened_cache_value_t *cache_entry) {
     void *mapped_ptr = NULL;
     assert(p != NULL);
-    assert(ptr != NULL);
+    assert(cache_entry != NULL);
     umf_result_t ret = umfMemoryProviderOpenIPCHandle(
         p->hUpstream, providerIpcData, &mapped_ptr);
     if (ret != UMF_RESULT_SUCCESS) {
@@ -666,7 +1218,21 @@ static umf_result_t upstreamOpenIPCHandle(umf_tracking_memory_provider_t *p,
     }
     assert(mapped_ptr != NULL);
 
-    ret = umfMemoryTrackerAdd(p->hTracker, p->pool, mapped_ptr, bufferSize);
+    // Today umfMemoryTrackerAddIpcSegment requires the memory provider handle
+    // to know which tracking provider instance opened the IPC handle.
+    // The `p` points to the tracking provider private data.
+    // Because of that we get handle to the tracking provider instance
+    // using `p->pool->provider`.
+    //
+    // TODO:
+    // Today we always create a pool and get an IPC handler from the pool.
+    // And tracking provider is always created together with a pool.
+    // And the IPC handler is a tracking memory provider in fact.
+    // However, we are considering adding an API that allows IPC handler creation
+    // from scratch (without creating a memory pool). In that case, we will
+    // create a tracker provider without a pool. So p->pool might be NULL in the future.
+    ret = umfMemoryTrackerAddIpcSegment(p->hTracker, mapped_ptr, bufferSize,
+                                        p->pool->provider, cache_entry);
     if (ret != UMF_RESULT_SUCCESS) {
         LOG_ERR("failed to add IPC region to the tracker, ptr=%p, "
                 "size=%zu, "
@@ -681,7 +1247,8 @@ static umf_result_t upstreamOpenIPCHandle(umf_tracking_memory_provider_t *p,
         return ret;
     }
 
-    *ptr = mapped_ptr;
+    cache_entry->mapped_size = bufferSize;
+    utils_atomic_store_release_ptr(&(cache_entry->mapped_base_ptr), mapped_ptr);
     return UMF_RESULT_SUCCESS;
 }
 
@@ -696,16 +1263,16 @@ static umf_result_t trackingOpenIpcHandle(void *provider, void *providerIpcData,
 
     umf_ipc_data_t *ipcUmfData = getIpcDataFromIpcHandle(providerIpcData);
 
-    // Compiler may add paddings to the ipc_mapped_handle_cache_key_t structure
+    // Compiler may add paddings to the ipc_opened_cache_key_t structure
     // so we need to zero it out to avoid false cache miss.
-    ipc_mapped_handle_cache_key_t key = {0};
+    ipc_opened_cache_key_t key = {0};
     key.remote_base_ptr = ipcUmfData->base;
     key.local_provider = provider;
     key.remote_pid = ipcUmfData->pid;
 
-    ipc_mapped_handle_cache_value_t *cache_entry = NULL;
-    ret = umfIpcHandleMappedCacheGet(p->hIpcMappedCache, &key,
-                                     ipcUmfData->handle_id, &cache_entry);
+    ipc_opened_cache_value_t *cache_entry = NULL;
+    ret = umfIpcOpenedCacheGet(p->hIpcMappedCache, &key, ipcUmfData->handle_id,
+                               &cache_entry);
     if (ret != UMF_RESULT_SUCCESS) {
         LOG_ERR("failed to get cache entry");
         return ret;
@@ -714,24 +1281,22 @@ static umf_result_t trackingOpenIpcHandle(void *provider, void *providerIpcData,
     assert(cache_entry != NULL);
 
     void *mapped_ptr = NULL;
-    utils_atomic_load_acquire(&(cache_entry->mapped_base_ptr), &mapped_ptr);
-    if (mapped_ptr == NULL) {
+    utils_atomic_load_acquire_ptr(&(cache_entry->mapped_base_ptr),
+                                  (void **)&mapped_ptr);
+    if (mapped_ptr == NULL) { // new cache entry
         utils_mutex_lock(&(cache_entry->mmap_lock));
-        utils_atomic_load_acquire(&(cache_entry->mapped_base_ptr), &mapped_ptr);
+        utils_atomic_load_acquire_ptr(&(cache_entry->mapped_base_ptr),
+                                      (void **)&mapped_ptr);
         if (mapped_ptr == NULL) {
             ret = upstreamOpenIPCHandle(p, providerIpcData,
-                                        ipcUmfData->baseSize, &mapped_ptr);
-            if (ret == UMF_RESULT_SUCCESS) {
-                // Put to the cache
-                cache_entry->mapped_size = ipcUmfData->baseSize;
-                utils_atomic_store_release(&(cache_entry->mapped_base_ptr),
-                                           mapped_ptr);
-            }
+                                        ipcUmfData->baseSize, cache_entry);
         }
+        mapped_ptr = cache_entry->mapped_base_ptr;
         utils_mutex_unlock(&(cache_entry->mmap_lock));
     }
 
     if (ret == UMF_RESULT_SUCCESS) {
+        assert(mapped_ptr != NULL);
         *ptr = mapped_ptr;
     }
 
@@ -741,61 +1306,91 @@ static umf_result_t trackingOpenIpcHandle(void *provider, void *providerIpcData,
 static umf_result_t trackingCloseIpcHandle(void *provider, void *ptr,
                                            size_t size) {
     (void)provider;
-    (void)ptr;
-    (void)size;
-    // We keep opened IPC handles in the p->hIpcMappedCache.
-    // IPC handle is closed when it is evicted from the cache
-    // or when cache is destroyed.
-    //
-    // TODO: today the size of the IPC cache is infinite.
-    // When the threshold for the cache size is implemented
-    // we need to introduce a reference counting mechanism.
-    // The trackingOpenIpcHandle will increment the refcount for the corresponding entry.
-    // The trackingCloseIpcHandle will decrement the refcount for the corresponding cache entry.
-    return UMF_RESULT_SUCCESS;
+    void *ref_value = NULL;
+    tracker_ipc_info_t *trackerIpcInfo =
+        critnib_get(TRACKER->ipc_segments_map, (uintptr_t)ptr, &ref_value);
+    if (!trackerIpcInfo) {
+        LOG_ERR("failed to get tracker ipc info, ptr=%p, size=%zu", ptr, size);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_result_t umf_result =
+        umfIpcHandleMappedCacheRelease(trackerIpcInfo->ipc_cache_value);
+
+    assert(ref_value);
+    critnib_release(TRACKER->ipc_segments_map, ref_value);
+
+    return umf_result;
+}
+
+static umf_result_t
+trackingGetAllocationProperties(void *provider, const void *ptr,
+                                umf_memory_property_id_t memory_property_id,
+                                void *value) {
+    umf_tracking_memory_provider_t *p =
+        (umf_tracking_memory_provider_t *)provider;
+    return umfMemoryProviderGetAllocationProperties(p->hUpstream, ptr,
+                                                    memory_property_id, value);
+}
+
+static umf_result_t trackingGetAllocationPropertiesSize(
+    void *provider, umf_memory_property_id_t memory_property_id, size_t *size) {
+    umf_tracking_memory_provider_t *p =
+        (umf_tracking_memory_provider_t *)provider;
+    return umfMemoryProviderGetAllocationPropertiesSize(
+        p->hUpstream, memory_property_id, size);
 }
 
 umf_memory_provider_ops_t UMF_TRACKING_MEMORY_PROVIDER_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = trackingInitialize,
     .finalize = trackingFinalize,
     .alloc = trackingAlloc,
+    .free = trackingFree,
     .get_last_native_error = trackingGetLastError,
     .get_min_page_size = trackingGetMinPageSize,
     .get_recommended_page_size = trackingGetRecommendedPageSize,
     .get_name = trackingName,
-    .ext.free = trackingFree,
-    .ext.purge_force = trackingPurgeForce,
-    .ext.purge_lazy = trackingPurgeLazy,
-    .ext.allocation_split = trackingAllocationSplit,
-    .ext.allocation_merge = trackingAllocationMerge,
-    .ipc.get_ipc_handle_size = trackingGetIpcHandleSize,
-    .ipc.get_ipc_handle = trackingGetIpcHandle,
-    .ipc.put_ipc_handle = trackingPutIpcHandle,
-    .ipc.open_ipc_handle = trackingOpenIpcHandle,
-    .ipc.close_ipc_handle = trackingCloseIpcHandle};
+    .ext_purge_force = trackingPurgeForce,
+    .ext_purge_lazy = trackingPurgeLazy,
+    .ext_allocation_split = trackingAllocationSplit,
+    .ext_allocation_merge = trackingAllocationMerge,
+    .ext_get_ipc_handle_size = trackingGetIpcHandleSize,
+    .ext_get_ipc_handle = trackingGetIpcHandle,
+    .ext_put_ipc_handle = trackingPutIpcHandle,
+    .ext_open_ipc_handle = trackingOpenIpcHandle,
+    .ext_close_ipc_handle = trackingCloseIpcHandle,
+    .ext_get_allocation_properties = trackingGetAllocationProperties,
+    .ext_get_allocation_properties_size = trackingGetAllocationPropertiesSize,
+};
+
+static void free_ipc_cache_value(void *unused, void *ipc_cache_value) {
+    (void)unused;
+    if (ipc_cache_value) {
+        umf_ba_global_free(ipc_cache_value);
+    }
+}
 
 umf_result_t umfTrackingMemoryProviderCreate(
     umf_memory_provider_handle_t hUpstream, umf_memory_pool_handle_t hPool,
-    umf_memory_provider_handle_t *hTrackingProvider, bool upstreamDoesNotFree) {
+    umf_memory_provider_handle_t *hTrackingProvider) {
 
     umf_tracking_memory_provider_t params;
     params.hUpstream = hUpstream;
-    params.upstreamDoesNotFree = upstreamDoesNotFree;
     params.hTracker = TRACKER;
     if (!params.hTracker) {
         LOG_ERR("failed, TRACKER is NULL");
         return UMF_RESULT_ERROR_UNKNOWN;
     }
     params.pool = hPool;
-    params.ipcCache = critnib_new();
+    params.ipcCache = critnib_new(free_ipc_cache_value, NULL);
     if (!params.ipcCache) {
         LOG_ERR("failed to create IPC cache");
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
     params.hIpcMappedCache =
-        umfIpcHandleMappedCacheCreate(ipcMappedCacheEvictionCallback);
+        umfIpcOpenedCacheCreate(ipcOpenedCacheEvictionCallback);
 
     LOG_DEBUG("upstream=%p, tracker=%p, "
               "pool=%p, ipcCache=%p, hIpcMappedCache=%p",
@@ -816,43 +1411,90 @@ void umfTrackingMemoryProviderGetUpstreamProvider(
     *hUpstream = p->hUpstream;
 }
 
-umf_memory_tracker_handle_t umfMemoryTrackerCreate(void) {
+static void free_leaf(void *leaf_allocator, void *ptr) {
+    if (ptr) {
+#if !defined(NDEBUG) && defined(UMF_DEVELOPER_MODE)
+        tracker_alloc_info_t *value = (tracker_alloc_info_t *)ptr;
+        utils_atomic_store_release_u64(&value->is_freed, 0xDEADBEEF);
+#endif
+        umf_ba_free(leaf_allocator, ptr);
+    }
+}
+
+static void free_ipc_segment(void *ipc_info_allocator, void *ptr) {
+    if (ptr) {
+        umf_ba_free(ipc_info_allocator, ptr);
+    }
+}
+
+umf_result_t umfMemoryTrackerCreate(umf_memory_tracker_handle_t *handle_out) {
     umf_memory_tracker_handle_t handle =
         umf_ba_global_alloc(sizeof(struct umf_memory_tracker_t));
     if (!handle) {
-        return NULL;
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
+    umf_result_t ret = UMF_RESULT_SUCCESS;
+    memset(handle, 0, sizeof(struct umf_memory_tracker_t));
 
-    umf_ba_pool_t *tracker_allocator =
-        umf_ba_create(sizeof(struct tracker_value_t));
-    if (!tracker_allocator) {
+    umf_ba_pool_t *alloc_info_allocator =
+        umf_ba_create(sizeof(struct tracker_alloc_info_t));
+
+    if (!alloc_info_allocator) {
+        ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
         goto err_free_handle;
     }
 
-    handle->tracker_allocator = tracker_allocator;
+    handle->alloc_info_allocator = alloc_info_allocator;
 
     void *mutex_ptr = utils_mutex_init(&handle->splitMergeMutex);
     if (!mutex_ptr) {
-        goto err_destroy_tracker_allocator;
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+        goto err_destroy_alloc_info_allocator;
     }
 
-    handle->map = critnib_new();
-    if (!handle->map) {
-        goto err_destroy_mutex;
+    int i;
+    for (i = 0; i < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP; i++) {
+        handle->alloc_segments_map[i] =
+            critnib_new(free_leaf, alloc_info_allocator);
+        if (!handle->alloc_segments_map[i]) {
+            ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+            goto err_destroy_alloc_segments_map;
+        }
     }
 
-    LOG_DEBUG("tracker created, handle=%p, segment map=%p", (void *)handle,
-              (void *)handle->map);
+    handle->ipc_info_allocator =
+        umf_ba_create(sizeof(struct tracker_ipc_info_t));
+    if (!handle->ipc_info_allocator) {
+        ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        goto err_destroy_alloc_segments_map;
+    }
+
+    handle->ipc_segments_map =
+        critnib_new(free_ipc_segment, handle->ipc_info_allocator);
+    if (!handle->ipc_segments_map) {
+        ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        goto err_destroy_ipc_info_allocator;
+    }
 
-    return handle;
+    LOG_DEBUG("tracker created, handle=%p, alloc_segments_map=%p",
+              (void *)handle, (void *)handle->alloc_segments_map);
+    *handle_out = handle;
+    return ret;
 
-err_destroy_mutex:
+err_destroy_ipc_info_allocator:
+    umf_ba_destroy(handle->ipc_info_allocator);
+err_destroy_alloc_segments_map:
+    for (i = 0; i < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP; i++) {
+        if (handle->alloc_segments_map[i]) {
+            critnib_delete(handle->alloc_segments_map[i]);
+        }
+    }
     utils_mutex_destroy_not_free(&handle->splitMergeMutex);
-err_destroy_tracker_allocator:
-    umf_ba_destroy(tracker_allocator);
+err_destroy_alloc_info_allocator:
+    umf_ba_destroy(alloc_info_allocator);
 err_free_handle:
     umf_ba_global_free(handle);
-    return NULL;
+    return ret;
 }
 
 void umfMemoryTrackerDestroy(umf_memory_tracker_handle_t handle) {
@@ -867,15 +1509,48 @@ void umfMemoryTrackerDestroy(umf_memory_tracker_handle_t handle) {
         return;
     }
 
-    clear_tracker(handle);
+#ifndef NDEBUG
+    check_if_tracker_is_empty(handle, NULL);
+#endif /* NDEBUG */
 
     // We have to zero all inner pointers,
     // because the tracker handle can be copied
     // and used in many places.
-    critnib_delete(handle->map);
-    handle->map = NULL;
+    for (int i = 0; i < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP; i++) {
+        if (handle->alloc_segments_map[i]) {
+            critnib_delete(handle->alloc_segments_map[i]);
+            handle->alloc_segments_map[i] = NULL;
+        }
+    }
     utils_mutex_destroy_not_free(&handle->splitMergeMutex);
-    umf_ba_destroy(handle->tracker_allocator);
-    handle->tracker_allocator = NULL;
+    umf_ba_destroy(handle->alloc_info_allocator);
+    handle->alloc_info_allocator = NULL;
+    critnib_delete(handle->ipc_segments_map);
+    handle->ipc_segments_map = NULL;
+    umf_ba_destroy(handle->ipc_info_allocator);
+    handle->ipc_info_allocator = NULL;
     umf_ba_global_free(handle);
 }
+
+umf_result_t umfMemoryTrackerIterateAll(int (*func)(uintptr_t key, void *value,
+                                                    void *privdata),
+                                        void *privdata) {
+    if (UNLIKELY(TRACKER == NULL)) {
+        LOG_ERR("tracker does not exist");
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+
+    if (UNLIKELY(TRACKER->alloc_segments_map[0] == NULL)) {
+        LOG_ERR("tracker's alloc_segments_map does not exist");
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+
+    for (int level = 0; level < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP; level++) {
+        critnib *alloc_segment = TRACKER->alloc_segments_map[level];
+        LOG_DEBUG("iterating tracker's %d segment: %p", level,
+                  (void *)alloc_segment);
+        critnib_iter_all(alloc_segment, func, privdata);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
diff --git a/src/provider/provider_tracking.h b/src/provider/provider_tracking.h
index 9444ee4757..254bbf6786 100644
--- a/src/provider/provider_tracking.h
+++ b/src/provider/provider_tracking.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -20,46 +20,60 @@
 
 #include "base_alloc.h"
 #include "critnib.h"
+#include "memory_properties_internal.h"
 #include "utils_concurrency.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-struct umf_memory_tracker_t {
-    umf_ba_pool_t *tracker_allocator;
-    critnib *map;
-    utils_mutex_t splitMergeMutex;
-};
-
+struct umf_memory_tracker_t;
 typedef struct umf_memory_tracker_t *umf_memory_tracker_handle_t;
 
 extern umf_memory_tracker_handle_t TRACKER;
 
-umf_memory_tracker_handle_t umfMemoryTrackerCreate(void);
+umf_result_t umfMemoryTrackerCreate(umf_memory_tracker_handle_t *handle);
 void umfMemoryTrackerDestroy(umf_memory_tracker_handle_t handle);
 
-umf_memory_pool_handle_t umfMemoryTrackerGetPool(const void *ptr);
+typedef struct tracker_alloc_info_t {
+    umf_memory_properties_t props;
+
+    // number of overlapping memory regions in the next level of map falling
+    // within the current range
+    size_t n_children;
+#if !defined(NDEBUG) && defined(UMF_DEVELOPER_MODE)
+    uint64_t is_freed;
+#endif
+} tracker_alloc_info_t;
+
+umf_result_t umfMemoryTrackerGetAllocInfo(const void *ptr,
+                                          tracker_alloc_info_t **info);
+
+typedef struct umf_ipc_info_t {
+    umf_memory_properties_handle_t props;
 
-typedef struct umf_alloc_info_t {
     void *base;
     size_t baseSize;
-    umf_memory_pool_handle_t pool;
-} umf_alloc_info_t;
+    umf_memory_provider_handle_t provider;
+} umf_ipc_info_t;
 
-umf_result_t umfMemoryTrackerGetAllocInfo(const void *ptr,
-                                          umf_alloc_info_t *pAllocInfo);
+umf_result_t umfMemoryTrackerGetIpcInfo(const void *ptr,
+                                        umf_ipc_info_t *pIpcInfo);
 
 // Creates a memory provider that tracks each allocation/deallocation through umf_memory_tracker_handle_t and
 // forwards all requests to hUpstream memory Provider. hUpstream lifetime should be managed by the user of this function.
 umf_result_t umfTrackingMemoryProviderCreate(
     umf_memory_provider_handle_t hUpstream, umf_memory_pool_handle_t hPool,
-    umf_memory_provider_handle_t *hTrackingProvider, bool upstreamDoesNotFree);
+    umf_memory_provider_handle_t *hTrackingProvider);
 
 void umfTrackingMemoryProviderGetUpstreamProvider(
     umf_memory_provider_handle_t hTrackingProvider,
     umf_memory_provider_handle_t *hUpstream);
 
+umf_result_t umfMemoryTrackerIterateAll(int (*func)(uintptr_t key, void *value,
+                                                    void *privdata),
+                                        void *privdata);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/proxy_lib/CMakeLists.txt b/src/proxy_lib/CMakeLists.txt
index d6b07902df..494ef1ef23 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/proxy_lib/proxy_lib.c b/src/proxy_lib/proxy_lib.c
index f8bae304d8..690cdb63fa 100644
--- a/src/proxy_lib/proxy_lib.c
+++ b/src/proxy_lib/proxy_lib.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -128,13 +128,6 @@ static umf_memory_pool_handle_t Proxy_pool = NULL;
 // it protects us from recursion in umfPool*()
 static __TLS int was_called_from_umfPool = 0;
 
-// This WA for the issue:
-// https://github.com/oneapi-src/unified-memory-framework/issues/894
-// It protects us from a recursion in malloc_usable_size()
-// when the JEMALLOC proxy_lib_pool is used.
-// TODO remove this WA when the issue is fixed.
-static __TLS int was_called_from_malloc_usable_size = 0;
-
 /*****************************************************************************/
 /*** The constructor and destructor of the proxy library *********************/
 /*****************************************************************************/
@@ -145,7 +138,7 @@ static size_t get_size_threshold(void) {
     LOG_DEBUG("UMF_PROXY[size.threshold] = %s", str_threshold);
     long threshold = utils_get_size_threshold(str_threshold);
     if (threshold < 0) {
-        LOG_ERR("incorrect size threshold: %s", str_threshold);
+        LOG_FATAL("incorrect size threshold: %s", str_threshold);
         exit(-1);
     }
 
@@ -170,6 +163,8 @@ static int get_system_allocator_symbols(void) {
         return 0;
     }
 
+    LOG_FATAL("Required system allocator's symbols not found.");
+
     return -1;
 }
 #endif /* _WIN32 */
@@ -181,7 +176,7 @@ void proxy_lib_create_common(void) {
 
     umf_result = umfOsMemoryProviderParamsCreate(&os_params);
     if (umf_result != UMF_RESULT_SUCCESS) {
-        LOG_ERR("creating OS memory provider params failed");
+        LOG_FATAL("creating OS memory provider params failed");
         exit(-1);
     }
 
@@ -189,7 +184,7 @@ void proxy_lib_create_common(void) {
     size_t _threshold = get_size_threshold();
     if (_threshold > 0) {
         if (get_system_allocator_symbols()) {
-            LOG_ERR("initialization of the system allocator failed!");
+            LOG_FATAL("initialization of the system allocator failed!");
             exit(-1);
         }
 
@@ -204,12 +199,12 @@ void proxy_lib_create_common(void) {
         umf_result = umfOsMemoryProviderParamsSetVisibility(os_params,
                                                             UMF_MEM_MAP_SHARED);
         if (umf_result != UMF_RESULT_SUCCESS) {
-            LOG_ERR("setting visibility mode failed");
+            LOG_FATAL("setting visibility mode failed");
             exit(-1);
         }
         umf_result = umfOsMemoryProviderParamsSetShmName(os_params, NULL);
         if (umf_result != UMF_RESULT_SUCCESS) {
-            LOG_ERR("setting shared memory name failed");
+            LOG_FATAL("setting shared memory name failed");
             exit(-1);
         }
     } else if (utils_env_var_has_str("UMF_PROXY",
@@ -217,7 +212,7 @@ void proxy_lib_create_common(void) {
         umf_result = umfOsMemoryProviderParamsSetVisibility(os_params,
                                                             UMF_MEM_MAP_SHARED);
         if (umf_result != UMF_RESULT_SUCCESS) {
-            LOG_ERR("setting visibility mode failed");
+            LOG_FATAL("setting visibility mode failed");
             exit(-1);
         }
 
@@ -226,7 +221,7 @@ void proxy_lib_create_common(void) {
         sprintf(shm_name, "umf_proxy_lib_shm_pid_%i", utils_getpid());
         umf_result = umfOsMemoryProviderParamsSetShmName(os_params, shm_name);
         if (umf_result != UMF_RESULT_SUCCESS) {
-            LOG_ERR("setting shared memory name failed");
+            LOG_FATAL("setting shared memory name failed");
             exit(-1);
         }
 
@@ -240,14 +235,14 @@ void proxy_lib_create_common(void) {
                                          &OS_memory_provider);
     umfOsMemoryProviderParamsDestroy(os_params);
     if (umf_result != UMF_RESULT_SUCCESS) {
-        LOG_ERR("creating OS memory provider failed");
+        LOG_FATAL("creating OS memory provider failed");
         exit(-1);
     }
 
     umf_result = umfPoolCreate(umfPoolManagerOps(), OS_memory_provider, NULL, 0,
                                &Proxy_pool);
     if (umf_result != UMF_RESULT_SUCCESS) {
-        LOG_ERR("creating UMF pool manager failed");
+        LOG_FATAL("creating UMF pool manager failed");
         exit(-1);
     }
 
@@ -308,7 +303,9 @@ static inline void *ba_generic_realloc(umf_ba_linear_pool_t *pool, void *ptr,
 /*** The "LEAK" linear base allocator functions ******************************/
 /*****************************************************************************/
 
-static void ba_leak_create(void) { Base_alloc_leak = umf_ba_linear_create(0); }
+static void ba_leak_create(void) {
+    Base_alloc_leak = umf_ba_linear_create(4 * 1024 * 1024);
+}
 
 // it does not implement destroy(), because we cannot destroy non-freed memory
 
@@ -394,8 +391,10 @@ void free(void *ptr) {
     if (ba_leak_free(ptr) == 0) {
         return;
     }
+    umf_memory_pool_handle_t pool;
 
-    if (Proxy_pool && (umfPoolByPtr(ptr) == Proxy_pool)) {
+    if (Proxy_pool && (umfPoolByPtr(ptr, &pool) == UMF_RESULT_SUCCESS &&
+                       pool == Proxy_pool)) {
         if (umfPoolFree(Proxy_pool, ptr) != UMF_RESULT_SUCCESS) {
             LOG_ERR("umfPoolFree() failed");
         }
@@ -428,8 +427,10 @@ void *realloc(void *ptr, size_t size) {
     if (leak_pool_contains_pointer) {
         return ba_leak_realloc(ptr, size, leak_pool_contains_pointer);
     }
+    umf_memory_pool_handle_t pool;
 
-    if (Proxy_pool && (umfPoolByPtr(ptr) == Proxy_pool)) {
+    if (Proxy_pool && (umfPoolByPtr(ptr, &pool) == UMF_RESULT_SUCCESS &&
+                       pool == Proxy_pool)) {
         was_called_from_umfPool = 1;
         void *new_ptr = umfPoolRealloc(Proxy_pool, ptr, size);
         was_called_from_umfPool = 0;
@@ -477,19 +478,19 @@ size_t malloc_usable_size(void *ptr) {
     if (ba_leak_pool_contains_pointer(ptr)) {
         return 0; // unsupported in case of the ba_leak allocator
     }
+    umf_memory_pool_handle_t pool;
 
-    if (!was_called_from_malloc_usable_size && Proxy_pool &&
-        (umfPoolByPtr(ptr) == Proxy_pool)) {
-        was_called_from_malloc_usable_size = 1;
+    if (Proxy_pool && (umfPoolByPtr(ptr, &pool) == UMF_RESULT_SUCCESS &&
+                       pool == Proxy_pool)) {
         was_called_from_umfPool = 1;
-        size_t size = umfPoolMallocUsableSize(Proxy_pool, ptr);
+        size_t size = 0;
+        umfPoolMallocUsableSize(Proxy_pool, ptr, &size);
         was_called_from_umfPool = 0;
-        was_called_from_malloc_usable_size = 0;
         return size;
     }
 
 #ifndef _WIN32
-    if (!was_called_from_malloc_usable_size && Size_threshold_value) {
+    if (Size_threshold_value) {
         return System_malloc_usable_size(ptr);
     }
 #endif /* _WIN32 */
diff --git a/src/proxy_lib/proxy_lib.rc.in b/src/proxy_lib/proxy_lib.rc.in
index dce151ec3e..a3eff71dea 100644
--- a/src/proxy_lib/proxy_lib.rc.in
+++ b/src/proxy_lib/proxy_lib.rc.in
@@ -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
@@ -10,6 +10,8 @@
 
 #define UMF_VERNUMBERS @PROJECT_VERSION_MAJOR@,@PROJECT_VERSION_MINOR@,@PROJECT_VERSION_PATCH@,@UMF_VERSION_REVISION@
 #define _UMF_VERSION "@UMF_VERSION@"
+// Store our CMake vars in the "FileDescription" block, as the custom fields require special parsing.
+#define _UMF_CMAKE_VARS "@UMF_ALL_CMAKE_VARIABLES@"
 
 #ifdef _DEBUG
 #define VERSION_DEBUG VS_FF_DEBUG
@@ -49,9 +51,9 @@ BEGIN
         BLOCK "040904b0" // U.S. English, Unicode (0x04b0 == 1200)
         BEGIN
             VALUE "CompanyName", "Intel Corporation\0"
-            VALUE "FileDescription", "Unified Memory Framework (UMF) proxy library\0"
+            VALUE "FileDescription", "Unified Memory Framework (UMF) proxy library (build options: " _UMF_CMAKE_VARS ")\0"
             VALUE "FileVersion", _UMF_VERSION "\0"
-            VALUE "LegalCopyright", "Copyright 2024, Intel Corporation. All rights reserved.\0"
+            VALUE "LegalCopyright", "Copyright 2024-2025, Intel Corporation. All rights reserved.\0"
             VALUE "LegalTrademarks", "\0"
             VALUE "OriginalFilename", "umf_proxy.dll\0"
             VALUE "ProductName", "Unified Memory Framework (UMF)\0"
diff --git a/src/topology.c b/src/topology.c
index eab7992ced..da7666f87c 100644
--- a/src/topology.c
+++ b/src/topology.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -13,7 +13,9 @@
 #include "utils_log.h"
 
 static hwloc_topology_t topology = NULL;
+static hwloc_topology_t topology_reduced = NULL;
 static UTIL_ONCE_FLAG topology_initialized = UTIL_ONCE_FLAG_INIT;
+static UTIL_ONCE_FLAG topology_reduced_initialized = UTIL_ONCE_FLAG_INIT;
 
 void umfDestroyTopology(void) {
     if (topology) {
@@ -24,22 +26,55 @@ void umfDestroyTopology(void) {
         memcpy(&topology_initialized, &is_initialized,
                sizeof(topology_initialized));
     }
+    if (topology_reduced) {
+        hwloc_topology_destroy(topology_reduced);
+
+        // portable version of "topology_initialized = UTIL_ONCE_FLAG_INIT;"
+        static UTIL_ONCE_FLAG is_initialized = UTIL_ONCE_FLAG_INIT;
+        memcpy(&topology_reduced_initialized, &is_initialized,
+               sizeof(topology_reduced_initialized));
+    }
 }
 
-static void umfCreateTopology(void) {
-    if (hwloc_topology_init(&topology)) {
+static void umfCreateTopologyHelper(bool reduced,
+                                    hwloc_topology_t *topology_ptr) {
+    if (hwloc_topology_init(topology_ptr)) {
         LOG_ERR("Failed to initialize topology");
-        topology = NULL;
+        *topology_ptr = NULL;
         return;
     }
 
-    if (hwloc_topology_load(topology)) {
+    if (reduced) {
+        // Set the topology to only include NUMA nodes and memory
+        // to improve performance of the topology load on large systems
+        if (hwloc_topology_set_all_types_filter(*topology_ptr,
+                                                HWLOC_TYPE_FILTER_KEEP_NONE)) {
+            LOG_ERR("Failed to set topology filter");
+            hwloc_topology_destroy(*topology_ptr);
+            *topology_ptr = NULL;
+            return;
+        }
+    }
+    if (hwloc_topology_load(*topology_ptr)) {
         LOG_ERR("Failed to initialize topology");
-        hwloc_topology_destroy(topology);
-        topology = NULL;
+        hwloc_topology_destroy(*topology_ptr);
+        *topology_ptr = NULL;
     }
 }
 
+static void umfCreateTopology(void) {
+    umfCreateTopologyHelper(false, &topology);
+}
+
+static void umfCreateTopologyReduced(void) {
+    umfCreateTopologyHelper(true, &topology_reduced);
+}
+
+hwloc_topology_t umfGetTopologyReduced(void) {
+    utils_init_once(&topology_reduced_initialized, umfCreateTopologyReduced);
+    return topology_reduced;
+}
+
 hwloc_topology_t umfGetTopology(void) {
     utils_init_once(&topology_initialized, umfCreateTopology);
     return topology;
diff --git a/src/topology.h b/src/topology.h
index c20defda7a..5d5982a0ca 100644
--- a/src/topology.h
+++ b/src/topology.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -17,6 +17,7 @@ extern "C" {
 #endif
 
 hwloc_topology_t umfGetTopology(void);
+hwloc_topology_t umfGetTopologyReduced(void);
 void umfDestroyTopology(void);
 
 #ifdef __cplusplus
diff --git a/src/utils/CMakeLists.txt b/src/utils/CMakeLists.txt
index a0bff39fd8..e26017e79d 100644
--- a/src/utils/CMakeLists.txt
+++ b/src/utils/CMakeLists.txt
@@ -1,37 +1,17 @@
-# 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)
 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
-                            utils_posix_math.c)
-
+set(UMF_UTILS_SOURCES_COMMON utils_common.c utils_log.c utils_load_library.c
+                             ../ctl/ctl.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 utils_windows_math.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()
+                              utils_windows_concurrency.c)
 
 if(LINUX OR MACOSX)
     set(UMF_UTILS_SOURCES ${UMF_UTILS_SOURCES_COMMON}
@@ -49,24 +29,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/src/utils/utils_assert.h b/src/utils/utils_assert.h
index 437eef9321..319b8e68c9 100644
--- a/src/utils/utils_assert.h
+++ b/src/utils/utils_assert.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -10,11 +10,13 @@
 #ifndef UMF_ASSERT_H
 #define UMF_ASSERT_H 1
 
-#include "utils_log.h"
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 
+#include "utils_common.h"
+#include "utils_log.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -50,7 +52,7 @@ extern "C" {
 
 #define UMF_CHECK(condition, errorStatus)                                      \
     do {                                                                       \
-        if (!(condition)) {                                                    \
+        if (UNLIKELY(!(condition))) {                                          \
             LOG_FATAL("UMF check failed: " #condition " in %s", __func__);     \
             return errorStatus;                                                \
         }                                                                      \
diff --git a/src/utils/utils_common.c b/src/utils/utils_common.c
index eaf5420fc6..225c02d2c1 100644
--- a/src/utils/utils_common.c
+++ b/src/utils/utils_common.c
@@ -128,3 +128,6 @@ umf_result_t utils_translate_flags(unsigned in_flags, unsigned max,
     *out_flags = out_f;
     return UMF_RESULT_SUCCESS;
 }
+
+size_t utils_max(size_t a, size_t b) { return a > b ? a : b; }
+size_t utils_min(size_t a, size_t b) { return a < b ? a : b; }
diff --git a/src/utils/utils_common.h b/src/utils/utils_common.h
index 9ef2b3cf13..17dd006ad6 100644
--- a/src/utils/utils_common.h
+++ b/src/utils/utils_common.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 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
@@ -38,6 +38,8 @@ typedef enum umf_purge_advise_t {
         expression;                                                            \
     } while (0)
 
+#define IS_POWER_OF_2(value) ((value) != 0 && ((value) & ((value)-1)) == 0)
+
 #define IS_ALIGNED(value, align)                                               \
     ((align == 0 || (((value) & ((align)-1)) == 0)))
 #define IS_NOT_ALIGNED(value, align)                                           \
@@ -51,18 +53,21 @@ typedef enum umf_purge_advise_t {
 #define ASSERT_IS_ALIGNED(value, align)                                        \
     DO_WHILE_EXPRS(assert(IS_ALIGNED(value, align)))
 
-#define VALGRIND_ANNOTATE_NEW_MEMORY(p, s) DO_WHILE_EMPTY
-#define VALGRIND_HG_DRD_DISABLE_CHECKING(p, s) DO_WHILE_EMPTY
-
 #ifdef _WIN32 /* Windows */
 
 #define __TLS __declspec(thread)
 
+#define LIKELY(x) (x)
+#define UNLIKELY(x) (x)
+
 #else /* Linux */
 
 #define __TLS __thread
 
-#endif /* _WIN32 */
+#define LIKELY(x) __builtin_expect(!!(x), 1)
+#define UNLIKELY(x) __builtin_expect(!!(x), 0)
+
+#endif /* !_WIN32 */
 
 // get the address of the given string in the environment variable (or NULL)
 char *utils_env_var_get_str(const char *envvar, const char *str);
@@ -116,6 +121,9 @@ int utils_getpid(void);
 // get the current thread ID
 int utils_gettid(void);
 
+// get the number of CPU cores
+unsigned utils_get_num_cores(void);
+
 // close file descriptor
 int utils_close_fd(int fd);
 
@@ -176,6 +184,10 @@ int utils_fallocate(int fd, long offset, long len);
 
 long utils_get_size_threshold(char *str_threshold);
 
+size_t utils_max(size_t a, size_t b);
+
+size_t utils_min(size_t a, size_t b);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/utils/utils_concurrency.h b/src/utils/utils_concurrency.h
index 155184cc44..74c7fc8ae1 100644
--- a/src/utils/utils_concurrency.h
+++ b/src/utils/utils_concurrency.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -10,7 +10,10 @@
 #ifndef UMF_UTILS_CONCURRENCY_H
 #define UMF_UTILS_CONCURRENCY_H 1
 
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdio.h>
+#include <stdlib.h>
 
 #ifdef _WIN32
 #include <windows.h>
@@ -18,7 +21,7 @@
 #include "utils_windows_intrin.h"
 
 #pragma intrinsic(_BitScanForward64)
-#else
+#else /* !_WIN32 */
 #include <pthread.h>
 
 #ifndef __cplusplus
@@ -26,10 +29,19 @@
 #else /* __cplusplus */
 #include <atomic>
 #define _Atomic(X) std::atomic<X>
+
+// TODO remove cpp code from this file
+using std::memory_order_acq_rel;
+using std::memory_order_acquire;
+using std::memory_order_relaxed;
+using std::memory_order_release;
+
 #endif /* __cplusplus */
 
-#endif /* _WIN32 */
+#endif /* !_WIN32 */
 
+#include "utils_assert.h"
+#include "utils_common.h"
 #include "utils_sanitizers.h"
 
 #ifdef __cplusplus
@@ -45,11 +57,27 @@ typedef struct utils_mutex_t {
 } utils_mutex_t;
 
 size_t utils_mutex_get_size(void);
-utils_mutex_t *utils_mutex_init(void *ptr);
+utils_mutex_t *utils_mutex_init(utils_mutex_t *ptr);
 void utils_mutex_destroy_not_free(utils_mutex_t *m);
 int utils_mutex_lock(utils_mutex_t *mutex);
 int utils_mutex_unlock(utils_mutex_t *mutex);
 
+typedef struct utils_rwlock_t {
+#ifdef _WIN32
+    // Slim Read/Wrtiter lock
+    SRWLOCK lock;
+#else
+    pthread_rwlock_t rwlock;
+#endif
+} utils_rwlock_t;
+
+int utils_rwlock_init(utils_rwlock_t *ptr);
+void utils_rwlock_destroy_not_free(utils_rwlock_t *rwlock);
+void utils_read_lock(utils_rwlock_t *rwlock);
+void utils_write_lock(utils_rwlock_t *rwlock);
+void utils_read_unlock(utils_rwlock_t *rwlock);
+void utils_write_unlock(utils_rwlock_t *rwlock);
+
 #if defined(_WIN32)
 #define UTIL_ONCE_FLAG INIT_ONCE
 #define UTIL_ONCE_FLAG_INIT INIT_ONCE_STATIC_INIT
@@ -61,54 +89,216 @@ int utils_mutex_unlock(utils_mutex_t *mutex);
 void utils_init_once(UTIL_ONCE_FLAG *flag, void (*onceCb)(void));
 
 #if defined(_WIN32)
-static __inline unsigned char utils_lssb_index(long long value) {
-    unsigned long ret;
-    _BitScanForward64(&ret, value);
-    return (unsigned char)ret;
-}
-static __inline unsigned char utils_mssb_index(long long value) {
-    unsigned long ret;
-    _BitScanReverse64(&ret, value);
-    return (unsigned char)ret;
+
+// There is no good way to do atomic_load on windows...
+static inline void utils_atomic_load_acquire_u64(uint64_t *ptr, uint64_t *out) {
+    // NOTE: Windows cl complains about direct accessing 'ptr' which is next
+    // accessed using Interlocked* functions (warning 28112 - disabled)
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+
+    // On Windows, there is no equivalent to __atomic_load, so we use cmpxchg
+    // with 0, 0 here. This will always return the value under the pointer
+    // without writing anything.
+    LONG64 ret = InterlockedCompareExchange64((LONG64 volatile *)ptr, 0, 0);
+    *out = *(uint64_t *)&ret;
 }
 
 // There is no good way to do atomic_load on windows...
-#define utils_atomic_load_acquire(object, dest)                                \
-    do {                                                                       \
-        *(LONG64 *)dest =                                                      \
-            InterlockedOr64Acquire((LONG64 volatile *)object, 0);              \
-    } while (0)
-
-#define utils_atomic_store_release(object, desired)                            \
-    InterlockedExchange64((LONG64 volatile *)object, (LONG64)desired)
-#define utils_atomic_increment(object)                                         \
-    InterlockedIncrement64((LONG64 volatile *)object)
-#define utils_atomic_decrement(object)                                         \
-    InterlockedDecrement64((LONG64 volatile *)object)
-#define utils_fetch_and_add64(ptr, value)                                      \
-    InterlockedExchangeAdd64((LONG64 *)(ptr), value)
-#else
-#define utils_lssb_index(x) ((unsigned char)__builtin_ctzll(x))
-#define utils_mssb_index(x) ((unsigned char)(63 - __builtin_clzll(x)))
-#define utils_atomic_load_acquire(object, dest)                                \
-    do {                                                                       \
-        utils_annotate_acquire((void *)object);                                \
-        __atomic_load(object, dest, memory_order_acquire);                     \
-    } while (0)
-
-#define utils_atomic_store_release(object, desired)                            \
-    do {                                                                       \
-        __atomic_store_n(object, desired, memory_order_release);               \
-        utils_annotate_release((void *)object);                                \
-    } while (0)
-
-#define utils_atomic_increment(object)                                         \
-    __atomic_add_fetch(object, 1, __ATOMIC_ACQ_REL)
-#define utils_atomic_decrement(object)                                         \
-    __atomic_sub_fetch(object, 1, __ATOMIC_ACQ_REL)
-#define utils_fetch_and_add64 __sync_fetch_and_add
+static inline void utils_atomic_load_acquire_u8(uint8_t *ptr, uint8_t *out) {
+    // On Windows, there is no equivalent to __atomic_load, so we use cmpxchg
+    // with 0, 0 here. This will always return the value under the pointer
+    // without writing anything.
+    char ret = _InterlockedCompareExchange8((char volatile *)ptr, 0, 0);
+    *out = *(uint8_t *)&ret;
+}
 
-#endif
+static inline void utils_atomic_load_acquire_ptr(void **ptr, void **out) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    uintptr_t ret = (uintptr_t)InterlockedCompareExchangePointer(ptr, 0, 0);
+    *(uintptr_t *)out = ret;
+}
+
+static inline void utils_atomic_store_release_u64(uint64_t *ptr, uint64_t val) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    InterlockedExchange64((LONG64 volatile *)ptr, val);
+}
+
+static inline void utils_atomic_store_release_u8(uint8_t *ptr, uint8_t val) {
+    InterlockedExchange8((CHAR volatile *)ptr, val);
+}
+
+static inline void utils_atomic_store_release_ptr(void **ptr, void *val) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    InterlockedExchangePointer(ptr, val);
+}
+
+static inline uint64_t utils_atomic_increment_u64(uint64_t *ptr) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    // return incremented value
+    return InterlockedIncrement64((LONG64 volatile *)ptr);
+}
+
+static inline uint64_t utils_atomic_decrement_u64(uint64_t *ptr) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    // return decremented value
+    return InterlockedDecrement64((LONG64 volatile *)ptr);
+}
+
+static inline uint64_t utils_fetch_and_add_u64(uint64_t *ptr, uint64_t val) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    // return the value that had previously been in *ptr
+    return InterlockedExchangeAdd64((LONG64 volatile *)(ptr), val);
+}
+
+static inline uint64_t utils_fetch_and_sub_u64(uint64_t *ptr, uint64_t val) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    // return the value that had previously been in *ptr
+    // NOTE: on Windows there is no *Sub* version of InterlockedExchange
+    return InterlockedExchangeAdd64((LONG64 volatile *)(ptr), -(LONG64)val);
+}
+
+static inline bool utils_compare_exchange_u64(uint64_t *ptr, uint64_t *expected,
+                                              uint64_t *desired) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    LONG64 out = InterlockedCompareExchange64(
+        (LONG64 volatile *)ptr, *(LONG64 *)desired, *(LONG64 *)expected);
+    if (out == *(LONG64 *)expected) {
+        return true;
+    }
+
+    // else
+    *expected = out;
+    return false;
+}
+
+static inline bool utils_compare_exchange_u8(uint8_t *ptr, uint8_t *expected,
+                                             uint8_t *desired) {
+    char out = _InterlockedCompareExchange8(
+        (char volatile *)ptr, *(char *)desired, *(char *)expected);
+    if (out == *(char *)expected) {
+        return true;
+    }
+
+    // else
+    *expected = out;
+    return false;
+}
+
+#else // !defined(_WIN32)
+
+static inline void utils_atomic_load_acquire_u64(uint64_t *ptr, uint64_t *out) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    ASSERT_IS_ALIGNED((uintptr_t)out, 8);
+    __atomic_load(ptr, out, memory_order_acquire);
+    utils_annotate_acquire(ptr);
+}
+
+static inline void utils_atomic_load_acquire_u8(uint8_t *ptr, uint8_t *out) {
+    __atomic_load(ptr, out, memory_order_acquire);
+    utils_annotate_acquire(ptr);
+}
+
+static inline void utils_atomic_load_acquire_ptr(void **ptr, void **out) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    ASSERT_IS_ALIGNED((uintptr_t)out, 8);
+    __atomic_load((uintptr_t *)ptr, (uintptr_t *)out, memory_order_acquire);
+    utils_annotate_acquire(ptr);
+}
+
+static inline void utils_atomic_store_release_u64(uint64_t *ptr, uint64_t val) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    utils_annotate_release(ptr);
+    __atomic_store_n(ptr, val, memory_order_release);
+}
+
+static inline void utils_atomic_store_release_u8(uint8_t *ptr, uint8_t val) {
+    utils_annotate_release(ptr);
+    __atomic_store_n(ptr, val, memory_order_release);
+}
+
+static inline void utils_atomic_store_release_ptr(void **ptr, void *val) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    utils_annotate_release(ptr);
+    __atomic_store_n((uintptr_t *)ptr, (uintptr_t)val, memory_order_release);
+}
+
+static inline uint64_t utils_atomic_increment_u64(uint64_t *val) {
+    ASSERT_IS_ALIGNED((uintptr_t)val, 8);
+    // return incremented value
+    return __atomic_add_fetch(val, 1, memory_order_acq_rel);
+}
+
+static inline uint64_t utils_atomic_decrement_u64(uint64_t *val) {
+    ASSERT_IS_ALIGNED((uintptr_t)val, 8);
+    // return decremented value
+    return __atomic_sub_fetch(val, 1, memory_order_acq_rel);
+}
+
+static inline uint64_t utils_fetch_and_add_u64(uint64_t *ptr, uint64_t val) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    // return the value that had previously been in *ptr
+    return __atomic_fetch_add(ptr, val, memory_order_acq_rel);
+}
+
+static inline uint64_t utils_fetch_and_sub_u64(uint64_t *ptr, uint64_t val) {
+    // return the value that had previously been in *ptr
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    return __atomic_fetch_sub(ptr, val, memory_order_acq_rel);
+}
+
+static inline bool utils_compare_exchange_u64(uint64_t *ptr, uint64_t *expected,
+                                              uint64_t *desired) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    return __atomic_compare_exchange(ptr, expected, desired, 0 /* strong */,
+                                     memory_order_acq_rel,
+                                     memory_order_relaxed);
+}
+
+static inline bool utils_compare_exchange_u8(uint8_t *ptr, uint8_t *expected,
+                                             uint8_t *desired) {
+    return __atomic_compare_exchange(ptr, expected, desired, 0 /* strong */,
+                                     memory_order_acq_rel,
+                                     memory_order_relaxed);
+}
+
+#endif // !defined(_WIN32)
+
+static inline void utils_atomic_load_acquire_size_t(size_t *ptr, size_t *out) {
+    COMPILE_ERROR_ON(sizeof(size_t) != sizeof(uint64_t));
+    utils_atomic_load_acquire_u64((uint64_t *)ptr, (uint64_t *)out);
+}
+
+static inline void utils_atomic_store_release_size_t(size_t *ptr, size_t val) {
+    COMPILE_ERROR_ON(sizeof(size_t) != sizeof(uint64_t));
+    utils_atomic_store_release_u64((uint64_t *)ptr, (uint64_t)val);
+}
+
+static inline size_t utils_fetch_and_add_size_t(size_t *ptr, size_t val) {
+    COMPILE_ERROR_ON(sizeof(size_t) != sizeof(uint64_t));
+    return utils_fetch_and_add_u64((uint64_t *)ptr, (uint64_t)val);
+}
+
+static inline size_t utils_fetch_and_sub_size_t(size_t *ptr, size_t val) {
+    COMPILE_ERROR_ON(sizeof(size_t) != sizeof(uint64_t));
+    return utils_fetch_and_sub_u64((uint64_t *)ptr, (uint64_t)val);
+}
+
+static inline bool utils_compare_exchange_size_t(size_t *ptr, size_t *expected,
+                                                 size_t *desired) {
+    COMPILE_ERROR_ON(sizeof(size_t) != sizeof(uint64_t));
+    return utils_compare_exchange_u64((uint64_t *)ptr, (uint64_t *)expected,
+                                      (uint64_t *)desired);
+}
+
+static inline size_t utils_atomic_increment_size_t(size_t *val) {
+    COMPILE_ERROR_ON(sizeof(size_t) != sizeof(uint64_t));
+    return utils_atomic_increment_u64((uint64_t *)val);
+}
+
+static inline size_t utils_atomic_decrement_size_t(size_t *val) {
+    COMPILE_ERROR_ON(sizeof(size_t) != sizeof(uint64_t));
+    return utils_atomic_decrement_u64((uint64_t *)val);
+}
 
 #ifdef __cplusplus
 }
diff --git a/src/utils/utils_level_zero.cpp b/src/utils/utils_level_zero.cpp
index 833047dd79..ee7aa85eae 100644
--- a/src/utils/utils_level_zero.cpp
+++ b/src/utils/utils_level_zero.cpp
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -13,8 +13,6 @@
 #include "utils_concurrency.h"
 #include "utils_load_library.h"
 
-#include "ze_api.h"
-
 struct libze_ops {
     ze_result_t (*zeInit)(ze_init_flags_t flags);
     ze_result_t (*zeDriverGet)(uint32_t *pCount, ze_driver_handle_t *phDrivers);
@@ -60,6 +58,9 @@ struct libze_ops {
                                     const ze_device_mem_alloc_desc_t *, size_t,
                                     size_t, ze_device_handle_t, void **);
     ze_result_t (*zeMemFree)(ze_context_handle_t, void *);
+    ze_result_t (*zeDeviceGetMemoryProperties)(
+        ze_device_handle_t hDevice, uint32_t *pCount,
+        ze_device_memory_properties_t *pMemProperties);
 } libze_ops;
 
 #if USE_DLOPEN
@@ -125,6 +126,9 @@ struct DlHandleCloser {
             libze_ops.zeMemFree = [](auto... args) {
                 return noop_stub(args...);
             };
+            libze_ops.zeDeviceGetMemoryProperties = [](auto... args) {
+                return noop_stub(args...);
+            };
             utils_close_library(dlHandle);
         }
     }
@@ -135,13 +139,18 @@ int InitLevelZeroOps() {
 #ifdef _WIN32
     const char *lib_name = "ze_loader.dll";
 #else
-    const char *lib_name = "libze_loader.so";
+    const char *lib_name = "libze_loader.so.1";
 #endif
     // Load Level Zero symbols
-    // NOTE that we use UMF_UTIL_OPEN_LIBRARY_GLOBAL which add all loaded symbols to the
+#if OPEN_ZE_LIBRARY_GLOBAL
+    // NOTE UMF_UTIL_OPEN_LIBRARY_GLOBAL adds all loaded symbols to the
     // global symbol table.
+    int open_flags = UMF_UTIL_OPEN_LIBRARY_GLOBAL;
+#else
+    int open_flags = 0;
+#endif
     zeDlHandle = std::unique_ptr<void, DlHandleCloser>(
-        utils_open_library(lib_name, UMF_UTIL_OPEN_LIBRARY_GLOBAL));
+        utils_open_library(lib_name, open_flags));
     *(void **)&libze_ops.zeInit =
         utils_get_symbol_addr(zeDlHandle.get(), "zeInit", lib_name);
     if (libze_ops.zeInit == nullptr) {
@@ -265,6 +274,13 @@ int InitLevelZeroOps() {
         fprintf(stderr, "zeMemFree symbol not found in %s\n", lib_name);
         return -1;
     }
+    *(void **)&libze_ops.zeDeviceGetMemoryProperties = utils_get_symbol_addr(
+        zeDlHandle.get(), "zeDeviceGetMemoryProperties", lib_name);
+    if (libze_ops.zeDeviceGetMemoryProperties == nullptr) {
+        fprintf(stderr, "zeDeviceGetMemoryProperties symbol not found in %s\n",
+                lib_name);
+        return -1;
+    }
 
     return 0;
 }
@@ -292,6 +308,7 @@ int InitLevelZeroOps() {
     libze_ops.zeMemGetAllocProperties = zeMemGetAllocProperties;
     libze_ops.zeMemAllocDevice = zeMemAllocDevice;
     libze_ops.zeMemFree = zeMemFree;
+    libze_ops.zeDeviceGetMemoryProperties = zeDeviceGetMemoryProperties;
 
     return 0;
 }
@@ -330,12 +347,6 @@ int utils_ze_get_drivers(uint32_t *drivers_num_,
     ze_driver_handle_t *drivers = NULL;
     uint32_t drivers_num = 0;
 
-    ret = utils_ze_init_level_zero();
-    if (ret != 0) {
-        fprintf(stderr, "utils_ze_init_level_zero() failed!\n");
-        goto init_fail;
-    }
-
     ze_result = libze_ops.zeDriverGet(&drivers_num, NULL);
     if (ze_result != ZE_RESULT_SUCCESS) {
         fprintf(stderr, "zeDriverGet() failed!\n");
@@ -372,7 +383,6 @@ int utils_ze_get_drivers(uint32_t *drivers_num_,
         *drivers_ = NULL;
     }
 
-init_fail:
     return ret;
 }
 
@@ -383,12 +393,6 @@ int utils_ze_get_devices(ze_driver_handle_t driver, uint32_t *devices_num_,
     uint32_t devices_num = 0;
     ze_device_handle_t *devices = NULL;
 
-    ret = utils_ze_init_level_zero();
-    if (ret != 0) {
-        fprintf(stderr, "utils_ze_init_level_zero() failed!\n");
-        goto init_fail;
-    }
-
     ze_result = libze_ops.zeDeviceGet(driver, &devices_num, NULL);
     if (ze_result != ZE_RESULT_SUCCESS) {
         fprintf(stderr, "zeDeviceGet() failed!\n");
@@ -424,7 +428,7 @@ int utils_ze_get_devices(ze_driver_handle_t driver, uint32_t *devices_num_,
         free(devices);
         devices = NULL;
     }
-init_fail:
+
     return ret;
 }
 
@@ -745,3 +749,15 @@ ze_memory_type_t utils_ze_get_mem_type(ze_context_handle_t context, void *ptr) {
     libze_ops.zeMemGetAllocProperties(context, ptr, &alloc_props, &device);
     return alloc_props.type;
 }
+
+int64_t utils_ze_get_num_memory_properties(ze_device_handle_t device) {
+    uint32_t pCount = 0;
+    ze_result_t ze_result =
+        libze_ops.zeDeviceGetMemoryProperties(device, &pCount, nullptr);
+    if (ze_result != ZE_RESULT_SUCCESS) {
+        fprintf(stderr, "zeDeviceGetMemoryProperties() failed!\n");
+        return -1;
+    }
+
+    return static_cast<int64_t>(pCount);
+}
diff --git a/src/utils/utils_level_zero.h b/src/utils/utils_level_zero.h
index b29a4dc438..00f55b3510 100644
--- a/src/utils/utils_level_zero.h
+++ b/src/utils/utils_level_zero.h
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -16,7 +16,6 @@
 extern "C" {
 #endif
 
-int utils_ze_init_level_zero(void);
 int utils_ze_init_level_zero(void);
 
 int utils_ze_get_drivers(uint32_t *drivers_num_, ze_driver_handle_t **drivers_);
@@ -45,6 +44,8 @@ int utils_ze_destroy_context(ze_context_handle_t context);
 
 ze_memory_type_t utils_ze_get_mem_type(ze_context_handle_t context, void *ptr);
 
+int64_t utils_ze_get_num_memory_properties(ze_device_handle_t device);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/utils/utils_load_library.c b/src/utils/utils_load_library.c
index ef0da450ba..d774fec840 100644
--- a/src/utils/utils_load_library.c
+++ b/src/utils/utils_load_library.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -32,7 +32,11 @@
 #ifdef _WIN32
 
 void *utils_open_library(const char *filename, int userFlags) {
-    (void)userFlags; //unused for win
+    if (userFlags & UMF_UTIL_OPEN_LIBRARY_NO_LOAD) {
+        HMODULE hModule;
+        BOOL ret = GetModuleHandleEx(0, TEXT(filename), &hModule);
+        return ret ? hModule : NULL;
+    }
     return LoadLibrary(TEXT(filename));
 }
 
@@ -66,6 +70,9 @@ void *utils_open_library(const char *filename, int userFlags) {
     if (userFlags & UMF_UTIL_OPEN_LIBRARY_GLOBAL) {
         dlopenFlags |= RTLD_GLOBAL;
     }
+    if (userFlags & UMF_UTIL_OPEN_LIBRARY_NO_LOAD) {
+        dlopenFlags |= RTLD_NOLOAD;
+    }
 
     void *handle = dlopen(filename, dlopenFlags);
     if (handle == NULL) {
diff --git a/src/utils/utils_load_library.h b/src/utils/utils_load_library.h
index 3206183f55..5b6e71239f 100644
--- a/src/utils/utils_load_library.h
+++ b/src/utils/utils_load_library.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -17,7 +17,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+// The symbols defined by this library will be made available for symbol resolution of subsequently loaded libraries.
 #define UMF_UTIL_OPEN_LIBRARY_GLOBAL 1
+// Don't load the library. utils_open_library succeeds if the library is already loaded.
+#define UMF_UTIL_OPEN_LIBRARY_NO_LOAD 1 << 1
 
 void *utils_open_library(const char *filename, int userFlags);
 int utils_close_library(void *handle);
diff --git a/src/utils/utils_log.c b/src/utils/utils_log.c
index 2fd28fc2ce..73836cd9e4 100644
--- a/src/utils/utils_log.c
+++ b/src/utils/utils_log.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -10,7 +10,6 @@
 #ifdef _WIN32
 #include <windows.h>
 #else
-#define _GNU_SOURCE 1
 #include <sys/syscall.h>
 #include <sys/types.h>
 #include <unistd.h>
@@ -26,8 +25,9 @@
 #include <string.h>
 #include <time.h>
 
-#include "umf.h"
+#include <umf.h>
 
+#include "ctl/ctl_internal.h"
 #include "utils_assert.h"
 #include "utils_common.h"
 #include "utils_log.h"
@@ -61,14 +61,16 @@ char const __umf_str_1__all_cmake_vars[] =
 #define MAX_ENV_LEN 2048
 
 typedef struct {
-    int timestamp;
-    int pid;
+    bool enableTimestamp;
+    bool enablePid;
     utils_log_level_t level;
     utils_log_level_t flushLevel;
     FILE *output;
+    char file_name[MAX_FILE_PATH];
 } utils_log_config_t;
 
-utils_log_config_t loggerConfig = {0, 0, LOG_ERROR, LOG_ERROR, NULL};
+utils_log_config_t loggerConfig = {false,     false, LOG_ERROR,
+                                   LOG_ERROR, NULL,  ""};
 
 static const char *level_to_str(utils_log_level_t l) {
     switch (l) {
@@ -97,8 +99,8 @@ static const char *level_to_str(utils_log_level_t l) {
 #endif // _MSC_VER
 
 static void utils_log_internal(utils_log_level_t level, int perror,
-                               const char *func, const char *format,
-                               va_list args) {
+                               const char *fileline, const char *func,
+                               const char *format, va_list args) {
     if (!loggerConfig.output && level != LOG_FATAL) {
         return; //logger not enabled
     }
@@ -113,7 +115,12 @@ static void utils_log_internal(utils_log_level_t level, int perror,
     char *b_pos = buffer;
     int b_size = sizeof(buffer);
 
-    int tmp = snprintf(b_pos, b_size, "%s: ", func);
+    int tmp = 0;
+    if (fileline == NULL) {
+        tmp = snprintf(b_pos, b_size, "%s: ", func);
+    } else {
+        tmp = snprintf(b_pos, b_size, "%s %s: ", fileline, func);
+    }
     ASSERT(tmp > 0);
 
     b_pos += (int)tmp;
@@ -138,28 +145,29 @@ static void utils_log_internal(utils_log_level_t level, int perror,
                 *err = '\0';
                 postfix = "[strerror_s failed]";
             }
-#elif defined(__APPLE__)
-            char err[1024]; // max size according to manpage.
+#else
             int saveno = errno;
             errno = 0;
-            if (strerror_r(saveno, err, sizeof(err))) {
-                /* should never happen */
+
+#if defined(__APPLE__) ||                                                      \
+    ((_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && !_GNU_SOURCE)
+            char err[1024];
+            int ret = strerror_r(saveno, err, sizeof(err));
+            if (ret) {
                 *err = '\0';
                 postfix = "[strerror_r failed]";
             }
-
             if (errno == ERANGE) {
                 postfix = "[truncated...]";
             }
-            errno = saveno;
 #else
-            char err_buff[1024]; // max size according to manpage.
-            int saveno = errno;
-            errno = 0;
+            char err_buff[1024];
             const char *err = strerror_r(saveno, err_buff, sizeof(err_buff));
             if (errno == ERANGE) {
                 postfix = "[truncated...]";
             }
+#endif
+
             errno = saveno;
 #endif
             strncpy(b_pos, err, b_size);
@@ -185,7 +193,7 @@ static void utils_log_internal(utils_log_level_t level, int perror,
     int h_size = sizeof(header);
     memset(header, 0, sizeof(header));
 
-    if (loggerConfig.timestamp) {
+    if (loggerConfig.enableTimestamp) {
         time_t now = time(NULL);
         struct tm tm_info;
 #ifdef _WIN32
@@ -200,7 +208,7 @@ static void utils_log_internal(utils_log_level_t level, int perror,
         h_size -= tmp;
     }
 
-    if (loggerConfig.pid) {
+    if (loggerConfig.enablePid) {
         ASSERT(h_size > 0);
         tmp = snprintf(h_pos, h_size, "PID:%-6lu TID:%-6lu ",
                        (unsigned long)pid, (unsigned long)tid);
@@ -226,19 +234,19 @@ static void utils_log_internal(utils_log_level_t level, int perror,
 #pragma warning(pop)
 #endif // _MSC_VER
 
-void utils_log(utils_log_level_t level, const char *func, const char *format,
-               ...) {
+void utils_log(utils_log_level_t level, const char *fileline, const char *func,
+               const char *format, ...) {
     va_list args;
     va_start(args, format);
-    utils_log_internal(level, 0, func, format, args);
+    utils_log_internal(level, 0, fileline, func, format, args);
     va_end(args);
 }
 
-void utils_plog(utils_log_level_t level, const char *func, const char *format,
-                ...) {
+void utils_plog(utils_log_level_t level, const char *fileline, const char *func,
+                const char *format, ...) {
     va_list args;
     va_start(args, format);
-    utils_log_internal(level, 1, func, format, args);
+    utils_log_internal(level, 1, fileline, func, format, args);
     va_end(args);
 }
 
@@ -254,8 +262,10 @@ void utils_log_init(void) {
     const char *arg;
     if (utils_parse_var(envVar, "output:stdout", NULL)) {
         loggerConfig.output = stdout;
+        strncpy(loggerConfig.file_name, "stdout", MAX_FILE_PATH);
     } else if (utils_parse_var(envVar, "output:stderr", NULL)) {
         loggerConfig.output = stderr;
+        strncpy(loggerConfig.file_name, "stderr", MAX_FILE_PATH);
     } else if (utils_parse_var(envVar, "output:file", &arg)) {
         loggerConfig.output = NULL;
         const char *argEnd = strstr(arg, ";");
@@ -284,6 +294,9 @@ void utils_log_init(void) {
             loggerConfig.output = NULL;
             return;
         }
+        strncpy(loggerConfig.file_name, file, MAX_FILE_PATH - 1);
+        loggerConfig.file_name[MAX_FILE_PATH - 1] =
+            '\0'; // ensure null-termination
     } else {
         loggerConfig.output = stderr;
         LOG_ERR("Logging output not set - logging disabled (UMF_LOG = \"%s\")",
@@ -293,15 +306,15 @@ void utils_log_init(void) {
     }
 
     if (utils_parse_var(envVar, "timestamp:yes", NULL)) {
-        loggerConfig.timestamp = 1;
+        loggerConfig.enableTimestamp = 1;
     } else if (utils_parse_var(envVar, "timestamp:no", NULL)) {
-        loggerConfig.timestamp = 0;
+        loggerConfig.enableTimestamp = 0;
     }
 
     if (utils_parse_var(envVar, "pid:yes", NULL)) {
-        loggerConfig.pid = 1;
+        loggerConfig.enablePid = 1;
     } else if (utils_parse_var(envVar, "pid:no", NULL)) {
-        loggerConfig.pid = 0;
+        loggerConfig.enablePid = 0;
     }
 
     if (utils_parse_var(envVar, "level:debug", NULL)) {
@@ -328,9 +341,267 @@ void utils_log_init(void) {
         loggerConfig.flushLevel = LOG_FATAL;
     }
 
-    LOG_INFO(
-        "Logger enabled (" LOG_STR_UMF_VERSION
-        "level: %s, flush: %s, pid: %s, timestamp: %s)",
-        level_to_str(loggerConfig.level), level_to_str(loggerConfig.flushLevel),
-        bool_to_str(loggerConfig.pid), bool_to_str(loggerConfig.timestamp));
+    LOG_INFO("Logger enabled (" LOG_STR_UMF_VERSION
+             "level: %s, flush: %s, pid: %s, timestamp: %s)",
+             level_to_str(loggerConfig.level),
+             level_to_str(loggerConfig.flushLevel),
+             bool_to_str(loggerConfig.enablePid),
+             bool_to_str(loggerConfig.enableTimestamp));
+}
+
+// this is needed for logger unit test
+#ifndef DISABLE_CTL_LOGGER
+static umf_result_t
+CTL_READ_HANDLER(timestamp)(void *ctx, umf_ctl_query_source_t source, void *arg,
+                            size_t size, umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)ctx;
+
+    bool *arg_out = (bool *)arg;
+
+    if (arg_out == NULL || size < sizeof(bool)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    *arg_out = loggerConfig.enableTimestamp;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t
+CTL_WRITE_HANDLER(timestamp)(void *ctx, umf_ctl_query_source_t source,
+                             void *arg, size_t size,
+                             umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)ctx;
+
+    bool arg_in = *(bool *)arg;
+
+    if (size < sizeof(bool)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    loggerConfig.enableTimestamp = arg_in;
+    LOG_INFO("Logger print timestamp set to %s",
+             bool_to_str(loggerConfig.enableTimestamp));
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t CTL_READ_HANDLER(pid)(void *ctx,
+                                          umf_ctl_query_source_t source,
+                                          void *arg, size_t size,
+                                          umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)ctx;
+
+    bool *arg_out = (bool *)arg;
+
+    if (arg_out == NULL || size < sizeof(bool)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    *arg_out = loggerConfig.enablePid;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t CTL_WRITE_HANDLER(pid)(void *ctx,
+                                           umf_ctl_query_source_t source,
+                                           void *arg, size_t size,
+                                           umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)ctx;
+
+    bool arg_in = *(bool *)arg;
+
+    if (size < sizeof(bool)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    loggerConfig.enablePid = arg_in;
+    LOG_INFO("Logger print pid %s set to", bool_to_str(loggerConfig.enablePid));
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t CTL_READ_HANDLER(level)(void *ctx,
+                                            umf_ctl_query_source_t source,
+                                            void *arg, size_t size,
+                                            umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)ctx;
+
+    bool *arg_out = (bool *)arg;
+
+    if (arg_out == NULL || size < sizeof(utils_log_level_t)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    *arg_out = loggerConfig.level;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t CTL_WRITE_HANDLER(level)(void *ctx,
+                                             umf_ctl_query_source_t source,
+                                             void *arg, size_t size,
+                                             umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)ctx;
+
+    utils_log_level_t *arg_in = (utils_log_level_t *)arg;
+
+    if (arg_in == NULL || *arg_in < LOG_DEBUG || *arg_in > LOG_FATAL ||
+        size < sizeof(int)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    utils_log_level_t old = loggerConfig.level;
+
+    // if new log level is higher then LOG_INFO print log before changing log level
+    // so if user changes from LOG_INFO to higher log level, it will get information about change anyway
+    if (*arg_in > LOG_INFO) {
+        LOG_INFO("Logger level changed from %s to %s", level_to_str(old),
+                 level_to_str(*arg_in));
+        loggerConfig.level = *arg_in;
+    } else {
+        loggerConfig.level = *arg_in;
+        LOG_INFO("Logger level changed from %s to %s", level_to_str(old),
+                 level_to_str(loggerConfig.level));
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t
+CTL_READ_HANDLER(flush_level)(void *ctx, umf_ctl_query_source_t source,
+                              void *arg, size_t size,
+                              umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)ctx;
+
+    utils_log_level_t *arg_out = (utils_log_level_t *)arg;
+
+    if (arg_out == NULL || size < sizeof(utils_log_level_t)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    *arg_out = loggerConfig.flushLevel;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t
+CTL_WRITE_HANDLER(flush_level)(void *ctx, umf_ctl_query_source_t source,
+                               void *arg, size_t size,
+                               umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)ctx;
+
+    utils_log_level_t *arg_in = (utils_log_level_t *)arg;
+
+    if (arg_in == NULL || *arg_in < LOG_DEBUG || *arg_in > LOG_FATAL ||
+        size < sizeof(int)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    loggerConfig.flushLevel = *arg_in;
+    LOG_INFO("Logger flush level set to %s",
+             level_to_str(loggerConfig.flushLevel));
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t CTL_READ_HANDLER(output)(void *ctx,
+                                             umf_ctl_query_source_t source,
+                                             void *arg, size_t size,
+                                             umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)ctx;
+
+    char *arg_out = (char *)arg;
+    if (arg_out == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (loggerConfig.output == NULL) {
+        const char disabled[] = "disabled";
+        if (size < sizeof(disabled)) {
+            LOG_ERR("Invalid output argument size: %zu, expected at least %zu",
+                    size, sizeof(disabled));
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+
+        strncpy(arg_out, disabled, size);
+        return UMF_RESULT_SUCCESS;
+    }
+    if (size < strlen(loggerConfig.file_name)) {
+        LOG_ERR("Invalid output argument size: %zu, expected at least %zu",
+                size, strlen(loggerConfig.file_name));
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    strncpy(arg_out, loggerConfig.file_name, size);
+    return UMF_RESULT_SUCCESS;
 }
+
+static umf_result_t CTL_WRITE_HANDLER(output)(void *ctx,
+                                              umf_ctl_query_source_t source,
+                                              void *arg, size_t size,
+                                              umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)ctx, (void)size;
+
+    const char *arg_in = (const char *)arg;
+
+    FILE *oldHandle = loggerConfig.output;
+    const char *oldName =
+        *loggerConfig.file_name == '\0' ? loggerConfig.file_name : "disabled";
+
+    if (arg_in == NULL) {
+        if (loggerConfig.output) {
+            LOG_INFO("Logger disabled");
+            if (oldHandle != stdout && oldHandle != stderr) {
+                fclose(oldHandle);
+            }
+            loggerConfig.output = NULL;
+            loggerConfig.file_name[0] = '\0';
+        }
+        return UMF_RESULT_SUCCESS;
+    }
+
+    FILE *newHandle = NULL;
+
+    if (strcmp(arg_in, "stdout") == 0) {
+        newHandle = stdout;
+        strncpy(loggerConfig.file_name, "stdout", MAX_FILE_PATH);
+    } else if (strcmp(arg_in, "stderr") == 0) {
+        newHandle = stderr;
+        strncpy(loggerConfig.file_name, "stderr", MAX_FILE_PATH);
+    } else {
+        newHandle = fopen(arg_in, "a");
+        if (!newHandle) {
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+        strncpy(loggerConfig.file_name, arg_in, MAX_FILE_PATH - 1);
+        loggerConfig.file_name[MAX_FILE_PATH - 1] =
+            '\0'; // ensure null-termination
+    }
+
+    loggerConfig.output = newHandle;
+    LOG_INFO("Logger output changed from %s to %s", oldName,
+             loggerConfig.file_name);
+
+    if (oldHandle && oldHandle != stdout && oldHandle != stderr) {
+        fclose(oldHandle);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static const struct ctl_argument CTL_ARG(timestamp) = CTL_ARG_BOOLEAN;
+static const struct ctl_argument CTL_ARG(pid) = CTL_ARG_BOOLEAN;
+static const struct ctl_argument CTL_ARG(level) = CTL_ARG_INT;
+static const struct ctl_argument CTL_ARG(flush_level) = CTL_ARG_INT;
+static const struct ctl_argument
+    CTL_ARG(output) = CTL_ARG_STRING(MAX_FILE_PATH);
+
+const umf_ctl_node_t CTL_NODE(logger)[] = {
+    CTL_LEAF_RW(timestamp),   CTL_LEAF_RW(pid),    CTL_LEAF_RW(level),
+    CTL_LEAF_RW(flush_level), CTL_LEAF_RW(output), CTL_NODE_END,
+};
+#endif
diff --git a/src/utils/utils_log.h b/src/utils/utils_log.h
index ab40121cec..15fdabec66 100644
--- a/src/utils/utils_log.h
+++ b/src/utils/utils_log.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -14,6 +14,8 @@
 extern "C" {
 #endif
 
+#include "ctl/ctl_internal.h"
+
 typedef enum {
     LOG_DEBUG,
     LOG_INFO,
@@ -22,31 +24,51 @@ typedef enum {
     LOG_FATAL
 } utils_log_level_t;
 
-#define LOG_DEBUG(...) utils_log(LOG_DEBUG, __func__, __VA_ARGS__);
-#define LOG_INFO(...) utils_log(LOG_INFO, __func__, __VA_ARGS__);
-#define LOG_WARN(...) utils_log(LOG_WARNING, __func__, __VA_ARGS__);
-#define LOG_ERR(...) utils_log(LOG_ERROR, __func__, __VA_ARGS__);
-#define LOG_FATAL(...) utils_log(LOG_FATAL, __func__, __VA_ARGS__);
+#ifdef UMF_DEVELOPER_MODE
+#define UMF_STRINGIFY(x) #x
+#define UMF_TOSTRING(x) UMF_STRINGIFY(x)
+#define UMF_FILELINE_DESC() __FILE__ ":" UMF_TOSTRING(__LINE__)
+#else
+#define UMF_FILELINE_DESC() NULL
+#endif
 
-#define LOG_PDEBUG(...) utils_plog(LOG_DEBUG, __func__, __VA_ARGS__);
-#define LOG_PINFO(...) utils_plog(LOG_INFO, __func__, __VA_ARGS__);
-#define LOG_PWARN(...) utils_plog(LOG_WARNING, __func__, __VA_ARGS__);
-#define LOG_PERR(...) utils_plog(LOG_ERROR, __func__, __VA_ARGS__);
-#define LOG_PFATAL(...) utils_plog(LOG_FATAL, __func__, __VA_ARGS__);
+#define LOG_DEBUG(...)                                                         \
+    utils_log(LOG_DEBUG, UMF_FILELINE_DESC(), __func__, __VA_ARGS__);
+#define LOG_INFO(...)                                                          \
+    utils_log(LOG_INFO, UMF_FILELINE_DESC(), __func__, __VA_ARGS__);
+#define LOG_WARN(...)                                                          \
+    utils_log(LOG_WARNING, UMF_FILELINE_DESC(), __func__, __VA_ARGS__);
+#define LOG_ERR(...)                                                           \
+    utils_log(LOG_ERROR, UMF_FILELINE_DESC(), __func__, __VA_ARGS__);
+#define LOG_FATAL(...)                                                         \
+    utils_log(LOG_FATAL, UMF_FILELINE_DESC(), __func__, __VA_ARGS__);
+
+#define LOG_PDEBUG(...)                                                        \
+    utils_plog(LOG_DEBUG, UMF_FILELINE_DESC(), __func__, __VA_ARGS__);
+#define LOG_PINFO(...)                                                         \
+    utils_plog(LOG_INFO, UMF_FILELINE_DESC(), __func__, __VA_ARGS__);
+#define LOG_PWARN(...)                                                         \
+    utils_plog(LOG_WARNING, UMF_FILELINE_DESC(), __func__, __VA_ARGS__);
+#define LOG_PERR(...)                                                          \
+    utils_plog(LOG_ERROR, UMF_FILELINE_DESC(), __func__, __VA_ARGS__);
+#define LOG_PFATAL(...)                                                        \
+    utils_plog(LOG_FATAL, UMF_FILELINE_DESC(), __func__, __VA_ARGS__);
 
 void utils_log_init(void);
 #ifdef _WIN32
-void utils_log(utils_log_level_t level, const char *func, const char *format,
-               ...);
-void utils_plog(utils_log_level_t level, const char *func, const char *format,
-                ...);
+void utils_log(utils_log_level_t level, const char *fileline, const char *func,
+               const char *format, ...);
+void utils_plog(utils_log_level_t level, const char *fileline, const char *func,
+                const char *format, ...);
 #else
-void utils_log(utils_log_level_t level, const char *func, const char *format,
-               ...) __attribute__((format(printf, 3, 4)));
-void utils_plog(utils_log_level_t level, const char *func, const char *format,
-                ...) __attribute__((format(printf, 3, 4)));
+void utils_log(utils_log_level_t level, const char *fileline, const char *func,
+               const char *format, ...) __attribute__((format(printf, 4, 5)));
+void utils_plog(utils_log_level_t level, const char *fileline, const char *func,
+                const char *format, ...) __attribute__((format(printf, 4, 5)));
 #endif
 
+extern const umf_ctl_node_t CTL_NODE(logger)[];
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/utils/utils_math.h b/src/utils/utils_math.h
index c78be11367..0e58fc38df 100644
--- a/src/utils/utils_math.h
+++ b/src/utils/utils_math.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -11,16 +11,58 @@
 #define UMF_MATH_H 1
 
 #include <assert.h>
+#include <limits.h>
 #include <stddef.h>
+#include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-size_t getLeftmostSetBitPos(size_t num);
+#if defined(_WIN32)
 
-// Logarithm is an index of the most significant non-zero bit.
-static inline size_t log2Utils(size_t num) { return getLeftmostSetBitPos(num); }
+#include "utils_windows_intrin.h"
+
+#pragma intrinsic(_BitScanReverse64)
+#pragma intrinsic(_BitScanForward64)
+
+// Retrieves the position of the leftmost set bit.
+// The position of the bit is counted from 0
+// e.g. for 01000011110 the position equals 9.
+static inline size_t utils_msb64(uint64_t num) {
+    assert(num != 0 &&
+           "Finding leftmost set bit when number equals zero is undefined");
+    unsigned long index = 0;
+    _BitScanReverse64(&index, num);
+    return (size_t)index;
+}
+
+static inline size_t utils_lsb64(uint64_t num) {
+    assert(num != 0 &&
+           "Finding rightmost set bit when number equals zero is undefined");
+    unsigned long index = 0;
+    _BitScanForward64(&index, num);
+    return (size_t)index;
+}
+
+#else // !defined(_WIN32)
+
+// Retrieves the position of the leftmost set bit.
+// The position of the bit is counted from 0
+// e.g. for 01000011110 the position equals 9.
+static inline size_t utils_msb64(uint64_t num) {
+    assert(num != 0 &&
+           "Finding leftmost set bit when number equals zero is undefined");
+    return 63 - __builtin_clzll(num);
+}
+
+static inline size_t utils_lsb64(uint64_t num) {
+    assert(num != 0 &&
+           "Finding rightmost set bit when number equals zero is undefined");
+    return __builtin_ctzll(num);
+}
+
+#endif // !defined(_WIN32)
 
 #ifdef __cplusplus
 }
diff --git a/src/utils/utils_name.h b/src/utils/utils_name.h
new file mode 100644
index 0000000000..6914d06ba3
--- /dev/null
+++ b/src/utils/utils_name.h
@@ -0,0 +1,46 @@
+/*
+ *
+ * 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
+ *
+ */
+
+#ifndef UMF_UTILS_NAME_H
+#define UMF_UTILS_NAME_H
+
+#include <ctype.h>
+#include <string.h>
+
+#include "utils_log.h"
+
+#define MAX_NAME 64
+
+static inline int utils_name_is_valid(const char *name) {
+    if (!name) {
+        return 0;
+    }
+    size_t len = strlen(name);
+    if (len > MAX_NAME) {
+        return 0;
+    }
+    for (size_t i = 0; i < len; ++i) {
+        char c = name[i];
+        if (!isalnum((unsigned char)c) && c != '-' && c != '_') {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+static inline void utils_warn_invalid_name(const char *kind, const char *name) {
+    if (!utils_name_is_valid(name)) {
+        LOG_WARN("%s name \"%s\" is deprecated. It should be no more than 64 "
+                 "characters including null character, containing only "
+                 "alphanumerics, '_' or '-'. CTL functionality may be limited.",
+                 kind, name);
+    }
+}
+
+#endif /* UMF_UTILS_NAME_H */
diff --git a/src/utils/utils_posix_common.c b/src/utils/utils_posix_common.c
index 4a60cbb1f2..da051695b2 100644
--- a/src/utils/utils_posix_common.c
+++ b/src/utils/utils_posix_common.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -37,13 +37,17 @@
          ? LLONG_MAX                                                           \
          : (sizeof(off_t) == sizeof(long) ? LONG_MAX : INT_MAX))
 
-static UTIL_ONCE_FLAG Page_size_is_initialized = UTIL_ONCE_FLAG_INIT;
+static UTIL_ONCE_FLAG System_info_is_initialized = UTIL_ONCE_FLAG_INIT;
 static size_t Page_size;
+static unsigned Core_count;
 
-static void _utils_get_page_size(void) { Page_size = sysconf(_SC_PAGE_SIZE); }
+static void _utils_get_system_info(void) {
+    Page_size = sysconf(_SC_PAGE_SIZE);
+    Core_count = sysconf(_SC_NPROCESSORS_ONLN);
+}
 
 size_t utils_get_page_size(void) {
-    utils_init_once(&Page_size_is_initialized, _utils_get_page_size);
+    utils_init_once(&System_info_is_initialized, _utils_get_system_info);
     return Page_size;
 }
 
@@ -62,6 +66,11 @@ int utils_gettid(void) {
 #endif
 }
 
+unsigned utils_get_num_cores(void) {
+    utils_init_once(&System_info_is_initialized, _utils_get_system_info);
+    return Core_count;
+}
+
 int utils_close_fd(int fd) { return close(fd); }
 
 umf_result_t utils_errno_to_umf_result(int err) {
@@ -91,9 +100,8 @@ umf_result_t utils_duplicate_fd(int pid, int fd_in, int *fd_out) {
     return UMF_RESULT_ERROR_NOT_SUPPORTED;
 #else
     // pidfd_getfd(2) is used to obtain a duplicate of another process's file descriptor.
-    // Permission to duplicate another process's file descriptor
-    // is governed by a ptrace access mode PTRACE_MODE_ATTACH_REALCREDS check (see ptrace(2))
-    // that can be changed using the /proc/sys/kernel/yama/ptrace_scope interface.
+    // Calling prctl(PR_SET_PTRACER, getppid()) in a producer binary that creates IPC handle
+    // allows file descriptor duplication for parent process and its children.
     // pidfd_getfd(2) is supported since Linux 5.6
     // pidfd_open(2) is supported since Linux 5.3
     errno = 0;
diff --git a/src/utils/utils_posix_concurrency.c b/src/utils/utils_posix_concurrency.c
index fcf04ed952..0149263df3 100644
--- a/src/utils/utils_posix_concurrency.c
+++ b/src/utils/utils_posix_concurrency.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 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
@@ -11,10 +11,11 @@
 #include <stdlib.h>
 
 #include "utils_concurrency.h"
+#include "utils_log.h"
 
 size_t utils_mutex_get_size(void) { return sizeof(pthread_mutex_t); }
 
-utils_mutex_t *utils_mutex_init(void *ptr) {
+utils_mutex_t *utils_mutex_init(utils_mutex_t *ptr) {
     pthread_mutex_t *mutex = (pthread_mutex_t *)ptr;
     int ret = pthread_mutex_init(mutex, NULL);
     return ret == 0 ? ((utils_mutex_t *)mutex) : NULL;
@@ -23,7 +24,9 @@ utils_mutex_t *utils_mutex_init(void *ptr) {
 void utils_mutex_destroy_not_free(utils_mutex_t *m) {
     pthread_mutex_t *mutex = (pthread_mutex_t *)m;
     int ret = pthread_mutex_destroy(mutex);
-    (void)ret; // TODO: add logging
+    if (ret) {
+        LOG_ERR("pthread_mutex_destroy failed");
+    }
 }
 
 int utils_mutex_lock(utils_mutex_t *m) {
@@ -35,5 +38,51 @@ int utils_mutex_unlock(utils_mutex_t *m) {
 }
 
 void utils_init_once(UTIL_ONCE_FLAG *flag, void (*oneCb)(void)) {
+    if (oneCb == NULL) {
+        LOG_FATAL("utils_init_once: callback is NULL");
+        return;
+    }
+
     pthread_once(flag, oneCb);
 }
+
+int utils_rwlock_init(utils_rwlock_t *ptr) {
+    pthread_rwlock_t *rwlock = (pthread_rwlock_t *)ptr;
+    return pthread_rwlock_init(rwlock, NULL);
+}
+
+void utils_rwlock_destroy_not_free(utils_rwlock_t *ptr) {
+    pthread_rwlock_t *rwlock = (pthread_rwlock_t *)ptr;
+    if (pthread_rwlock_destroy(rwlock) != 0) {
+        LOG_FATAL("pthread_rwlock_destroy failed");
+        abort();
+    }
+}
+
+void utils_read_lock(utils_rwlock_t *rwlock) {
+    if (pthread_rwlock_rdlock((pthread_rwlock_t *)rwlock) != 0) {
+        LOG_FATAL("pthread_rwlock_rdlock failed");
+        abort();
+    }
+}
+
+void utils_write_lock(utils_rwlock_t *rwlock) {
+    if (pthread_rwlock_wrlock((pthread_rwlock_t *)rwlock) != 0) {
+        LOG_FATAL("pthread_rwlock_wrlock failed");
+        abort();
+    }
+}
+
+void utils_read_unlock(utils_rwlock_t *rwlock) {
+    if (pthread_rwlock_unlock((pthread_rwlock_t *)rwlock) != 0) {
+        LOG_FATAL("pthread_rwlock_unlock failed");
+        abort();
+    }
+}
+
+void utils_write_unlock(utils_rwlock_t *rwlock) {
+    if (pthread_rwlock_unlock((pthread_rwlock_t *)rwlock) != 0) {
+        LOG_FATAL("pthread_rwlock_unlock failed");
+        abort();
+    }
+}
diff --git a/src/utils/utils_posix_math.c b/src/utils/utils_posix_math.c
deleted file mode 100644
index 465b687725..0000000000
--- a/src/utils/utils_posix_math.c
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- *
- * Copyright (C) 2023 Intel Corporation
- *
- * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- *
- */
-
-#include "utils_math.h"
-#include <limits.h>
-
-// Retrieves the position of the leftmost set bit.
-// The position of the bit is counted from 0
-// e.g. for 01000011110 the position equals 9.
-size_t getLeftmostSetBitPos(size_t num) {
-    assert(num != 0 &&
-           "Finding leftmost set bit when number equals zero is undefined");
-    return (sizeof(num) * CHAR_BIT - 1) - __builtin_clzll(num);
-}
diff --git a/src/utils/utils_sanitizers.h b/src/utils/utils_sanitizers.h
index 3498e4b705..f8896d0ae3 100644
--- a/src/utils/utils_sanitizers.h
+++ b/src/utils/utils_sanitizers.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -168,6 +168,24 @@ static inline void utils_annotate_memory_inaccessible(void *ptr, size_t size) {
 #endif
 }
 
+static inline void utils_annotate_memory_new(void *ptr, size_t size) {
+#ifdef UMF_VG_DRD_ENABLED
+    ANNOTATE_NEW_MEMORY(ptr, size);
+#else
+    (void)ptr;
+    (void)size;
+#endif
+}
+
+static inline void utils_annotate_memory_no_check(void *ptr, size_t size) {
+#ifdef UMF_VG_HELGRIND_ENABLED
+    VALGRIND_HG_DISABLE_CHECKING(ptr, size);
+#else
+    (void)ptr;
+    (void)size;
+#endif
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/utils/utils_windows_common.c b/src/utils/utils_windows_common.c
index b6c5b0b4ee..4e1c63bd44 100644
--- a/src/utils/utils_windows_common.c
+++ b/src/utils/utils_windows_common.c
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -10,6 +10,7 @@
 #include <windows.h>
 
 #include <assert.h>
+#include <handleapi.h>
 #include <processenv.h>
 #include <processthreadsapi.h>
 #include <stdio.h>
@@ -22,28 +23,32 @@
 
 #define BUFFER_SIZE 1024
 
-static UTIL_ONCE_FLAG Page_size_is_initialized = UTIL_ONCE_FLAG_INIT;
+static UTIL_ONCE_FLAG System_info_is_initialized = UTIL_ONCE_FLAG_INIT;
 static size_t Page_size;
+static unsigned Core_count;
 
-static void _utils_get_page_size(void) {
+static void _utils_get_system_info(void) {
     SYSTEM_INFO SystemInfo;
     GetSystemInfo(&SystemInfo);
     Page_size = SystemInfo.dwPageSize;
+    Core_count = SystemInfo.dwNumberOfProcessors;
 }
 
 size_t utils_get_page_size(void) {
-    utils_init_once(&Page_size_is_initialized, _utils_get_page_size);
+    utils_init_once(&System_info_is_initialized, _utils_get_system_info);
     return Page_size;
 }
 
+unsigned utils_get_num_cores(void) {
+    utils_init_once(&System_info_is_initialized, _utils_get_system_info);
+    return Core_count;
+}
+
 int utils_getpid(void) { return GetCurrentProcessId(); }
 
 int utils_gettid(void) { return GetCurrentThreadId(); }
 
-int utils_close_fd(int fd) {
-    (void)fd; // unused
-    return -1;
-}
+int utils_close_fd(int fd) { return CloseHandle((HANDLE)(uintptr_t)fd); }
 
 umf_result_t utils_errno_to_umf_result(int err) {
     (void)err; // unused
@@ -51,10 +56,41 @@ umf_result_t utils_errno_to_umf_result(int err) {
 }
 
 umf_result_t utils_duplicate_fd(int pid, int fd_in, int *fd_out) {
-    (void)pid;    // unused
-    (void)fd_in;  // unused
-    (void)fd_out; // unused
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    umf_result_t ret = UMF_RESULT_SUCCESS;
+    HANDLE current_process_handle = GetCurrentProcess();
+    if (!current_process_handle) {
+        LOG_ERR("GetCurrentProcess() failed.");
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    HANDLE source_process_handle = OpenProcess(PROCESS_DUP_HANDLE, FALSE, pid);
+    if (!source_process_handle) {
+        LOG_ERR("OpenProcess() failed for pid=%d.", pid);
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+        goto release_current;
+    }
+
+    HANDLE handle_in = (HANDLE)(uintptr_t)fd_in;
+    HANDLE handle_out = NULL;
+    BOOL result = DuplicateHandle(source_process_handle, handle_in,
+                                  current_process_handle, &handle_out,
+                                  GENERIC_READ | GENERIC_WRITE, FALSE, 0);
+    if (!result) {
+        LOG_ERR("DuplicateHandle() failed for pid=%d fd_in=%d handle_in=%p",
+                pid, fd_in, handle_in);
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+        goto release_source;
+    }
+
+    *fd_out = (int)(uintptr_t)handle_out;
+
+release_source:
+    CloseHandle(source_process_handle);
+
+release_current:
+    CloseHandle(current_process_handle);
+
+    return ret;
 }
 
 umf_result_t utils_translate_mem_protection_flags(unsigned in_protection,
diff --git a/src/utils/utils_windows_concurrency.c b/src/utils/utils_windows_concurrency.c
index 696f4523bc..645d87b106 100644
--- a/src/utils/utils_windows_concurrency.c
+++ b/src/utils/utils_windows_concurrency.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 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
@@ -11,35 +11,57 @@
 
 size_t utils_mutex_get_size(void) { return sizeof(utils_mutex_t); }
 
-utils_mutex_t *utils_mutex_init(void *ptr) {
-    utils_mutex_t *mutex_internal = (utils_mutex_t *)ptr;
-    InitializeCriticalSection(&mutex_internal->lock);
-    return (utils_mutex_t *)mutex_internal;
+utils_mutex_t *utils_mutex_init(utils_mutex_t *mutex) {
+    InitializeCriticalSection(&mutex->lock);
+    return mutex;
 }
 
 void utils_mutex_destroy_not_free(utils_mutex_t *mutex) {
-    utils_mutex_t *mutex_internal = (utils_mutex_t *)mutex;
-    DeleteCriticalSection(&mutex_internal->lock);
+    DeleteCriticalSection(&mutex->lock);
 }
 
 int utils_mutex_lock(utils_mutex_t *mutex) {
-    utils_mutex_t *mutex_internal = (utils_mutex_t *)mutex;
-    EnterCriticalSection(&mutex_internal->lock);
+    EnterCriticalSection(&mutex->lock);
 
-    if (mutex_internal->lock.RecursionCount > 1) {
-        LeaveCriticalSection(&mutex_internal->lock);
+    if (mutex->lock.RecursionCount > 1) {
+        LeaveCriticalSection(&mutex->lock);
         /* deadlock detected */
-        return -1;
+        abort();
     }
     return 0;
 }
 
 int utils_mutex_unlock(utils_mutex_t *mutex) {
-    utils_mutex_t *mutex_internal = (utils_mutex_t *)mutex;
-    LeaveCriticalSection(&mutex_internal->lock);
+    LeaveCriticalSection(&mutex->lock);
     return 0;
 }
 
+int utils_rwlock_init(utils_rwlock_t *rwlock) {
+    InitializeSRWLock(&rwlock->lock);
+    return 0; // never fails
+}
+
+void utils_rwlock_destroy_not_free(utils_rwlock_t *rwlock) {
+    // there is no call to destroy SWR lock
+    (void)rwlock;
+}
+
+void utils_read_lock(utils_rwlock_t *rwlock) {
+    AcquireSRWLockShared(&rwlock->lock); // never fails
+}
+
+void utils_write_lock(utils_rwlock_t *rwlock) {
+    AcquireSRWLockExclusive(&rwlock->lock); // never fails
+}
+
+void utils_read_unlock(utils_rwlock_t *rwlock) {
+    ReleaseSRWLockShared(&rwlock->lock); // never fails
+}
+
+void utils_write_unlock(utils_rwlock_t *rwlock) {
+    ReleaseSRWLockExclusive(&rwlock->lock); // never fails
+}
+
 static BOOL CALLBACK initOnceCb(PINIT_ONCE InitOnce, PVOID Parameter,
                                 PVOID *lpContext) {
     (void)InitOnce;  // unused
diff --git a/src/utils/utils_windows_math.c b/src/utils/utils_windows_math.c
deleted file mode 100644
index 07c4c9978b..0000000000
--- a/src/utils/utils_windows_math.c
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- *
- * Copyright (C) 2023 Intel Corporation
- *
- * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- *
- */
-
-#include "utils_math.h"
-#include "utils_windows_intrin.h"
-
-#pragma intrinsic(_BitScanReverse)
-
-// Retrieves the position of the leftmost set bit.
-// The position of the bit is counted from 0
-// e.g. for 01000011110 the position equals 9.
-size_t getLeftmostSetBitPos(size_t num) {
-    assert(num != 0 &&
-           "Finding leftmost set bit when number equals zero is undefined");
-    unsigned long index = 0;
-    _BitScanReverse(&index, (unsigned long)num);
-    return (size_t)index;
-}
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index c8b854ba5d..b6493b8582 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,32 +1,50 @@
-# Copyright (C) 2022-2024 Intel Corporation
+# Copyright (C) 2022-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED YES)
 
-include(FetchContent)
-FetchContent_Declare(
-    googletest
-    GIT_REPOSITORY https://github.com/google/googletest.git
-    GIT_TAG v1.15.2)
-
-# For Windows: Prevent overriding the parent project's compiler/linker settings
-set(gtest_force_shared_crt
-    ON
-    CACHE BOOL "" FORCE)
-set(INSTALL_GTEST
-    OFF
-    CACHE BOOL "" FORCE)
-FetchContent_MakeAvailable(googletest)
+if(CMAKE_C_COMPILER_ID STREQUAL "IntelLLVM")
+    # Compiler dependencies needs to be in library path or to be linked
+    # statically
+    add_link_options(-static-intel)
+endif()
+
+set(GTEST_VER 1.15.2)
+
+find_package(GTest ${GTEST_VER} QUIET)
+
+if(NOT GTest_FOUND)
+    include(FetchContent)
+    FetchContent_Declare(
+        googletest
+        GIT_REPOSITORY https://github.com/google/googletest.git
+        GIT_TAG v${GTEST_VER})
+
+    # For Windows: Prevent overriding the parent project's compiler/linker
+    # settings
+    set(gtest_force_shared_crt
+        ON
+        CACHE BOOL "" FORCE)
+    set(INSTALL_GTEST
+        OFF
+        CACHE BOOL "" FORCE)
+    FetchContent_MakeAvailable(googletest)
+endif()
 enable_testing()
 
 set(UMF_TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-set(UMF_UTILS_DIR ${UMF_CMAKE_SOURCE_DIR}/src/utils)
+set(UMF_SRC_DIR ${UMF_CMAKE_SOURCE_DIR}/src)
+set(UMF_UTILS_DIR ${UMF_SRC_DIR}/utils)
+set(UMF_BA_DIR ${UMF_SRC_DIR}/base_alloc)
 
 function(build_umf_test)
-    # Parameters: * NAME - a name of the test * SRCS - source files * LIBS -
-    # libraries to be linked with
+    # Parameters:
+    #
+    # * NAME - a name of the test
+    # * SRCS - source files
+    # * LIBS - libraries to be linked with
     set(oneValueArgs NAME)
     set(multiValueArgs SRCS LIBS)
     cmake_parse_arguments(
@@ -36,40 +54,38 @@ function(build_umf_test)
         "${multiValueArgs}"
         ${ARGN})
 
-    set(TEST_NAME umf-${ARG_NAME})
-    set(TEST_TARGET_NAME umf_test-${ARG_NAME})
+    set(TEST_NAME test_${ARG_NAME})
+    set(TEST_TARGET_NAME test_${ARG_NAME})
 
     set(LIB_DIRS ${LIB_DIRS} ${LIBHWLOC_LIBRARY_DIRS})
+    set(INC_DIRS ${INC_DIRS} ${LIBHWLOC_INCLUDE_DIRS})
 
-    if(UMF_BUILD_LIBUMF_POOL_JEMALLOC)
-        set(LIB_DIRS ${LIB_DIRS} ${JEMALLOC_LIBRARY_DIRS})
+    if(UMF_CUDA_ENABLED)
+        set(INC_DIRS ${INC_DIRS} ${CUDA_INCLUDE_DIRS})
+        set(LIB_DIRS ${LIB_DIRS} ${CUDA_LIBRARY_DIRS})
     endif()
 
-    if(UMF_BUILD_CUDA_PROVIDER)
-        set(LIB_DIRS ${LIB_DIRS} ${CUDA_LIBRARY_DIRS})
+    if(UMF_LEVEL_ZERO_ENABLED)
+        set(INC_DIRS ${INC_DIRS} ${LEVEL_ZERO_INCLUDE_DIRS})
+        set(LIB_DIRS ${LIB_DIRS} ${ZE_LOADER_LIBRARY_DIRS})
+    endif()
+
+    if(UMF_POOL_JEMALLOC_ENABLED)
+        set(CPL_DEFS ${CPL_DEFS} UMF_POOL_JEMALLOC_ENABLED=1)
     endif()
 
-    set(TEST_LIBS
-        umf_test_common
-        ${ARG_LIBS}
-        GTest::gtest_main
-        ${LIBS_OPTIONAL}
-        umf)
+    if(UMF_POOL_SCALABLE_ENABLED)
+        set(CPL_DEFS ${CPL_DEFS} UMF_POOL_SCALABLE_ENABLED=1)
+    endif()
+
+    set(TEST_LIBS umf_test_common ${ARG_LIBS} GTest::gtest_main umf)
 
     add_umf_executable(
         NAME ${TEST_TARGET_NAME}
         SRCS ${ARG_SRCS}
         LIBS ${TEST_LIBS})
 
-    if(UMF_POOL_JEMALLOC_ENABLED)
-        target_compile_definitions(${TEST_TARGET_NAME}
-                                   PRIVATE UMF_POOL_JEMALLOC_ENABLED=1)
-    endif()
-
-    if(UMF_POOL_SCALABLE_ENABLED)
-        target_compile_definitions(${TEST_TARGET_NAME}
-                                   PRIVATE UMF_POOL_SCALABLE_ENABLED=1)
-    endif()
+    target_compile_definitions(${TEST_TARGET_NAME} PRIVATE ${CPL_DEFS})
 
     if(NOT MSVC)
         # Suppress 'cast discards const qualifier' warnings. Parametrized GTEST
@@ -81,6 +97,7 @@ function(build_umf_test)
             target_compile_options(${TEST_TARGET_NAME} PRIVATE -Werror)
         endif()
     endif()
+
     target_link_directories(${TEST_TARGET_NAME} PRIVATE ${LIB_DIRS})
 
     target_include_directories(
@@ -88,16 +105,22 @@ function(build_umf_test)
         PRIVATE ${UMF_CMAKE_SOURCE_DIR}/include
                 ${UMF_CMAKE_SOURCE_DIR}/src
                 ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc
+                ${UMF_CMAKE_SOURCE_DIR}/src/coarse
                 ${UMF_CMAKE_SOURCE_DIR}/src/utils
                 ${UMF_TEST_DIR}/common
-                ${UMF_TEST_DIR})
+                ${UMF_TEST_DIR}
+                ${INC_DIRS})
 endfunction()
 
 function(add_umf_test)
-    # Parameters: * NAME - a name of the test * SRCS - source files * LIBS -
-    # libraries to be linked with
+    # Parameters:
+    #
+    # * NAME - a name of the test
+    # * SRCS - source files
+    # * LIBS - libraries to be linked with
+    # * ENVS - environment variables
     set(oneValueArgs NAME)
-    set(multiValueArgs SRCS LIBS)
+    set(multiValueArgs SRCS LIBS ENVS)
     cmake_parse_arguments(
         ARG
         ""
@@ -106,15 +129,12 @@ function(add_umf_test)
         ${ARGN})
 
     build_umf_test(
-        NAME
-        ${ARG_NAME}
-        SRCS
-        ${ARG_SRCS}
-        LIBS
-        ${ARG_LIBS})
+        NAME ${ARG_NAME}
+        SRCS ${ARG_SRCS}
+        LIBS ${ARG_LIBS})
 
-    set(TEST_NAME umf-${ARG_NAME})
-    set(TEST_TARGET_NAME umf_test-${ARG_NAME})
+    set(TEST_NAME test_${ARG_NAME})
+    set(TEST_TARGET_NAME test_${ARG_NAME})
 
     add_test(
         NAME ${TEST_NAME}
@@ -122,19 +142,48 @@ function(add_umf_test)
         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
     set_tests_properties(${TEST_NAME} PROPERTIES LABELS "umf")
+    if(ARG_ENVS)
+        set_tests_properties(${TEST_NAME} PROPERTIES ENVIRONMENT ${ARG_ENVS})
+    endif()
 
     if(WINDOWS)
-        # append PATH to DLLs
+        # add PATH to DLL on Windows
+        set(DLL_PATH_LIST
+            "${DLL_PATH_LIST};"
+            "PATH=path_list_append:${CMAKE_BINARY_DIR}/bin/;"
+            "PATH=path_list_append:${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
+
+        # append PATH to DLLs NOTE: this would work only for the CMake ver >= #
+        # 3.22. For the older versions, the PATH variable should be set in the
+        # test script)
         set_property(TEST ${TEST_NAME} PROPERTY ENVIRONMENT_MODIFICATION
                                                 "${DLL_PATH_LIST}")
     endif()
 endfunction()
 
+function(add_umf_mocked_test test_name test_source_file)
+    add_umf_test(
+        NAME ${test_name}
+        SRCS ${test_source_file} ${UMF_UTILS_DIR}/utils_level_zero.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} umf_test_mocks
+             GTest::gmock)
+
+    set_tests_properties(
+        test_${test_name} PROPERTIES
+        ENVIRONMENT
+        "UMF_LOG=level:debug\\\\\\\\;flush:debug\\\\\\\\;output:stdout;UMF_ZE_LOADER_LIB_NAME=$<TARGET_FILE:umf_ze_loopback>"
+    )
+    target_compile_definitions(test_${test_name} PUBLIC USE_DLOPEN=1)
+    add_dependencies(test_${test_name} umf_ze_loopback)
+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
@@ -156,28 +205,34 @@ if(UMF_BUILD_SHARED_LIBRARY)
     endif()
 endif()
 
-if(UMF_POOL_JEMALLOC_ENABLED)
-    set(LIB_JEMALLOC_POOL jemalloc_pool)
-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})
+
+if(NOT UMF_BUILD_SHARED_LIBRARY)
+    add_umf_test(
+        NAME logger
+        SRCS utils/utils_log.cpp ${UMF_UTILS_SOURCES} ../src/ctl/ctl.c
+        LIBS ${UMF_LOGGER_LIBS} ${UMF_BA_FOR_TEST})
+endif()
+
 add_umf_test(
-    NAME logger
-    SRCS utils/utils_log.cpp ${UMF_UTILS_SOURCES}
-    LIBS ${UMF_LOGGER_LIBS})
+    NAME ctl_unittest
+    SRCS ctl/ctl_unittest.cpp ctl/ctl_debug.c ../src/ctl/ctl.c
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+
+add_umf_test(
+    NAME ctl_api
+    SRCS ctl/ctl_api.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 
 add_umf_test(
     NAME utils_common
@@ -191,53 +246,82 @@ if(LINUX)
         LIBS ${UMF_UTILS_FOR_TEST})
 endif()
 
+build_umf_test(
+    NAME ctl_env_app
+    SRCS ctl/ctl_env_app.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} umf)
+
+file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/ctl/ctl_env_config1.cfg
+     DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/ctl)
+file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/ctl/ctl_env_config2.cfg
+     DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/ctl)
+file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/ctl/ctl_env_disjoint_pool.cfg
+     DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/ctl)
+
 add_umf_test(
-    NAME provider_coarse
-    SRCS provider_coarse.cpp ${BA_SOURCES_FOR_TEST}
+    NAME ctl_env_driver
+    SRCS ctl/ctl_env_driver.cpp
     LIBS ${UMF_UTILS_FOR_TEST})
 
-if(UMF_BUILD_LIBUMF_POOL_DISJOINT)
-    add_umf_test(
-        NAME disjointPool
-        SRCS pools/disjoint_pool.cpp malloc_compliance_tests.cpp
-        LIBS disjoint_pool)
-    add_umf_test(
-        NAME c_api_disjoint_pool
-        SRCS c_api/disjoint_pool.c
-        LIBS disjoint_pool)
+target_compile_definitions(
+    test_ctl_env_driver
+    PRIVATE CTL_ENV_APP="$<TARGET_FILE:test_ctl_env_app>"
+            CTL_CONF_FILE_DIR="${CMAKE_CURRENT_BINARY_DIR}/ctl")
+
+add_umf_test(
+    NAME coarse_lib
+    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
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+
+add_umf_test(
+    NAME disjoint_pool_ctl
+    SRCS pools/disjoint_pool_ctl.cpp malloc_compliance_tests.cpp
+         ${BA_SOURCES_FOR_TEST}
+    LIBS ${UMF_UTILS_FOR_TEST})
+
+add_umf_test(
+    NAME pool_null_params
+    SRCS test_pool_null_params.cpp
+    LIBS ${UMF_UTILS_FOR_TEST})
+
+add_umf_test(
+    NAME c_api_disjoint_pool
+    SRCS c_api/disjoint_pool.c
+    LIBS ${UMF_UTILS_FOR_TEST})
+
+if(LINUX)
+    # this test uses the file provider
     add_umf_test(
-        NAME disjointCoarseMallocPool
-        SRCS disjointCoarseMallocPool.cpp
-        LIBS disjoint_pool)
+        NAME disjoint_pool_file_prov
+        SRCS disjoint_pool_file_prov.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 endif()
 
-if(UMF_BUILD_LIBUMF_POOL_DISJOINT
-   AND UMF_POOL_JEMALLOC_ENABLED
-   AND UMF_POOL_SCALABLE_ENABLED
-   AND (NOT UMF_DISABLE_HWLOC))
-    add_umf_test(
-        NAME c_api_multi_pool
-        SRCS c_api/multi_pool.c
-        LIBS disjoint_pool jemalloc_pool ${JEMALLOC_LIBRARIES})
+if(UMF_POOL_JEMALLOC_ENABLED AND UMF_POOL_SCALABLE_ENABLED)
+    add_umf_test(NAME c_api_multi_pool SRCS c_api/multi_pool.c)
 endif()
 
-if(UMF_POOL_JEMALLOC_ENABLED AND (NOT UMF_DISABLE_HWLOC))
+if(UMF_POOL_JEMALLOC_ENABLED)
     add_umf_test(
         NAME jemalloc_pool
         SRCS pools/jemalloc_pool.cpp malloc_compliance_tests.cpp
-        LIBS jemalloc_pool)
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 endif()
 
-if(UMF_POOL_SCALABLE_ENABLED AND (NOT UMF_DISABLE_HWLOC))
+if(UMF_POOL_SCALABLE_ENABLED)
     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
-                                      # only for Linux now
+if(LINUX) # OS-specific functions are implemented
+    # only for Linux now
     if(PkgConfig_FOUND)
         pkg_check_modules(LIBNUMA numa)
     endif()
@@ -247,46 +331,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} ${LIB_JEMALLOC_POOL})
-    if(UMF_BUILD_LIBUMF_POOL_DISJOINT)
-        target_compile_definitions(umf_test-provider_os_memory
-                                   PRIVATE UMF_POOL_DISJOINT_ENABLED=1)
-        target_link_libraries(umf_test-provider_os_memory PRIVATE disjoint_pool)
-    endif()
-
+        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} ${LIBHWLOC_LIBRARIES})
+        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} ${LIBHWLOC_LIBRARIES})
+        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} ${LIBHWLOC_LIBRARIES})
+        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} ${LIBHWLOC_LIBRARIES})
+        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} ${LIBHWLOC_LIBRARIES})
+        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} ${LIBHWLOC_LIBRARIES})
+        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
@@ -294,34 +378,50 @@ if(LINUX AND (NOT UMF_DISABLE_HWLOC)) # OS-specific functions are implemented
     add_umf_test(
         NAME memtarget
         SRCS memspaces/memtarget.cpp
-        LIBS ${LIBNUMA_LIBRARIES} ${LIBHWLOC_LIBRARIES})
+        LIBS ${LIBNUMA_LIBRARIES} ${UMF_HWLOC_NAME})
     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} ${LIB_JEMALLOC_POOL})
+        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} ${LIB_JEMALLOC_POOL})
+        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} ${UMF_BA_FOR_TEST})
+    add_umf_test(
+        NAME provider_tracking
+        SRCS provider_tracking.cpp
+        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
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+    add_umf_test(
+        NAME provider_properties
+        SRCS properties/provider_properties.cpp
+        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
-            LIBS jemalloc_pool)
+            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
-            LIBS jemalloc_pool)
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     endif()
 
     # This test requires Linux-only file memory provider
@@ -329,57 +429,64 @@ 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(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND UMF_BUILD_FUZZTESTS)
+    if(UMF_BUILD_FUZZTESTS)
         add_subdirectory(fuzz)
     endif()
 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})
+if(UMF_BUILD_LEVEL_ZERO_PROVIDER)
+    add_umf_mocked_test(provider_level_zero_residency
+                        providers/provider_level_zero_residency.cpp)
+    add_umf_mocked_test(pool_residency pools/pool_residency.cpp)
 endif()
 
-if(UMF_BUILD_GPU_TESTS AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
+if(UMF_BUILD_GPU_TESTS AND UMF_LEVEL_ZERO_ENABLED)
     # we have two test binaries here that use the same sources, but differ in
     # the way they are linked to the Level Zero (statically or at runtime using
     # dlopen)
     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)
-    target_include_directories(umf_test-provider_level_zero
-                               PRIVATE ${LEVEL_ZERO_INCLUDE_DIRS})
+             ${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
+        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})
-    target_compile_definitions(umf_test-provider_level_zero_dlopen
-                               PUBLIC USE_DLOPEN=1)
-    target_include_directories(umf_test-provider_level_zero_dlopen
-                               PRIVATE ${LEVEL_ZERO_INCLUDE_DIRS})
+             ${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
+        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)
+
+    add_umf_test(
+        NAME provider_properties_level_zero
+        SRCS properties/provider_properties_level_zero.cpp
+             ${UMF_UTILS_DIR}/utils_level_zero.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ze_loader)
 endif()
 
 if(NOT UMF_BUILD_LEVEL_ZERO_PROVIDER)
@@ -397,26 +504,31 @@ 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)
-        target_include_directories(umf_test-provider_cuda
-                                   PRIVATE ${CUDA_INCLUDE_DIRS})
-        target_link_directories(umf_test-provider_cuda PRIVATE
-                                ${CUDA_LIBRARY_DIRS})
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} cuda)
 
         add_umf_test(
-            NAME provider_cuda_dlopen
+            NAME provider_cuda_dlopen_global
             SRCS providers/provider_cuda.cpp providers/cuda_helpers.cpp
-                 ${BA_SOURCES_FOR_TEST}
-            LIBS ${UMF_UTILS_FOR_TEST})
-        target_compile_definitions(umf_test-provider_cuda_dlopen
-                                   PUBLIC USE_DLOPEN=1)
-        target_include_directories(umf_test-provider_cuda_dlopen
-                                   PRIVATE ${CUDA_INCLUDE_DIRS})
+            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
+            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)
+
+        add_umf_test(
+            NAME provider_properties_cuda
+            SRCS properties/provider_properties_cuda.cpp
+                 providers/cuda_helpers.cpp
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} cuda)
     else()
         message(
             STATUS
-                "CUDA provdier tests requires CUDA libraries to be installed and added to the default library search path - skipping"
+                "CUDA provider tests requires CUDA libraries to be installed and added to the default library search path - skipping"
         )
     endif()
 endif()
@@ -430,56 +542,62 @@ 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 test_proxy_lib_size_threshold
-            SRCS ${BA_SOURCES_FOR_TEST} test_proxy_lib_size_threshold.cpp
+            NAME proxy_lib_size_threshold
+            SRCS test_proxy_lib_size_threshold.cpp
             LIBS ${UMF_UTILS_FOR_TEST} umf_proxy)
-        set_property(TEST umf-test_proxy_lib_size_threshold
+        set_property(TEST test_proxy_lib_size_threshold
                      PROPERTY ENVIRONMENT UMF_PROXY="size.threshold=64")
     endif()
 
     # 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)
-    target_compile_definitions(umf_test-proxy_lib_memoryPool
+        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
+    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)
 
 function(add_umf_ipc_test)
-    # Parameters: * TEST - a name of the test * SRC_DIR - source files directory
-    # path
+    # Parameters:
+    #
+    # * TEST - a name of the test
+    # * SRC_DIR - source files directory path
     set(oneValueArgs TEST SRC_DIR)
     cmake_parse_arguments(
         ARG
@@ -488,7 +606,7 @@ function(add_umf_ipc_test)
         ""
         ${ARGN})
 
-    set(TEST_NAME umf-${ARG_TEST})
+    set(TEST_NAME test_${ARG_TEST})
 
     if(DEFINED ARG_SRC_DIR)
         set(SRC_DIR ${ARG_SRC_DIR})
@@ -496,12 +614,37 @@ function(add_umf_ipc_test)
         set(SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR})
     endif()
 
-    file(COPY ${SRC_DIR}/${ARG_TEST}.sh DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+    if(WINDOWS)
+        set(EXT py)
+    else()
+        set(EXT sh)
+    endif()
 
-    add_test(
-        NAME ${TEST_NAME}
-        COMMAND ${ARG_TEST}.sh
-        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    file(COPY ${SRC_DIR}/${ARG_TEST}.${EXT}
+         DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+
+    if(WINDOWS)
+        add_test(
+            NAME ${TEST_NAME}
+            COMMAND python ${ARG_TEST}.${EXT}
+            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    else()
+        add_test(
+            NAME ${TEST_NAME}
+            COMMAND ${ARG_TEST}.${EXT}
+            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    endif()
+
+    if(WINDOWS)
+        set_tests_properties(${TEST_NAME} PROPERTIES
+                             ENVIRONMENT "BUILD_TYPE=${CMAKE_BUILD_TYPE}")
+        # add PATH to DLL on Windows
+        set(DLL_PATH_LIST
+            "${DLL_PATH_LIST};PATH=path_list_append:${CMAKE_BINARY_DIR}/bin/;PATH=path_list_append:${CMAKE_BINARY_DIR}/bin/$<CONFIG>/"
+        )
+        set_property(TEST ${TEST_NAME} PROPERTY ENVIRONMENT_MODIFICATION
+                                                "${DLL_PATH_LIST}")
+    endif()
 
     set_tests_properties(${TEST_NAME} PROPERTIES LABELS "umf")
     set_tests_properties(${TEST_NAME} PROPERTIES TIMEOUT 60)
@@ -510,155 +653,102 @@ function(add_umf_ipc_test)
     endif()
 endfunction()
 
+if(WINDOWS)
+    set(UMF_IPC_LIBS ws2_32)
+endif()
+
+if(UMF_BUILD_GPU_TESTS AND UMF_LEVEL_ZERO_ENABLED)
+    build_umf_test(
+        NAME ipc_level_zero_prov_consumer
+        SRCS providers/ipc_level_zero_prov_consumer.c common/ipc_common.c
+             providers/ipc_level_zero_prov_common.c
+             ${UMF_UTILS_DIR}/utils_level_zero.cpp
+        LIBS ze_loader ${UMF_IPC_LIBS} ${UMF_UTILS_FOR_TEST})
+    build_umf_test(
+        NAME ipc_level_zero_prov_producer
+        SRCS providers/ipc_level_zero_prov_producer.c common/ipc_common.c
+             providers/ipc_level_zero_prov_common.c
+             ${UMF_UTILS_DIR}/utils_level_zero.cpp
+        LIBS ze_loader ${UMF_IPC_LIBS} ${UMF_UTILS_FOR_TEST})
+    add_umf_ipc_test(TEST ipc_level_zero_prov SRC_DIR providers)
+endif()
+
+if(UMF_BUILD_GPU_TESTS AND UMF_BUILD_CUDA_PROVIDER)
+    build_umf_test(
+        NAME ipc_cuda_prov_consumer
+        SRCS providers/ipc_cuda_prov_consumer.c common/ipc_common.c
+             providers/ipc_cuda_prov_common.c providers/cuda_helpers.cpp
+        LIBS cuda ${UMF_IPC_LIBS} ${UMF_UTILS_FOR_TEST})
+    build_umf_test(
+        NAME ipc_cuda_prov_producer
+        SRCS providers/ipc_cuda_prov_producer.c common/ipc_common.c
+             providers/ipc_cuda_prov_common.c providers/cuda_helpers.cpp
+        LIBS cuda ${UMF_IPC_LIBS} ${UMF_UTILS_FOR_TEST})
+    add_umf_ipc_test(TEST ipc_cuda_prov SRC_DIR providers)
+endif()
+
+# TODO IPC tests for OS, file, devdax providers and proxy lib are supported only
+# on Linux - skipping
 if(LINUX)
-    if(NOT UMF_DISABLE_HWLOC AND UMF_POOL_SCALABLE_ENABLED)
+    if(UMF_POOL_SCALABLE_ENABLED)
         build_umf_test(
-            NAME
-            ipc_os_prov_consumer
-            SRCS
-            ipc_os_prov_consumer.c
-            common/ipc_common.c
-            common/ipc_os_prov_common.c)
+            NAME ipc_os_prov_consumer
+            SRCS ipc_os_prov_consumer.c common/ipc_common.c
+                 common/ipc_os_prov_common.c)
         build_umf_test(
-            NAME
-            ipc_os_prov_producer
-            SRCS
-            ipc_os_prov_producer.c
-            common/ipc_common.c
-            common/ipc_os_prov_common.c)
+            NAME ipc_os_prov_producer
+            SRCS ipc_os_prov_producer.c common/ipc_common.c
+                 common/ipc_os_prov_common.c)
         add_umf_ipc_test(TEST ipc_os_prov_anon_fd)
         add_umf_ipc_test(TEST ipc_os_prov_shm)
 
         if(UMF_PROXY_LIB_ENABLED AND UMF_BUILD_SHARED_LIBRARY)
             build_umf_test(
-                NAME
-                ipc_os_prov_proxy
-                SRCS
-                ipc_os_prov_proxy.c
-                common/ipc_common.c
-                LIBS
-                ${UMF_UTILS_FOR_TEST})
+                NAME ipc_os_prov_proxy
+                SRCS ipc_os_prov_proxy.c common/ipc_common.c
+                LIBS ${UMF_UTILS_FOR_TEST})
             add_umf_ipc_test(TEST ipc_os_prov_proxy)
         endif()
 
         build_umf_test(
-            NAME
-            ipc_devdax_prov_consumer
-            SRCS
-            ipc_devdax_prov_consumer.c
-            common/ipc_common.c
-            common/ipc_os_prov_common.c)
+            NAME ipc_devdax_prov_consumer
+            SRCS ipc_devdax_prov_consumer.c common/ipc_common.c
+                 common/ipc_os_prov_common.c)
         build_umf_test(
-            NAME
-            ipc_devdax_prov_producer
-            SRCS
-            ipc_devdax_prov_producer.c
-            common/ipc_common.c
-            common/ipc_os_prov_common.c)
+            NAME ipc_devdax_prov_producer
+            SRCS ipc_devdax_prov_producer.c common/ipc_common.c
+                 common/ipc_os_prov_common.c)
         add_umf_ipc_test(TEST ipc_devdax_prov)
 
         build_umf_test(
-            NAME
-            ipc_file_prov_consumer
-            SRCS
-            ipc_file_prov_consumer.c
-            common/ipc_common.c
-            common/ipc_os_prov_common.c)
+            NAME ipc_file_prov_consumer
+            SRCS ipc_file_prov_consumer.c common/ipc_common.c
+                 common/ipc_os_prov_common.c)
         build_umf_test(
-            NAME
-            ipc_file_prov_producer
-            SRCS
-            ipc_file_prov_producer.c
-            common/ipc_common.c
-            common/ipc_os_prov_common.c)
+            NAME ipc_file_prov_producer
+            SRCS ipc_file_prov_producer.c common/ipc_common.c
+                 common/ipc_os_prov_common.c)
         add_umf_ipc_test(TEST ipc_file_prov)
         add_umf_ipc_test(TEST ipc_file_prov_fsdax)
     endif()
 
-    # TODO add IPC tests for CUDA
-
-    if(UMF_BUILD_GPU_TESTS
-       AND UMF_BUILD_LEVEL_ZERO_PROVIDER
-       AND UMF_BUILD_LIBUMF_POOL_DISJOINT)
-        build_umf_test(
-            NAME
-            ipc_level_zero_prov_consumer
-            SRCS
-            providers/ipc_level_zero_prov_consumer.c
-            common/ipc_common.c
-            providers/ipc_level_zero_prov_common.c
-            ${UMF_UTILS_DIR}/utils_level_zero.cpp
-            LIBS
-            ze_loader
-            disjoint_pool
-            ${UMF_UTILS_FOR_TEST})
-        build_umf_test(
-            NAME
-            ipc_level_zero_prov_producer
-            SRCS
-            providers/ipc_level_zero_prov_producer.c
-            common/ipc_common.c
-            providers/ipc_level_zero_prov_common.c
-            ${UMF_UTILS_DIR}/utils_level_zero.cpp
-            LIBS
-            ze_loader
-            disjoint_pool
-            ${UMF_UTILS_FOR_TEST})
-        target_include_directories(umf_test-ipc_level_zero_prov_producer
-                                   PRIVATE ${LEVEL_ZERO_INCLUDE_DIRS})
-        target_include_directories(umf_test-ipc_level_zero_prov_consumer
-                                   PRIVATE ${LEVEL_ZERO_INCLUDE_DIRS})
-        add_umf_ipc_test(TEST ipc_level_zero_prov SRC_DIR providers)
-    endif()
-
-    if(UMF_BUILD_GPU_TESTS
-       AND UMF_BUILD_CUDA_PROVIDER
-       AND UMF_BUILD_LIBUMF_POOL_DISJOINT)
-        build_umf_test(
-            NAME
-            ipc_cuda_prov_consumer
-            SRCS
-            providers/ipc_cuda_prov_consumer.c
-            common/ipc_common.c
-            providers/ipc_cuda_prov_common.c
-            providers/cuda_helpers.cpp
-            LIBS
-            cuda
-            disjoint_pool
-            ${UMF_UTILS_FOR_TEST})
-        build_umf_test(
-            NAME
-            ipc_cuda_prov_producer
-            SRCS
-            providers/ipc_cuda_prov_producer.c
-            common/ipc_common.c
-            providers/ipc_cuda_prov_common.c
-            providers/cuda_helpers.cpp
-            LIBS
-            cuda
-            disjoint_pool
-            ${UMF_UTILS_FOR_TEST})
-        target_include_directories(umf_test-ipc_cuda_prov_producer
-                                   PRIVATE ${CUDA_INCLUDE_DIRS})
-        target_include_directories(umf_test-ipc_cuda_prov_consumer
-                                   PRIVATE ${CUDA_INCLUDE_DIRS})
-        add_umf_ipc_test(TEST ipc_cuda_prov SRC_DIR providers)
-    endif()
 else()
-    message(STATUS "IPC tests are supported on Linux only - skipping")
+    message(
+        STATUS
+            "IPC tests for OS, file, devdax providers and proxy lib are supported only on Linux - skipping"
+    )
 endif()
 
 if(LINUX
    AND UMF_BUILD_SHARED_LIBRARY
-   AND UMF_POOL_SCALABLE_ENABLED
-   AND NOT UMF_DISABLE_HWLOC)
+   AND UMF_POOL_SCALABLE_ENABLED)
     add_umf_test(
         NAME init_teardown
         SRCS test_init_teardown.c
         LIBS dl)
     # append LD_LIBRARY_PATH to the libumf
     set_property(
-        TEST umf-init_teardown
+        TEST test_init_teardown
         PROPERTY ENVIRONMENT_MODIFICATION
                  "LD_LIBRARY_PATH=path_list_append:${CMAKE_BINARY_DIR}/lib")
 endif()
@@ -667,6 +757,7 @@ endif()
 # replace test_examples.sh with CMake script?)
 if(LINUX
    AND UMF_BUILD_SHARED_LIBRARY
+   AND UMF_BUILD_EXAMPLES
    AND NOT
        (UMF_USE_ASAN
         OR UMF_USE_UBSAN
@@ -677,15 +768,15 @@ if(LINUX
     set(EXAMPLES "")
 
     if(UMF_POOL_SCALABLE_ENABLED)
-        set(EXAMPLES ${EXAMPLES} basic custom_file_provider)
+        set(EXAMPLES ${EXAMPLES} basic fetch_content custom_file_provider)
     else()
         message(
             STATUS
-                "The basic and custom_file_provider examples require TBB to be installed and added to the default library search path - skipping"
+                "The basic, fetch_content, and custom_file_provider examples require TBB to be installed and added to the default library search path - skipping"
         )
     endif()
 
-    if(LIBNUMA_LIBRARIES)
+    if(LIBNUMA_FOUND)
         set(EXAMPLES ${EXAMPLES} memspace_hmat memspace_numa)
     else()
         message(
@@ -694,41 +785,32 @@ if(LINUX
         )
     endif()
 
-    if(UMF_BUILD_GPU_EXAMPLES
-       AND UMF_BUILD_LIBUMF_POOL_DISJOINT
-       AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
+    if(UMF_BUILD_GPU_EXAMPLES AND UMF_LEVEL_ZERO_ENABLED)
         set(EXAMPLES ${EXAMPLES} level_zero_shared_memory)
     else()
         message(
             STATUS
-                "GPU level zero shared memory example requires UMF_BUILD_GPU_EXAMPLES, "
-                "UMF_BUILD_LEVEL_ZERO_PROVIDER and UMF_BUILD_LIBUMF_POOL_DISJOINT "
-                "to be turned ON - skipping")
+                "GPU level zero shared memory example requires UMF_BUILD_GPU_EXAMPLES and "
+                "UMF_BUILD_LEVEL_ZERO_PROVIDER to be turned ON - skipping")
     endif()
 
-    if(UMF_BUILD_GPU_EXAMPLES
-       AND UMF_BUILD_LIBUMF_POOL_DISJOINT
-       AND UMF_BUILD_CUDA_PROVIDER
-       AND UMF_CUDA_ENABLED)
+    if(UMF_BUILD_GPU_EXAMPLES AND UMF_CUDA_ENABLED)
         set(EXAMPLES ${EXAMPLES} cuda_shared_memory)
     else()
         message(
             STATUS
-                "GPU CUDA shared memory example requires UMF_BUILD_GPU_EXAMPLES, "
-                "UMF_BUILD_CUDA_PROVIDER, UMF_BUILD_LIBUMF_POOL_DISJOINT "
-                "to be turned ON and installed CUDA libraries - skipping")
+                "GPU CUDA shared memory example requires UMF_BUILD_GPU_EXAMPLES "
+                "and UMF_BUILD_CUDA_PROVIDER to be turned ON and installed CUDA "
+                "libraries - skipping")
     endif()
 
     # TODO add IPC examples for CUDA
-    if(UMF_BUILD_GPU_EXAMPLES
-       AND UMF_BUILD_LIBUMF_POOL_DISJOINT
-       AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
+    if(UMF_BUILD_GPU_EXAMPLES AND UMF_LEVEL_ZERO_ENABLED)
         set(EXAMPLES ${EXAMPLES} ipc_level_zero)
     else()
         message(
-            STATUS
-                "IPC Level 0 example requires UMF_BUILD_GPU_EXAMPLES, UMF_BUILD_LEVEL_ZERO_PROVIDER and UMF_BUILD_LIBUMF_POOL_DISJOINT to be turned ON - skipping"
-        )
+            STATUS "IPC Level Zero example requires UMF_BUILD_GPU_EXAMPLES and "
+                   "UMF_BUILD_LEVEL_ZERO_PROVIDER to be turned ON - skipping")
     endif()
 
     if(UMF_POOL_SCALABLE_ENABLED)
@@ -745,14 +827,21 @@ if(LINUX
     else()
         message(
             STATUS
-                "The dram_and_fsdax example is supported on Linux only and requires UMF_BUILD_LIBUMF_POOL_JEMALLOC to be turned ON - skipping"
+                "The dram_and_fsdax example is supported on Linux only and requires the jemalloc pool, but it is disabled - skipping"
         )
     endif()
 
-    if(EXAMPLES AND NOT UMF_DISABLE_HWLOC)
+    if(EXAMPLES)
         set(STANDALONE_CMAKE_OPTIONS
             "-DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
         )
+        if(JEMALLOC_INCLUDE_DIRS)
+            # add custom jemalloc installation
+            set(STANDALONE_CMAKE_OPTIONS
+                "${STANDALONE_CMAKE_OPTIONS} -DCMAKE_PREFIX_PATH=${JEMALLOC_INCLUDE_DIRS}/../"
+            )
+        endif()
+
         add_test(
             NAME umf-standalone_examples
             COMMAND
diff --git a/test/c_api/disjoint_pool.c b/test/c_api/disjoint_pool.c
index 4d4634def1..932e14c38c 100644
--- a/test/c_api/disjoint_pool.c
+++ b/test/c_api/disjoint_pool.c
@@ -1,10 +1,11 @@
-// 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 <stdlib.h>
 
-#include "pool_disjoint.h"
+#include <umf/pools/pool_disjoint.h>
+
 #include "provider_null.h"
 #include "test_helpers.h"
 #include "test_ut_asserts.h"
@@ -35,8 +36,9 @@ void test_disjoint_pool_shared_limits(void) {
     retp = umfDisjointPoolParamsCreate(&params);
     UT_ASSERTeq(retp, UMF_RESULT_SUCCESS);
 
-    umf_disjoint_pool_shared_limits_handle_t limits =
-        umfDisjointPoolSharedLimitsCreate(1024);
+    umf_disjoint_pool_shared_limits_handle_t limits;
+    retp = umfDisjointPoolSharedLimitsCreate(1024, &limits);
+    UT_ASSERTeq(retp, UMF_RESULT_SUCCESS);
     UT_ASSERTne(limits, NULL);
 
     retp = umfDisjointPoolParamsSetSharedLimits(params, limits);
@@ -47,8 +49,11 @@ void test_disjoint_pool_shared_limits(void) {
 
     umfPoolDestroy(pool);
     umfMemoryProviderDestroy(provider);
-    umfDisjointPoolSharedLimitsDestroy(limits);
-    umfDisjointPoolParamsDestroy(params);
+    retp = umfDisjointPoolSharedLimitsDestroy(limits);
+    UT_ASSERTeq(retp, UMF_RESULT_SUCCESS);
+
+    retp = umfDisjointPoolParamsDestroy(params);
+    UT_ASSERTeq(retp, UMF_RESULT_SUCCESS);
 }
 
 int main(void) {
diff --git a/test/c_api/multi_pool.c b/test/c_api/multi_pool.c
index bbd8383124..d9f3144d2a 100644
--- a/test/c_api/multi_pool.c
+++ b/test/c_api/multi_pool.c
@@ -1,4 +1,4 @@
-// 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
 
@@ -87,7 +87,10 @@ int main(void) {
     }
 
     for (int i = 0; i < 4; i++) {
-        UT_ASSERTeq(umfPoolByPtr(ptrs[i]), pools[i]);
+        umf_memory_pool_handle_t pool = NULL;
+        ret = umfPoolByPtr(ptrs[i], &pool);
+        UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
+        UT_ASSERTeq(pool, pools[i]);
     }
 
     for (int i = 0; i < 4; i++) {
diff --git a/test/c_api/test_ut_asserts.h b/test/c_api/test_ut_asserts.h
index 834d39bda8..b73f0cd19e 100644
--- a/test/c_api/test_ut_asserts.h
+++ b/test/c_api/test_ut_asserts.h
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -9,7 +9,7 @@
 
 /*
  The project uses GTEST framework for testing, which is not supported in C
- These asserts should NOT be used in other purposes than for testing C API 
+ These asserts should NOT be used in other purposes than for testing C API
  */
 
 #ifndef UMF_TEST_UT_ASSERTS_H
diff --git a/test/coarse_lib.cpp b/test/coarse_lib.cpp
new file mode 100644
index 0000000000..598df11ca2
--- /dev/null
+++ b/test/coarse_lib.cpp
@@ -0,0 +1,1383 @@
+/*
+ * 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
+*/
+
+#include "coarse.h"
+#include "provider.hpp"
+
+using umf_test::KB;
+using umf_test::MB;
+using umf_test::test;
+
+#define MOCKED_COARSE ((coarse_t *)0x01)
+#define MOCKED_PROVIDER ((umf_memory_provider_handle_t)0x02)
+#define INVALID_PTR ((void *)0x03)
+
+static umf_result_t alloc_cb(void *provider, size_t size, size_t alignment,
+                             void **ptr) {
+    return umfMemoryProviderAlloc((umf_memory_provider_handle_t)provider, size,
+                                  alignment, ptr);
+}
+
+static umf_result_t free_cb(void *provider, void *ptr, size_t size) {
+    return umfMemoryProviderFree((umf_memory_provider_handle_t)provider, ptr,
+                                 size);
+}
+
+static umf_result_t split_cb(void *provider, void *ptr, size_t totalSize,
+                             size_t firstSize) {
+    if (provider == NULL || ptr == NULL || (firstSize >= totalSize) ||
+        firstSize == 0 || totalSize == 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t merge_cb(void *provider, void *lowPtr, void *highPtr,
+                             size_t totalSize) {
+    if (provider == NULL || lowPtr == NULL || highPtr == NULL ||
+        totalSize == 0 || ((uintptr_t)highPtr <= (uintptr_t)lowPtr) ||
+        ((uintptr_t)highPtr - (uintptr_t)lowPtr >= totalSize)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t alloc_cb_fails(void *provider, size_t size,
+                                   size_t alignment, void **ptr) {
+    (void)provider;  //unused
+    (void)size;      //unused
+    (void)alignment; //unused
+    (void)ptr;       //unused
+    return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+}
+
+static umf_result_t split_cb_fails(void *provider, void *ptr, size_t totalSize,
+                                   size_t firstSize) {
+    (void)provider;  //unused
+    (void)ptr;       //unused
+    (void)totalSize; //unused
+    (void)firstSize; //unused
+    return UMF_RESULT_ERROR_USER_SPECIFIC;
+}
+
+static umf_result_t merge_cb_fails(void *provider, void *lowPtr, void *highPtr,
+                                   size_t totalSize) {
+    (void)provider;  //unused
+    (void)lowPtr;    //unused
+    (void)highPtr;   //unused
+    (void)totalSize; //unused
+    return UMF_RESULT_ERROR_USER_SPECIFIC;
+}
+
+static void coarse_params_set_default(coarse_params_t *coarse_params,
+                                      umf_memory_provider_handle_t provider,
+                                      coarse_strategy_t allocation_strategy) {
+    memset(coarse_params, 0, sizeof(*coarse_params));
+    coarse_params->provider = provider;
+    coarse_params->allocation_strategy = allocation_strategy;
+    coarse_params->cb.split = split_cb;
+    coarse_params->cb.merge = merge_cb;
+    coarse_params->page_size = utils_get_page_size();
+
+    if (provider) {
+        coarse_params->cb.alloc = alloc_cb;
+        coarse_params->cb.free = free_cb;
+    }
+}
+
+umf_memory_provider_ops_t UMF_MALLOC_MEMORY_PROVIDER_OPS =
+    umf_test::providerMakeCOps<umf_test::provider_ba_global, void>();
+
+struct CoarseWithMemoryStrategyTest
+    : umf_test::test,
+      ::testing::WithParamInterface<coarse_strategy_t> {
+    void SetUp() override {
+        test::SetUp();
+        allocation_strategy = this->GetParam();
+        coarse_params_set_default(&coarse_params, MOCKED_PROVIDER,
+                                  allocation_strategy);
+    }
+
+    coarse_t *coarse_handle = nullptr;
+    coarse_params_t coarse_params;
+    coarse_strategy_t allocation_strategy;
+    umf_result_t umf_result;
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    CoarseWithMemoryStrategyTest, CoarseWithMemoryStrategyTest,
+    ::testing::Values(UMF_COARSE_MEMORY_STRATEGY_FASTEST,
+                      UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE,
+                      UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE),
+    ([](auto const &info) -> std::string {
+        static const char *names[] = {
+            "UMF_COARSE_MEMORY_STRATEGY_FASTEST",
+            "UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE",
+            "UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE"};
+        return names[info.index];
+    }));
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_provider) {
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    const size_t alloc_size = 20 * MB;
+    void *ptr;
+
+    umf_result = coarse_add_memory_from_provider(ch, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    umf_result = coarse_free(ch, ptr, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // test double free
+    umf_result = coarse_free(ch, ptr, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    coarse_delete(ch);
+    umf_result = umfMemoryProviderDestroy(malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_fixed_memory) {
+    // preallocate some memory and initialize the vector with zeros
+    const size_t buff_size = 20 * MB + coarse_params.page_size;
+    std::vector<char> buffer(buff_size, 0);
+    void *buf = (void *)ALIGN_UP_SAFE((uintptr_t)buffer.data(),
+                                      coarse_params.page_size);
+    ASSERT_NE(buf, nullptr);
+
+    coarse_params.cb.alloc = NULL;
+    coarse_params.cb.free = NULL;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    char *ptr = nullptr;
+
+    umf_result = coarse_add_memory_fixed(ch, buf, buff_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    umf_result = coarse_free(ch, ptr, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // test double free
+    umf_result = coarse_free(ch, ptr, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    coarse_delete(ch);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_fixed_memory_various) {
+    // preallocate some memory and initialize the vector with zeros
+    const size_t buff_size = 20 * MB + coarse_params.page_size;
+    std::vector<char> buffer(buff_size, 0);
+    void *buf = (void *)ALIGN_UP_SAFE((uintptr_t)buffer.data(),
+                                      coarse_params.page_size);
+    ASSERT_NE(buf, nullptr);
+
+    coarse_params.cb.alloc = NULL;
+    coarse_params.cb.free = NULL;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    char *ptr = nullptr;
+
+    umf_result = coarse_add_memory_fixed(ch, buf, buff_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // free NULL
+    umf_result = coarse_free(ch, nullptr, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // free invalid pointer
+    umf_result = coarse_free(ch, INVALID_PTR, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // wrong alignment (3 bytes)
+    ptr = nullptr;
+    umf_result = coarse_alloc(ch, 2 * MB, 3, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ALIGNMENT);
+    ASSERT_EQ(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // not freed allocation
+    // coarse_delete() prints LOG_WARN() in Debug mode
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    coarse_delete(ch);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_merge) {
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    char *ptr = nullptr;
+    const size_t alloc_size = 20 * MB;
+
+    umf_result = coarse_add_memory_from_provider(ch, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    /* test coarse_split */
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    umf_result = coarse_split(ch, ptr, 2 * MB, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    umf_result = coarse_free(ch, (ptr + 1 * MB), 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 1 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    umf_result = coarse_free(ch, ptr, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    /* test coarse_merge */
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    umf_result = coarse_split(ch, ptr, 2 * MB, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    umf_result = coarse_merge(ch, ptr, (ptr + 1 * MB), 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    umf_result = coarse_free(ch, ptr, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    coarse_delete(coarse_handle);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+// negative tests
+
+// NULL parameters
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_no_params) {
+    umf_result = coarse_new(nullptr, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_handle, nullptr);
+}
+
+// no provider
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_no_provider) {
+    coarse_params.provider = NULL;
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_handle, nullptr);
+}
+
+// no page size
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_no_page_size) {
+    coarse_params.page_size = 0;
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_handle, nullptr);
+}
+
+// no split callback
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_no_split_cb) {
+    coarse_params.cb.split = NULL;
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_handle, nullptr);
+}
+
+// no merge callback
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_no_merge_cb) {
+    coarse_params.cb.merge = NULL;
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_handle, nullptr);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_alloc_invalid) {
+    void *ptr = nullptr;
+
+    umf_result = coarse_alloc(nullptr, MB, 0, nullptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(ptr, nullptr);
+
+    umf_result = coarse_alloc(nullptr, MB, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(ptr, nullptr);
+
+    umf_result = coarse_alloc(MOCKED_COARSE, MB, 0, nullptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(ptr, nullptr);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_free_invalid) {
+    // coarse handle is NULL
+    umf_result = coarse_free(nullptr, nullptr, MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_delete_null) {
+    coarse_delete(nullptr);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest,
+       coarseTest_add_memory_from_provider_null_0) {
+    umf_result = coarse_add_memory_from_provider(nullptr, 0);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_add_memory_fixed_null_0) {
+    umf_result = coarse_add_memory_fixed(nullptr, nullptr, 0);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_null_stats) {
+    ASSERT_EQ(coarse_get_stats(nullptr).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(nullptr).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(nullptr).num_all_blocks, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(nullptr).num_free_blocks, (size_t)0);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_merge_negative) {
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    char *ptr = nullptr;
+    const size_t alloc_size = 20 * MB;
+
+    umf_result = coarse_add_memory_from_provider(ch, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    /* test coarse_split */
+
+    umf_result = coarse_alloc(ch, 6 * MB, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 6 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    // firstSize >= totalSize
+    umf_result = coarse_split(ch, ptr, 6 * MB, 6 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // firstSize == 0
+    umf_result = coarse_split(ch, ptr, 6 * MB, 0);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // totalSize == 0
+    umf_result = coarse_split(ch, ptr, 0, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // wrong totalSize
+    umf_result = coarse_split(ch, ptr, 5 * MB, 1 * KB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // memory block not found
+    umf_result = coarse_split(ch, ptr + 1, 6 * MB, 1 * KB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result = coarse_free(ch, ptr, 6 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // split freed block
+    umf_result = coarse_split(ch, ptr, alloc_size, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    /* test coarse_merge */
+
+    umf_result = coarse_alloc(ch, 6 * MB, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 6 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    // split (6 * MB) block into (1 * MB) + (5 * MB)
+    umf_result = coarse_split(ch, ptr, 6 * MB, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 6 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    // split (5 * MB) block into (2 * MB) + (3 * MB)
+    umf_result = coarse_split(ch, (ptr + 1 * MB), 5 * MB, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 6 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)4);
+
+    // now we have 3 used blocks: (1 * MB) + (2 * MB) + (3 * MB)
+
+    // highPtr <= lowPtr
+    umf_result = coarse_merge(ch, (ptr + 1 * MB), ptr, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // highPtr - lowPtr >= totalSize
+    umf_result = coarse_merge(ch, ptr, (ptr + 1 * MB), 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // low ptr does not exist
+    umf_result = coarse_merge(ch, ptr + 1, (ptr + 1 * MB), 3 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // high ptr does not exist
+    umf_result = coarse_merge(ch, ptr, (ptr + 1 * MB + 1), 3 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // low_block->size + high_block->size != totalSize
+    umf_result = coarse_merge(ch, ptr, (ptr + 1 * MB), 5 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // not adjacent blocks
+    umf_result = coarse_merge(ch, ptr, (ptr + 3 * MB), 4 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // free the 2 MB block in the middle
+    umf_result = coarse_free(ch, (ptr + 1 * MB), 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 4 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)4);
+
+    // now we have 3 blocks: (1 * MB) used + (2 * MB) freed + (3 * MB) used
+
+    // the low ptr block is not allocated
+    umf_result = coarse_merge(ch, (ptr + 1 * MB), (ptr + 3 * MB), 5 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // the high ptr block is not allocated
+    umf_result = coarse_merge(ch, ptr, (ptr + 1 * MB), 3 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result = coarse_free(ch, ptr, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 3 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    umf_result = coarse_free(ch, (ptr + 3 * MB), 3 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    coarse_delete(coarse_handle);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_alloc_cb_fails) {
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+    coarse_params.cb.alloc = alloc_cb_fails;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    const size_t alloc_size = 20 * MB;
+
+    umf_result = coarse_add_memory_from_provider(ch, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    coarse_delete(ch);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_cb_fails) {
+    if (coarse_params.allocation_strategy ==
+        UMF_COARSE_MEMORY_STRATEGY_FASTEST) {
+        // This test is designed for the UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE
+        // and UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE strategies,
+        // because the UMF_COARSE_MEMORY_STRATEGY_FASTEST strategy
+        // looks always for a block of size greater by the page size.
+        return;
+    }
+
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+    coarse_params.cb.split = split_cb_fails;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    void *ptr = nullptr;
+    const size_t alloc_size = 20 * MB;
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    umf_result = coarse_add_memory_from_provider(ch, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // coarse_alloc(alloc_size / 2, alignment = 0)
+    umf_result = coarse_alloc(ch, alloc_size / 2, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_USER_SPECIFIC);
+    ASSERT_EQ(ptr, nullptr);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // coarse_alloc(alloc_size / 2, alignment = 2 * MB)
+    umf_result = coarse_alloc(ch, alloc_size / 2, 2 * MB, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_USER_SPECIFIC);
+    ASSERT_EQ(ptr, nullptr);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // coarse_alloc(alloc_size, alignment = 0) - OK
+    umf_result = coarse_alloc(ch, alloc_size, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    umf_result = coarse_split(ch, ptr, alloc_size, alloc_size / 2);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_USER_SPECIFIC);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    umf_result = coarse_free(ch, ptr, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    coarse_delete(coarse_handle);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_merge_cb_fails) {
+    // preallocate some memory and initialize the vector with zeros
+    const size_t buff_size = 10 * MB + coarse_params.page_size;
+    std::vector<char> buffer(buff_size, 0);
+    void *buf = (void *)ALIGN_UP_SAFE((uintptr_t)buffer.data(),
+                                      coarse_params.page_size);
+    ASSERT_NE(buf, nullptr);
+
+    coarse_params.cb.alloc = NULL;
+    coarse_params.cb.free = NULL;
+    coarse_params.cb.merge = merge_cb_fails;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    char *ptr = nullptr;
+
+    umf_result = coarse_add_memory_fixed(ch, buf, buff_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    /* test coarse_merge */
+    umf_result = coarse_alloc(ch, 3 * MB, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 3 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    umf_result = coarse_split(ch, ptr, 3 * MB, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 3 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    umf_result = coarse_merge(ch, ptr, (ptr + 1 * MB), 3 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_USER_SPECIFIC);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 3 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    umf_result = coarse_free(ch, ptr, 3 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 3 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    umf_result = coarse_free(ch, ptr, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    umf_result = coarse_free(ch, (ptr + 1 * MB), 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    coarse_delete(coarse_handle);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_fixed_memory_alloc_set) {
+    // preallocate some memory and initialize the vector with zeros
+    const size_t buff_size = 20 * MB;
+    std::vector<char> buffer(buff_size, 0);
+    void *buf = (void *)buffer.data();
+    ASSERT_NE(buf, nullptr);
+
+    coarse_params.cb.free = NULL;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    umf_result = coarse_add_memory_fixed(ch, buf, buff_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    coarse_delete(ch);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_fixed_memory_free_set) {
+    // preallocate some memory and initialize the vector with zeros
+    const size_t buff_size = 20 * MB;
+    std::vector<char> buffer(buff_size, 0);
+    void *buf = (void *)buffer.data();
+    ASSERT_NE(buf, nullptr);
+
+    coarse_params.cb.alloc = NULL;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    umf_result = coarse_add_memory_fixed(ch, buf, buff_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    coarse_delete(ch);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_fixed_memory_alloc_free_set) {
+    // preallocate some memory and initialize the vector with zeros
+    const size_t buff_size = 20 * MB;
+    std::vector<char> buffer(buff_size, 0);
+    void *buf = (void *)buffer.data();
+    ASSERT_NE(buf, nullptr);
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    umf_result = coarse_add_memory_fixed(ch, buf, buff_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    coarse_delete(ch);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_provider_alloc_not_set) {
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+    coarse_params.cb.alloc = NULL;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    const size_t alloc_size = 20 * MB;
+    void *ptr;
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    umf_result = coarse_add_memory_from_provider(ch, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    umf_result = coarse_alloc(ch, 2 * MB, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY);
+    ASSERT_EQ(ptr, nullptr);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    umf_result = coarse_alloc(ch, 2 * MB, 2 * MB, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY);
+    ASSERT_EQ(ptr, nullptr);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    coarse_delete(ch);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic) {
+    if (coarse_params.allocation_strategy ==
+        UMF_COARSE_MEMORY_STRATEGY_FASTEST) {
+        // This test is designed for the UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE
+        // and UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE strategies,
+        // because the UMF_COARSE_MEMORY_STRATEGY_FASTEST strategy
+        // looks always for a block of size greater by the page size.
+        return;
+    }
+
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    const size_t init_buffer_size = 20 * MB;
+    void *p1, *p2;
+
+    umf_result = coarse_add_memory_from_provider(ch, init_buffer_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // alloc 2x 2MB
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&p1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(p1, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&p2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(p2, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 4 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+    ASSERT_NE(p1, p2);
+
+    // swap pointers to get p1 < p2
+    if (p1 > p2) {
+        std::swap(p1, p2);
+    }
+
+    // free + alloc first block
+    // the block should be reused
+    // currently there is no purging, so the alloc size shouldn't change
+    // there should be no block merging between used and not-used blocks
+    umf_result = coarse_free(ch, p1, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&p1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(p1, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 4 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    // free all allocs
+    // overall alloc size shouldn't change
+    // block p2 should merge with the prev free block p1
+    // and the remaining init block
+    umf_result = coarse_free(ch, p1, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+    umf_result = coarse_free(ch, p2, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // test allocations with alignment
+    // TODO: what about holes?
+    umf_result = coarse_alloc(ch, 1 * MB - 4, 128, (void **)&p1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(p1, nullptr);
+    ASSERT_EQ((uintptr_t)p1 & 127, 0ULL);
+
+    umf_result = coarse_alloc(ch, 1 * MB - 4, 128, (void **)&p2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(p2, nullptr);
+    ASSERT_EQ((uintptr_t)p2 & 127, 0ULL);
+
+    umf_result = coarse_free(ch, p1, 1 * MB - 4);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = coarse_free(ch, p2, 1 * MB - 4);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // alloc whole buffer
+    // after this, there should be one single block
+    umf_result = coarse_alloc(ch, init_buffer_size, 0, (void **)&p1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(p1, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // free all memory
+    umf_result = coarse_free(ch, p1, init_buffer_size);
+
+    // alloc 2 MB block - the init block should be split
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&p1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(p1, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    // alloc additional 2 MB
+    // the non-used block should be used
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&p2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(p2, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 4 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+    ASSERT_NE(p1, p2);
+
+    // make sure that p1 < p2
+    if (p1 > p2) {
+        std::swap(p1, p2);
+    }
+
+    // free blocks in order: p2, p1
+    // block p1 should merge with the next block p2
+    // swap pointers to get p1 < p2
+    coarse_free(ch, p2, 2 * MB);
+    coarse_free(ch, p1, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // alloc 10x 2 MB - this should occupy all allocated memory
+    constexpr size_t allocs_size = 10;
+    void *allocs[allocs_size] = {0};
+    for (size_t i = 0; i < allocs_size; i++) {
+        ASSERT_EQ(coarse_get_stats(ch).used_size, i * 2 * MB);
+        umf_result = coarse_alloc(ch, 2 * MB, 0, &allocs[i]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ASSERT_NE(allocs[i], nullptr);
+    }
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 20 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    // there should be no block with the free memory
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, allocs_size);
+
+    // free all memory
+    for (size_t i = 0; i < allocs_size; i++) {
+        umf_result = coarse_free(ch, allocs[i], 2 * MB);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+
+    coarse_delete(ch);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_simple1) {
+    if (coarse_params.allocation_strategy ==
+        UMF_COARSE_MEMORY_STRATEGY_FASTEST) {
+        // This test is designed for the UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE
+        // and UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE strategies,
+        // because the UMF_COARSE_MEMORY_STRATEGY_FASTEST strategy
+        // looks always for a block of size greater by the page size.
+        return;
+    }
+
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    const size_t init_buffer_size = 20 * MB;
+
+    umf_result = coarse_add_memory_from_provider(ch, init_buffer_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // test 1
+
+    size_t s1 = 74659 * KB;
+    size_t s2 = 8206 * KB;
+
+    size_t max_alloc_size = 0;
+
+    const int nreps = 2;
+    const int nptrs = 6;
+
+    // s1
+    for (int j = 0; j < nreps; j++) {
+        void *t[nptrs] = {0};
+        for (int i = 0; i < nptrs; i++) {
+            umf_result = coarse_alloc(ch, s1, 0, &t[i]);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+            ASSERT_NE(t[i], nullptr);
+        }
+
+        size_t alloc_size = coarse_get_stats(ch).alloc_size;
+        if (alloc_size > max_alloc_size) {
+            max_alloc_size = alloc_size;
+        }
+
+        for (int i = 0; i < nptrs; i++) {
+            umf_result = coarse_free(ch, t[i], s1);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+    }
+
+    // s2
+    for (int j = 0; j < nreps; j++) {
+        void *t[nptrs] = {0};
+        for (int i = 0; i < nptrs; i++) {
+            umf_result = coarse_alloc(ch, s2, 0, &t[i]);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+            ASSERT_NE(t[i], nullptr);
+        }
+
+        // all s2 should fit into single block leaved after freeing s1
+        ASSERT_LE(coarse_get_stats(ch).alloc_size, max_alloc_size);
+
+        for (int i = 0; i < nptrs; i++) {
+            umf_result = coarse_free(ch, t[i], s2);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+    }
+
+    coarse_delete(ch);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_simple2) {
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    const size_t init_buffer_size = 20 * MB;
+
+    umf_result = coarse_add_memory_from_provider(ch, init_buffer_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // test
+    double sizes[] = {2, 4, 0.5, 1, 8, 0.25};
+    size_t alignment[] = {0, 4, 0, 16, 32, 128};
+    for (int i = 0; i < 6; i++) {
+        size_t s = (size_t)(sizes[i] * MB);
+        void *t[8] = {0};
+        for (int j = 0; j < 8; j++) {
+            umf_result = coarse_alloc(ch, s, alignment[i], &t[j]);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+            ASSERT_NE(t[j], nullptr);
+        }
+
+        for (int j = 0; j < 8; j++) {
+            umf_result = coarse_free(ch, t[j], s);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+    }
+
+    coarse_delete(ch);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_alignment_provider) {
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    const size_t alloc_size = 40 * MB;
+
+    umf_result = coarse_add_memory_from_provider(ch, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    const int niter = 10;
+    const size_t size = 1 * MB;
+    void *ptr[niter] = {0};
+
+    for (int i = 0; i < niter; i++) {
+        umf_result = coarse_alloc(ch, size, 0, &ptr[i]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ptr[i], nullptr);
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, niter * size);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)(niter + 1));
+
+    for (int i = 0; i < niter; i += 2) {
+        umf_result = coarse_free(ch, ptr[i], size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ptr[i] = nullptr;
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, niter * size / 2);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)(niter + 1));
+
+    for (int i = 0; i < niter; i += 2) {
+        ASSERT_EQ(ptr[i], nullptr);
+        umf_result = coarse_alloc(ch, size, 2 * MB, &ptr[i]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ptr[i], nullptr);
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, niter * size);
+
+    for (int i = 0; i < niter; i++) {
+        umf_result = coarse_free(ch, ptr[i], size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    coarse_delete(ch);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_alignment_fixed_memory) {
+    // preallocate some memory and initialize the vector with zeros
+    const size_t alloc_size = 40 * MB + coarse_params.page_size;
+    std::vector<char> buffer(alloc_size, 0);
+    void *buf = (void *)ALIGN_UP_SAFE((uintptr_t)buffer.data(),
+                                      coarse_params.page_size);
+    ASSERT_NE(buf, nullptr);
+
+    coarse_params.cb.alloc = NULL;
+    coarse_params.cb.free = NULL;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+
+    umf_result = coarse_add_memory_fixed(ch, buf, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    const int niter = 10;
+    const size_t size = 1 * MB;
+    void *ptr[niter] = {0};
+
+    for (int i = 0; i < niter; i++) {
+        umf_result = coarse_alloc(ch, size, 0, &ptr[i]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ptr[i], nullptr);
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, niter * size);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)(niter + 1));
+
+    for (int i = 0; i < niter; i += 2) {
+        umf_result = coarse_free(ch, ptr[i], size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ptr[i] = nullptr;
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, niter * size / 2);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)(niter + 1));
+
+    for (int i = 0; i < niter; i += 2) {
+        ASSERT_EQ(ptr[i], nullptr);
+        umf_result = coarse_alloc(ch, size, 2 * MB, &ptr[i]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ptr[i], nullptr);
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, niter * size);
+
+    for (int i = 0; i < niter; i++) {
+        umf_result = coarse_free(ch, ptr[i], size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    coarse_delete(ch);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest,
+       coarseTest_basic_non_aligned_fixed_memory) {
+    // preallocate some memory and initialize the vector with zeros
+    const size_t buff_size = 20 * MB + coarse_params.page_size;
+    std::vector<char> buffer(buff_size, 0);
+
+    void *buf_aligned = (void *)ALIGN_UP_SAFE((uintptr_t)buffer.data(),
+                                              coarse_params.page_size);
+    ASSERT_NE(buf_aligned, nullptr);
+
+    void *buf_non_aligned = (void *)((uintptr_t)buf_aligned + 64);
+    size_t buf_non_aligned_size =
+        buff_size - ((uintptr_t)buf_non_aligned - (uintptr_t)buffer.data());
+    buf_non_aligned_size =
+        ALIGN_DOWN(buf_non_aligned_size, coarse_params.page_size);
+
+    coarse_params.cb.alloc = NULL;
+    coarse_params.cb.free = NULL;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    char *ptr = nullptr;
+
+    umf_result =
+        coarse_add_memory_fixed(ch, buf_non_aligned, buf_non_aligned_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buf_non_aligned_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    umf_result = coarse_alloc(ch, buf_non_aligned_size, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY);
+    ASSERT_EQ(ptr, nullptr);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buf_non_aligned_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    coarse_delete(ch);
+}
diff --git a/test/common/CMakeLists.txt b/test/common/CMakeLists.txt
index 6cffe5cfe8..da6817223b 100644
--- a/test/common/CMakeLists.txt
+++ b/test/common/CMakeLists.txt
@@ -1,4 +1,4 @@
-# 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
 
@@ -20,3 +20,21 @@ add_umf_library(
 
 target_include_directories(umf_test_common
                            PRIVATE ${UMF_CMAKE_SOURCE_DIR}/include)
+
+if(UMF_BUILD_LEVEL_ZERO_PROVIDER)
+    add_library(umf_test_mocks STATIC level_zero_mocks.cpp)
+    target_link_libraries(umf_test_mocks GTest::gmock umf_utils)
+    target_include_directories(
+        umf_test_mocks PUBLIC ${UMF_CMAKE_SOURCE_DIR}/include ${UMF_SRC_DIR}
+                              ${UMF_UTILS_DIR} ${LEVEL_ZERO_INCLUDE_DIRS})
+
+    add_umf_library(
+        NAME umf_ze_loopback
+        TYPE SHARED
+        SRCS ze_loopback.cpp
+        LINUX_MAP_FILE ${CMAKE_CURRENT_SOURCE_DIR}/ze_loopback.map
+        WINDOWS_DEF_FILE ${CMAKE_CURRENT_SOURCE_DIR}/ze_loopback.def)
+
+    target_include_directories(umf_ze_loopback
+                               PUBLIC ${LEVEL_ZERO_INCLUDE_DIRS})
+endif()
diff --git a/test/common/fork_helpers.hpp b/test/common/fork_helpers.hpp
new file mode 100644
index 0000000000..3887f97034
--- /dev/null
+++ b/test/common/fork_helpers.hpp
@@ -0,0 +1,76 @@
+/*
+ * 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
+ */
+
+#pragma once
+
+#include "umf.h"
+#include <gtest/gtest.h>
+
+#include <type_traits>
+#include <utility>
+
+#ifndef _WIN32
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#endif
+
+namespace umf_test {
+
+constexpr int ForkedTestSuccess = 0;
+constexpr int ForkedTestFailure = 1;
+constexpr int ForkedTestSkip = 77;
+
+template <typename Func> void run_in_fork(Func &&func) {
+#ifndef _WIN32
+    static_assert(std::is_invocable_r_v<void, Func &&>,
+                  "run_in_fork requires a void-returning callable");
+
+    pid_t pid = fork();
+    ASSERT_NE(pid, -1) << "fork failed";
+
+    if (pid == 0) {
+        std::forward<Func>(func)();
+
+        auto *unit = ::testing::UnitTest::GetInstance();
+        const ::testing::TestInfo *info =
+            unit ? unit->current_test_info() : nullptr;
+        const ::testing::TestResult *result = info ? info->result() : nullptr;
+
+        if (result != nullptr) {
+            if (result->Skipped()) {
+                _exit(ForkedTestSkip);
+            }
+            if (result->Failed()) {
+                _exit(ForkedTestFailure);
+            }
+        }
+        umfTearDown(); // exit not call destructor so we need to call it manually
+        _exit(ForkedTestSuccess);
+    }
+
+    int status = 0;
+    ASSERT_EQ(waitpid(pid, &status, 0), pid) << "waitpid failed";
+
+    if (!WIFEXITED(status)) {
+        FAIL() << "Forked test terminated abnormally.";
+    }
+
+    int exit_code = WEXITSTATUS(status);
+    if (exit_code == ForkedTestSkip) {
+        GTEST_SKIP() << "Forked test body requested skip.";
+    }
+
+    ASSERT_EQ(exit_code, ForkedTestSuccess)
+        << "Forked test exited with code " << exit_code;
+#else
+    (void)func;
+    GTEST_SKIP() << "Fork-based tests are not supported on Windows.";
+#endif
+}
+
+} // namespace umf_test
diff --git a/test/common/ipc_common.c b/test/common/ipc_common.c
index 140927079b..879d392868 100644
--- a/test/common/ipc_common.c
+++ b/test/common/ipc_common.c
@@ -1,16 +1,25 @@
 /*
- * 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
  */
 
+#ifdef _WIN32
+#define _WINSOCK_DEPRECATED_NO_WARNINGS
+#include <winsock2.h>
+typedef int socklen_t;
+typedef SSIZE_T ssize_t;
+#else
 #include <arpa/inet.h>
+#include <sys/prctl.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#endif
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/socket.h>
-#include <unistd.h>
 
 #include "ipc_common.h"
 
@@ -52,25 +61,39 @@ Generally communication between the producer and the consumer looks like:
 */
 
 int consumer_connect(int port) {
+
+#ifdef _WIN32
+    WSADATA wsaData;
+    SOCKET producer_socket, consumer_socket;
+#else
+    int producer_socket = -1;
+    int consumer_socket = -1;
+#endif
+
     struct sockaddr_in consumer_addr;
     struct sockaddr_in producer_addr;
     int producer_addr_len;
-    int producer_socket = -1;
-    int consumer_socket = -1;
-    int ret = -1;
+
+#ifdef _WIN32
+    // initialize Winsock
+    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
+        fprintf(stderr, "WSAStartup failed: %d\n", WSAGetLastError());
+        return -1;
+    }
+#endif
 
     // create a socket
     consumer_socket = socket(AF_INET, SOCK_STREAM, 0);
     if (consumer_socket < 0) {
         fprintf(stderr, "[consumer] ERROR: creating socket failed\n");
-        return -1;
+        goto err_WSA_cleanup;
     }
 
     fprintf(stderr, "[consumer] Socket created\n");
 
     // set the IP address and the port
     consumer_addr.sin_family = AF_INET;
-    consumer_addr.sin_port = htons(port);
+    consumer_addr.sin_port = htons((uint16_t)port);
     consumer_addr.sin_addr.s_addr = inet_addr(INET_ADDR);
 
     // bind to the IP address and the port
@@ -100,21 +123,39 @@ int consumer_connect(int port) {
     }
 
     fprintf(stderr, "[consumer] Producer connected at IP %s and port %i\n",
-            inet_ntoa(producer_addr.sin_addr), ntohs(producer_addr.sin_port));
+            inet_ntoa(producer_addr.sin_addr),
+            (int)ntohs(producer_addr.sin_port));
 
-    ret = producer_socket; // success
+    return (int)producer_socket; // success
 
 err_close_consumer_socket:
+#ifdef _WIN32
+    closesocket(consumer_socket);
+#else
     close(consumer_socket);
+#endif
 
-    return ret;
+err_WSA_cleanup:
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
+    return -1;
 }
 
-int run_consumer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
-                 umf_memory_provider_ops_t *provider_ops, void *provider_params,
-                 memcopy_callback_t memcopy_callback, void *memcopy_ctx) {
+int run_consumer(int port, const umf_memory_pool_ops_t *pool_ops,
+                 void *pool_params,
+                 const umf_memory_provider_ops_t *provider_ops,
+                 void *provider_params, memcopy_callback_t memcopy_callback,
+                 void *memcopy_ctx) {
     char consumer_message[MSG_SIZE];
+
+#ifdef _WIN32
+    SOCKET producer_socket;
+#else
     int producer_socket = -1;
+#endif
+
     int ret = -1;
     umf_memory_provider_handle_t provider = NULL;
     umf_result_t umf_result = UMF_RESULT_ERROR_UNKNOWN;
@@ -126,8 +167,7 @@ int run_consumer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
     umf_result =
         umfMemoryProviderCreate(provider_ops, provider_params, &provider);
     if (umf_result != UMF_RESULT_SUCCESS) {
-        fprintf(stderr,
-                "[consumer] ERROR: creating OS memory provider failed\n");
+        fprintf(stderr, "[consumer] ERROR: creating memory provider failed\n");
         return -1;
     }
 
@@ -169,8 +209,8 @@ int run_consumer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
             IPC_handle_size);
 
     // send confirmation to the producer (IPC handle size)
-    recv_len =
-        send(producer_socket, &IPC_handle_size, sizeof(IPC_handle_size), 0);
+    recv_len = send(producer_socket, (const char *)&IPC_handle_size,
+                    sizeof(IPC_handle_size), 0);
     if (recv_len < 0) {
         fprintf(stderr, "[consumer] ERROR: sending confirmation failed\n");
         goto err_free_recv_buffer;
@@ -212,8 +252,8 @@ int run_consumer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
         strcpy(consumer_message, "SKIP");
 
         // send the SKIP response to the producer
-        send(producer_socket, consumer_message, strlen(consumer_message) + 1,
-             0);
+        send(producer_socket, consumer_message,
+             (int)strlen(consumer_message) + 1, 0);
 
         goto err_free_recv_buffer;
     }
@@ -247,8 +287,8 @@ int run_consumer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
     strcpy(consumer_message, CONSUMER_MSG);
 
     // send response to the producer
-    if (send(producer_socket, consumer_message, strlen(consumer_message) + 1,
-             0) < 0) {
+    if (send(producer_socket, consumer_message,
+             (int)strlen(consumer_message) + 1, 0) < 0) {
         fprintf(stderr, "[consumer] ERROR: send() failed\n");
         goto err_closeIPCHandle;
     }
@@ -271,7 +311,12 @@ int run_consumer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
     free(recv_buffer);
 
 err_close_producer_socket:
+#ifdef _WIN32
+    closesocket(producer_socket);
+    WSACleanup();
+#else
     close(producer_socket);
+#endif
 
 err_umfMemoryPoolDestroy:
     umfPoolDestroy(pool);
@@ -293,20 +338,35 @@ int run_consumer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
 
 int producer_connect(int port) {
     struct sockaddr_in consumer_addr;
+
+#ifdef _WIN32
+    WSADATA wsaData;
+    SOCKET producer_socket;
+#else
     int producer_socket = -1;
+#endif
+
+#ifdef _WIN32
+    // initialize Winsock
+    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
+        fprintf(stderr, "WSAStartup failed. Error Code: %d\n",
+                WSAGetLastError());
+        return -1;
+    }
+#endif
 
     // create a producer socket
     producer_socket = socket(AF_INET, SOCK_STREAM, 0);
     if (producer_socket < 0) {
         fprintf(stderr, "[producer] ERROR: Unable to create socket\n");
-        return -1;
+        goto err_WSA_cleanup;
     }
 
     fprintf(stderr, "[producer] Socket created\n");
 
     // set IP address and port the same as for the consumer
     consumer_addr.sin_family = AF_INET;
-    consumer_addr.sin_port = htons(port);
+    consumer_addr.sin_port = htons((uint16_t)port);
     consumer_addr.sin_addr.s_addr = inet_addr(INET_ADDR);
 
     // send connection request to the consumer
@@ -319,30 +379,48 @@ int producer_connect(int port) {
 
     fprintf(stderr, "[producer] Connected to the consumer\n");
 
-    return producer_socket; // success
+    return (int)producer_socket; // success
 
 err_close_producer_socket_connect:
+#ifdef _WIN32
+    closesocket(producer_socket);
+#else
     close(producer_socket);
+#endif
+
+err_WSA_cleanup:
+#ifdef _WIN32
+    WSACleanup();
+#endif
 
     return -1;
 }
 
-int run_producer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
-                 umf_memory_provider_ops_t *provider_ops, void *provider_params,
-                 memcopy_callback_t memcopy_callback, void *memcopy_ctx) {
+int run_producer(int port, const umf_memory_pool_ops_t *pool_ops,
+                 void *pool_params,
+                 const umf_memory_provider_ops_t *provider_ops,
+                 void *provider_params, memcopy_callback_t memcopy_callback,
+                 void *memcopy_ctx) {
     int ret = -1;
     umf_memory_provider_handle_t provider = NULL;
     umf_result_t umf_result = UMF_RESULT_ERROR_UNKNOWN;
     int producer_socket = -1;
     char consumer_message[MSG_SIZE];
 
+#if !defined(_WIN32)
+    ret = prctl(PR_SET_PTRACER, getppid());
+    if (ret == -1) {
+        perror("PR_SET_PTRACER may be not supported. prctl() call failed");
+        goto err_end;
+    }
+#endif
+
     // create OS memory provider
     umf_result =
         umfMemoryProviderCreate(provider_ops, provider_params, &provider);
     if (umf_result != UMF_RESULT_SUCCESS) {
-        fprintf(stderr,
-                "[producer] ERROR: creating OS memory provider failed\n");
-        return -1;
+        fprintf(stderr, "[producer] ERROR: creating memory provider failed\n");
+        goto err_end;
     }
 
     umf_memory_pool_handle_t pool;
@@ -412,8 +490,8 @@ int run_producer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
     }
 
     // send the IPC_handle_size to the consumer
-    ssize_t len =
-        send(producer_socket, &IPC_handle_size, sizeof(IPC_handle_size), 0);
+    ssize_t len = send(producer_socket, (const char *)&IPC_handle_size,
+                       sizeof(IPC_handle_size), 0);
     if (len < 0) {
         fprintf(stderr, "[producer] ERROR: unable to send the message\n");
         goto err_close_producer_socket;
@@ -450,7 +528,8 @@ int run_producer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
     }
 
     // send the IPC_handle of IPC_handle_size to the consumer
-    if (send(producer_socket, IPC_handle, IPC_handle_size, 0) < 0) {
+    if (send(producer_socket, (const char *)IPC_handle, (int)IPC_handle_size,
+             0) < 0) {
         fprintf(stderr, "[producer] ERROR: unable to send the message\n");
         goto err_close_producer_socket;
     }
@@ -503,7 +582,12 @@ int run_producer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
     }
 
 err_close_producer_socket:
+#ifdef _WIN32
+    closesocket(producer_socket);
+    WSACleanup();
+#else
     close(producer_socket);
+#endif
 
 err_PutIPCHandle:
     umf_result = umfPutIPCHandle(IPC_handle);
@@ -528,6 +612,7 @@ int run_producer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
 err_umfMemoryProviderDestroy:
     umfMemoryProviderDestroy(provider);
 
+err_end:
     if (ret == 0) {
         fprintf(stderr, "[producer] Shutting down (status OK) ...\n");
     } else if (ret == 1) {
diff --git a/test/common/ipc_common.h b/test/common/ipc_common.h
index 89303899b6..c46c9a0643 100644
--- a/test/common/ipc_common.h
+++ b/test/common/ipc_common.h
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -20,12 +20,16 @@ typedef void (*memcopy_callback_t)(void *dst, const void *src, size_t size,
 int producer_connect(int port);
 int consumer_connect(int port);
 
-int run_producer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
-                 umf_memory_provider_ops_t *provider_ops, void *provider_params,
-                 memcopy_callback_t memcopy_callback, void *memcopy_ctx);
+int run_producer(int port, const umf_memory_pool_ops_t *pool_ops,
+                 void *pool_params,
+                 const umf_memory_provider_ops_t *provider_ops,
+                 void *provider_params, memcopy_callback_t memcopy_callback,
+                 void *memcopy_ctx);
 
-int run_consumer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
-                 umf_memory_provider_ops_t *provider_ops, void *provider_params,
-                 memcopy_callback_t memcopy_callback, void *memcopy_ctx);
+int run_consumer(int port, const umf_memory_pool_ops_t *pool_ops,
+                 void *pool_params,
+                 const umf_memory_provider_ops_t *provider_ops,
+                 void *provider_params, memcopy_callback_t memcopy_callback,
+                 void *memcopy_ctx);
 
 #endif // UMF_TEST_IPC_COMMON_H
diff --git a/test/common/level_zero_mocks.cpp b/test/common/level_zero_mocks.cpp
new file mode 100644
index 0000000000..8d64ba8595
--- /dev/null
+++ b/test/common/level_zero_mocks.cpp
@@ -0,0 +1,125 @@
+/*
+ *
+ * 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 <cstdlib>
+
+#include <umf/providers/provider_level_zero.h>
+
+#include "level_zero_mocks.h"
+#include "utils_load_library.h"
+
+using namespace ::testing;
+
+umf_memory_provider_handle_t
+LevelZeroMock::initializeMemoryProviderWithResidentDevices(
+    ze_device_handle_t device, std::vector<ze_device_handle_t> residentDevices,
+    ze_context_handle_t context, ze_device_properties_t device_properties,
+    ze_memory_allocation_properties_t memory_allocation_properties) {
+
+    umf_level_zero_memory_provider_params_handle_t params = nullptr;
+    EXPECT_EQ(umfLevelZeroMemoryProviderParamsCreate(&params),
+              UMF_RESULT_SUCCESS);
+    EXPECT_EQ(umfLevelZeroMemoryProviderParamsSetContext(params, context),
+              UMF_RESULT_SUCCESS);
+    EXPECT_EQ(umfLevelZeroMemoryProviderParamsSetDevice(params, device),
+              UMF_RESULT_SUCCESS);
+    EXPECT_EQ(umfLevelZeroMemoryProviderParamsSetMemoryType(
+                  params, UMF_MEMORY_TYPE_DEVICE),
+              UMF_RESULT_SUCCESS);
+    EXPECT_EQ(
+        umfLevelZeroMemoryProviderParamsSetResidentDevices(
+            params, residentDevices.data(), (uint32_t)residentDevices.size()),
+        UMF_RESULT_SUCCESS);
+
+    // query min page size operation upon provider initialization
+    EXPECT_CALL(*this, zeDeviceGetProperties(device, _))
+        .WillRepeatedly(DoAll(SetArgPointee<1>(device_properties),
+                              Return(ZE_RESULT_SUCCESS)));
+
+    void *POINTER_TESTING_PROPS = TestCreatePointer<void *>(0x77);
+    EXPECT_CALL(*this, zeMemAllocDevice(CONTEXT, _, _, _, device, _))
+        .WillOnce(DoAll(SetArgPointee<5>(POINTER_TESTING_PROPS),
+                        Return(ZE_RESULT_SUCCESS)));
+    for (auto dev : residentDevices) {
+        EXPECT_CALL(*this, zeContextMakeMemoryResident(context, dev, _, _))
+            .WillOnce(Return(ZE_RESULT_SUCCESS));
+    }
+    EXPECT_CALL(*this, zeMemGetAllocProperties(context, _, _, _))
+        .WillOnce(DoAll(SetArgPointee<2>(memory_allocation_properties),
+                        Return(ZE_RESULT_SUCCESS)));
+    EXPECT_CALL(*this, zeMemFree(CONTEXT, POINTER_TESTING_PROPS))
+        .WillOnce(Return(ZE_RESULT_SUCCESS));
+
+    umf_memory_provider_handle_t provider = nullptr;
+    EXPECT_EQ(umfMemoryProviderCreate(umfLevelZeroMemoryProviderOps(), params,
+                                      &provider),
+              UMF_RESULT_SUCCESS);
+    EXPECT_NE(provider, nullptr);
+
+    umfLevelZeroMemoryProviderParamsDestroy(params);
+    return provider;
+}
+
+ze_device_properties_t TestCreateDeviceProperties() {
+    return ze_device_properties_t{ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES,
+                                  nullptr,
+                                  ZE_DEVICE_TYPE_GPU,
+                                  0,
+                                  0,
+                                  0,
+                                  0,
+                                  0,
+                                  1024,
+                                  100,
+                                  20,
+                                  16,
+                                  256,
+                                  8,
+                                  2,
+                                  4,
+                                  1,
+                                  8,
+                                  8,
+                                  {123},
+                                  "TESTGPU"};
+};
+
+ze_memory_allocation_properties_t
+TestCreateMemoryAllocationProperties(uint32_t modifier) {
+    return ze_memory_allocation_properties_t{
+        ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES, nullptr,
+        ZE_MEMORY_TYPE_DEVICE, modifier, 2048};
+}
+
+void MockedLevelZeroTestEnvironment::SetUp() {
+    const char *lib_name = getenv("UMF_ZE_LOADER_LIB_NAME");
+    ASSERT_NE(lib_name, nullptr);
+    if (lib_name == nullptr) {
+        return; // to avoid nullptr deref coverity issue
+    }
+    ASSERT_NE(lib_name[0], '\0');
+
+    lib_handle = utils_open_library(lib_name, 0);
+    ASSERT_NE(lib_handle, nullptr);
+
+    void *l0interface_sym =
+        utils_get_symbol_addr(lib_handle, "level_zero_mock", lib_name);
+    ASSERT_NE(l0interface_sym, nullptr);
+
+    l0interface = static_cast<LevelZero **>(l0interface_sym);
+    ASSERT_NE(l0interface, nullptr);
+
+    ASSERT_EQ(*l0interface, nullptr);
+}
+
+void MockedLevelZeroTestEnvironment::TearDown() {
+    utils_close_library(lib_handle);
+}
+
+LevelZero **MockedLevelZeroTestEnvironment::l0interface;
diff --git a/test/common/level_zero_mocks.h b/test/common/level_zero_mocks.h
new file mode 100644
index 0000000000..35a5e2b7ab
--- /dev/null
+++ b/test/common/level_zero_mocks.h
@@ -0,0 +1,96 @@
+/*
+ *
+ * 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
+ *
+ */
+
+#ifndef UMF_TEST_PROVIDER_LEVEL_ZERO_MOCKS_H
+#define UMF_TEST_PROVIDER_LEVEL_ZERO_MOCKS_H
+
+#include <gmock/gmock.h>
+#include <vector>
+
+#include "utils_log.h"
+#include "ze_loopback.h"
+
+// TEST CREATE methods for objects
+
+template <class T> constexpr T TestCreatePointer(uintptr_t modifier = 0) {
+    return reinterpret_cast<T>(static_cast<uintptr_t>(0x1000) + modifier);
+}
+
+ze_device_properties_t TestCreateDeviceProperties();
+
+ze_memory_allocation_properties_t
+TestCreateMemoryAllocationProperties(uint32_t modifier = 0);
+
+// already created common instances for tests writing convenience
+
+static const auto DEVICE_0 = TestCreatePointer<ze_device_handle_t>(0);
+static const auto DEVICE_1 = TestCreatePointer<ze_device_handle_t>(1);
+static const auto DEVICE_2 = TestCreatePointer<ze_device_handle_t>(2);
+static const auto DEVICE_3 = TestCreatePointer<ze_device_handle_t>(3);
+static const auto DEVICE_4 = TestCreatePointer<ze_device_handle_t>(4);
+static const auto DEVICE_5 = TestCreatePointer<ze_device_handle_t>(5);
+
+static const auto CONTEXT = TestCreatePointer<ze_context_handle_t>();
+static const auto DEVICE_PROPS = TestCreateDeviceProperties();
+static const auto MEM_PROPS = TestCreateMemoryAllocationProperties();
+
+static void *POINTER_0 = TestCreatePointer<void *>(0x90);
+static void *POINTER_1 = TestCreatePointer<void *>(0x91);
+static void *POINTER_2 = TestCreatePointer<void *>(0x92);
+static void *POINTER_3 = TestCreatePointer<void *>(0x93);
+static void *POINTER_4 = TestCreatePointer<void *>(0x94);
+
+class LevelZeroMock : public LevelZero {
+  public:
+    MOCK_METHOD3(zeContextCreate,
+                 ze_result_t(ze_driver_handle_t, const ze_context_desc_t *,
+                             ze_context_handle_t *));
+    MOCK_METHOD2(zeDeviceGetProperties,
+                 ze_result_t(ze_device_handle_t, ze_device_properties_t *));
+    MOCK_METHOD6(zeMemAllocDevice,
+                 ze_result_t(ze_context_handle_t,
+                             const ze_device_mem_alloc_desc_t *, size_t, size_t,
+                             ze_device_handle_t, void **));
+    MOCK_METHOD4(zeMemGetAllocProperties,
+                 ze_result_t(ze_context_handle_t, const void *,
+                             ze_memory_allocation_properties_t *,
+                             ze_device_handle_t *));
+    MOCK_METHOD4(zeContextMakeMemoryResident,
+                 ze_result_t(ze_context_handle_t, ze_device_handle_t, void *,
+                             size_t));
+    MOCK_METHOD4(zeContextEvictMemory,
+                 ze_result_t(ze_context_handle_t, ze_device_handle_t, void *,
+                             size_t));
+    MOCK_METHOD2(zeMemFree,
+                 ze_result_t(ze_context_handle_t hContext, void *ptr));
+
+    // A helper function that (1) sets all EXPECT_CALLs related to successful l0 provider creation
+    // and initialization (2) calls l0 provider creation and initialization
+    umf_memory_provider_handle_t initializeMemoryProviderWithResidentDevices(
+        ze_device_handle_t device,
+        std::vector<ze_device_handle_t> residentDevices,
+        ze_context_handle_t context = CONTEXT,
+        ze_device_properties_t device_properties = DEVICE_PROPS,
+        ze_memory_allocation_properties_t memory_allocation_properties =
+            MEM_PROPS);
+};
+
+// important, makes UMF load ze_loopback instead of regular l0
+class MockedLevelZeroTestEnvironment : public ::testing::Environment {
+
+    void *lib_handle;
+
+  public:
+    static LevelZero **l0interface;
+
+    void SetUp() override;
+    void TearDown() override;
+};
+
+#endif //UMF_TEST_PROVIDER_LEVEL_ZERO_MOCKS_H
diff --git a/test/common/pool.hpp b/test/common/pool.hpp
index 9a5739085a..30abd08cad 100644
--- a/test/common/pool.hpp
+++ b/test/common/pool.hpp
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -19,16 +19,49 @@
 
 #include <umf/base.h>
 #include <umf/memory_provider.h>
+#include <umf/pools/pool_disjoint.h>
 
 #include "base.hpp"
-#include "cpp_helpers.hpp"
 #include "provider.hpp"
+#include "utils/cpp_helpers.hpp"
+
+typedef void *(*pfnPoolParamsCreate)();
+typedef umf_result_t (*pfnPoolParamsDestroy)(void *);
+
+typedef void *(*pfnProviderParamsCreate)();
+typedef umf_result_t (*pfnProviderParamsDestroy)(void *);
+
+using poolCreateExtParams =
+    std::tuple<const umf_memory_pool_ops_t *, pfnPoolParamsCreate,
+               pfnPoolParamsDestroy, const umf_memory_provider_ops_t *,
+               pfnProviderParamsCreate, pfnProviderParamsDestroy>;
+
+std::string poolCreateExtParamsNameGen(
+    const testing::TestParamInfo<poolCreateExtParams> &info) {
+
+    const umf_memory_pool_ops_t *pool_ops = std::get<0>(info.param);
+    const umf_memory_provider_ops_t *provider_ops = std::get<3>(info.param);
+
+    const char *poolName = NULL;
+    pool_ops->get_name(NULL, &poolName);
+
+    const char *providerName = NULL;
+    provider_ops->get_name(NULL, &providerName);
+
+    // if there are multiple cases with the same pool and provider combination,
+    // add the index to the name
+    std::string poolParams = std::get<1>(info.param)
+                                 ? "_w_params_" + std::to_string(info.index)
+                                 : "";
+
+    return std::string(poolName) + poolParams + "_" + providerName;
+}
 
 namespace umf_test {
 
 umf_memory_pool_handle_t
-createPoolChecked(umf_memory_pool_ops_t *ops,
-                  umf_memory_provider_handle_t hProvider, void *params,
+createPoolChecked(const umf_memory_pool_ops_t *ops,
+                  umf_memory_provider_handle_t hProvider, const void *params,
                   umf_pool_create_flags_t flags = 0) {
     umf_memory_pool_handle_t hPool;
     auto ret = umfPoolCreate(ops, hProvider, params, flags, &hPool);
@@ -37,7 +70,7 @@ createPoolChecked(umf_memory_pool_ops_t *ops,
 }
 
 auto wrapPoolUnique(umf_memory_pool_handle_t hPool) {
-    return umf::pool_unique_handle_t(hPool, &umfPoolDestroy);
+    return umf_test::pool_unique_handle_t(hPool, &umfPoolDestroy);
 }
 
 bool isReallocSupported(umf_memory_pool_handle_t hPool) {
@@ -82,7 +115,11 @@ bool isCallocSupported(umf_memory_pool_handle_t hPool) {
     return supported;
 }
 
-bool isAlignedAllocSupported(umf_memory_pool_handle_t hPool) {
+bool isAlignedAllocSupported([[maybe_unused]] umf_memory_pool_handle_t hPool) {
+#ifdef _WIN32
+    // On Windows, aligned allocation is not supported
+    return false;
+#else
     static constexpr size_t allocSize = 8;
     static constexpr size_t alignment = 8;
     auto *ptr = umfPoolAlignedMalloc(hPool, allocSize, alignment);
@@ -96,31 +133,47 @@ bool isAlignedAllocSupported(umf_memory_pool_handle_t hPool) {
     } else {
         throw std::runtime_error("AlignedMalloc failed with unexpected error");
     }
+#endif
 }
 
 typedef struct pool_base_t {
     umf_result_t initialize(umf_memory_provider_handle_t) noexcept {
         return UMF_RESULT_SUCCESS;
     };
-    void *malloc([[maybe_unused]] size_t size) noexcept { return nullptr; }
+    void *malloc(size_t) noexcept { return nullptr; }
     void *calloc(size_t, size_t) noexcept { return nullptr; }
     void *realloc(void *, size_t) noexcept { return nullptr; }
     void *aligned_malloc(size_t, size_t) noexcept { return nullptr; }
-    size_t malloc_usable_size(void *) noexcept { return 0; }
-    umf_result_t free(void *) noexcept { return UMF_RESULT_SUCCESS; }
+    umf_result_t malloc_usable_size(const void *, size_t *) noexcept {
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+    umf_result_t free(void *) noexcept { return UMF_RESULT_ERROR_UNKNOWN; }
     umf_result_t get_last_allocation_error() noexcept {
-        return UMF_RESULT_SUCCESS;
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+    umf_result_t get_name(const char **) noexcept {
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+    umf_result_t ext_ctl(umf_ctl_query_source_t, const char *, void *, size_t,
+                         umf_ctl_query_type_t, va_list) noexcept {
+        return UMF_RESULT_ERROR_INVALID_CTL_PATH;
+    }
+    umf_result_t ext_trim_memory(size_t) noexcept {
+        return UMF_RESULT_ERROR_UNKNOWN;
     }
 } pool_base_t;
 
 struct malloc_pool : public pool_base_t {
     void *malloc(size_t size) noexcept { return ::malloc(size); }
+
     void *calloc(size_t num, size_t size) noexcept {
         return ::calloc(num, size);
     }
+
     void *realloc(void *ptr, size_t size) noexcept {
         return ::realloc(ptr, size);
     }
+
     void *aligned_malloc(size_t size, size_t alignment) noexcept {
 #ifdef _WIN32
         (void)size;      // unused
@@ -132,23 +185,83 @@ struct malloc_pool : public pool_base_t {
         return ::aligned_alloc(alignment, size);
 #endif
     }
-    size_t malloc_usable_size(void *ptr) noexcept {
+
+    umf_result_t malloc_usable_size(const void *ptr, size_t *size) noexcept {
+        if (size) {
 #ifdef _WIN32
-        return _msize(ptr);
+            *size = _msize((void *)ptr);
 #elif __APPLE__
-        return ::malloc_size(ptr);
+            *size = ::malloc_size((void *)ptr);
 #else
-        return ::malloc_usable_size(ptr);
+            *size = ::malloc_usable_size((void *)ptr);
 #endif
+        }
+        return UMF_RESULT_SUCCESS;
     }
+
     umf_result_t free(void *ptr) noexcept {
         ::free(ptr);
         return UMF_RESULT_SUCCESS;
     }
+
+    umf_result_t get_name(const char **name) noexcept {
+        if (name) {
+            *name = "malloc_pool";
+        }
+        return UMF_RESULT_SUCCESS;
+    }
+
+    umf_result_t ext_trim_memory(size_t) noexcept {
+        // malloc_pool frees all memory immediately, so we have nothing to trim
+        return UMF_RESULT_SUCCESS;
+    }
 };
 
 umf_memory_pool_ops_t MALLOC_POOL_OPS =
-    umf::poolMakeCOps<umf_test::malloc_pool, void>();
+    umf_test::poolMakeCOps<umf_test::malloc_pool, void>();
+
+static constexpr size_t DEFAULT_DISJOINT_SLAB_MIN_SIZE = 4096;
+static constexpr size_t DEFAULT_DISJOINT_MAX_POOLABLE_SIZE = 4096;
+static constexpr size_t DEFAULT_DISJOINT_CAPACITY = 4;
+static constexpr size_t DEFAULT_DISJOINT_MIN_BUCKET_SIZE = 64;
+
+inline void *defaultDisjointPoolConfig() {
+    umf_disjoint_pool_params_handle_t config = nullptr;
+    umf_result_t res = umfDisjointPoolParamsCreate(&config);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error("Failed to create pool params");
+    }
+    res = umfDisjointPoolParamsSetSlabMinSize(config,
+                                              DEFAULT_DISJOINT_SLAB_MIN_SIZE);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfDisjointPoolParamsDestroy(config);
+        throw std::runtime_error("Failed to set slab min size");
+    }
+    res = umfDisjointPoolParamsSetMaxPoolableSize(
+        config, DEFAULT_DISJOINT_MAX_POOLABLE_SIZE);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfDisjointPoolParamsDestroy(config);
+        throw std::runtime_error("Failed to set max poolable size");
+    }
+    res = umfDisjointPoolParamsSetCapacity(config, DEFAULT_DISJOINT_CAPACITY);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfDisjointPoolParamsDestroy(config);
+        throw std::runtime_error("Failed to set capacity");
+    }
+    res = umfDisjointPoolParamsSetMinBucketSize(
+        config, DEFAULT_DISJOINT_MIN_BUCKET_SIZE);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfDisjointPoolParamsDestroy(config);
+        throw std::runtime_error("Failed to set min bucket size");
+    }
+
+    return config;
+}
+
+inline umf_result_t defaultDisjointPoolConfigDestroy(void *config) {
+    return umfDisjointPoolParamsDestroy(
+        static_cast<umf_disjoint_pool_params_handle_t>(config));
+}
 
 } // namespace umf_test
 
diff --git a/test/common/pool_null.c b/test/common/pool_null.c
index c34bcfc169..ccabfee562 100644
--- a/test/common/pool_null.c
+++ b/test/common/pool_null.c
@@ -1,4 +1,4 @@
-// Copyright (C) 2023 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
 
@@ -9,7 +9,7 @@
 #include <umf/memory_pool_ops.h>
 
 static umf_result_t nullInitialize(umf_memory_provider_handle_t provider,
-                                   void *params, void **pool) {
+                                   const void *params, void **pool) {
     (void)provider;
     (void)params;
     assert(provider);
@@ -17,7 +17,10 @@ static umf_result_t nullInitialize(umf_memory_provider_handle_t provider,
     return UMF_RESULT_SUCCESS;
 }
 
-static void nullFinalize(void *pool) { (void)pool; }
+static umf_result_t nullFinalize(void *pool) {
+    (void)pool;
+    return UMF_RESULT_SUCCESS;
+}
 
 static void *nullMalloc(void *pool, size_t size) {
     (void)pool;
@@ -46,10 +49,14 @@ static void *nullAlignedMalloc(void *pool, size_t size, size_t alignment) {
     return NULL;
 }
 
-static size_t nullMallocUsableSize(void *pool, void *ptr) {
+static umf_result_t nullMallocUsableSize(void *pool, const void *ptr,
+                                         size_t *size) {
     (void)ptr;
     (void)pool;
-    return 0;
+    if (size) {
+        *size = 0;
+    }
+    return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t nullFree(void *pool, void *ptr) {
@@ -63,8 +70,14 @@ static umf_result_t nullGetLastStatus(void *pool) {
     return UMF_RESULT_SUCCESS;
 }
 
+static umf_result_t nullGetName(void *pool, const char **name) {
+    (void)pool;
+    *name = "null";
+    return UMF_RESULT_SUCCESS;
+}
+
 umf_memory_pool_ops_t UMF_NULL_POOL_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_POOL_OPS_VERSION_CURRENT,
     .initialize = nullInitialize,
     .finalize = nullFinalize,
     .malloc = nullMalloc,
@@ -74,4 +87,5 @@ umf_memory_pool_ops_t UMF_NULL_POOL_OPS = {
     .malloc_usable_size = nullMallocUsableSize,
     .free = nullFree,
     .get_last_allocation_error = nullGetLastStatus,
+    .get_name = nullGetName,
 };
diff --git a/test/common/pool_trace.c b/test/common/pool_trace.c
index 29329f31c0..c05a16d325 100644
--- a/test/common/pool_trace.c
+++ b/test/common/pool_trace.c
@@ -1,4 +1,4 @@
-// Copyright (C) 2023 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
 
@@ -13,13 +13,13 @@ typedef struct trace_pool {
 } trace_pool_t;
 
 static umf_result_t traceInitialize(umf_memory_provider_handle_t provider,
-                                    void *params, void **pool) {
+                                    const void *params, void **pool) {
     trace_pool_t *trace_pool = (trace_pool_t *)malloc(sizeof(trace_pool_t));
     if (NULL == trace_pool) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    umf_pool_trace_params_t *pub_params = params;
+    const umf_pool_trace_params_t *pub_params = params;
     trace_pool->params.hUpstreamPool = pub_params->hUpstreamPool;
     trace_pool->params.trace_context = pub_params->trace_context;
     trace_pool->params.trace_handler = pub_params->trace_handler;
@@ -31,7 +31,10 @@ static umf_result_t traceInitialize(umf_memory_provider_handle_t provider,
     return UMF_RESULT_SUCCESS;
 }
 
-static void traceFinalize(void *pool) { free(pool); }
+static umf_result_t traceFinalize(void *pool) {
+    free(pool);
+    return UMF_RESULT_SUCCESS;
+}
 
 static void *traceMalloc(void *pool, size_t size) {
     trace_pool_t *trace_pool = (trace_pool_t *)pool;
@@ -66,12 +69,13 @@ static void *traceAlignedMalloc(void *pool, size_t size, size_t alignment) {
                                 alignment);
 }
 
-static size_t traceMallocUsableSize(void *pool, void *ptr) {
+static umf_result_t traceMallocUsableSize(void *pool, const void *ptr,
+                                          size_t *size) {
     trace_pool_t *trace_pool = (trace_pool_t *)pool;
 
     trace_pool->params.trace_handler(trace_pool->params.trace_context,
                                      "malloc_usable_size");
-    return umfPoolMallocUsableSize(trace_pool->params.hUpstreamPool, ptr);
+    return umfPoolMallocUsableSize(trace_pool->params.hUpstreamPool, ptr, size);
 }
 
 static umf_result_t traceFree(void *pool, void *ptr) {
@@ -89,8 +93,22 @@ static umf_result_t traceGetLastStatus(void *pool) {
     return umfPoolGetLastAllocationError(trace_pool->params.hUpstreamPool);
 }
 
+static umf_result_t traceGetName(void *pool, const char **name) {
+    (void)pool;
+    *name = "trace";
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t traceTrimMemory(void *pool, size_t minBytesToKeep) {
+    trace_pool_t *trace_pool = (trace_pool_t *)pool;
+
+    trace_pool->params.trace_handler(trace_pool->params.trace_context,
+                                     "trim_memory");
+    return umfPoolTrimMemory(trace_pool->params.hUpstreamPool, minBytesToKeep);
+}
+
 umf_memory_pool_ops_t UMF_TRACE_POOL_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_POOL_OPS_VERSION_CURRENT,
     .initialize = traceInitialize,
     .finalize = traceFinalize,
     .malloc = traceMalloc,
@@ -100,4 +118,6 @@ umf_memory_pool_ops_t UMF_TRACE_POOL_OPS = {
     .malloc_usable_size = traceMallocUsableSize,
     .free = traceFree,
     .get_last_allocation_error = traceGetLastStatus,
+    .get_name = traceGetName,
+    .ext_trim_memory = traceTrimMemory,
 };
diff --git a/test/common/provider.hpp b/test/common/provider.hpp
index 148f34dc89..947392559c 100644
--- a/test/common/provider.hpp
+++ b/test/common/provider.hpp
@@ -1,6 +1,6 @@
 /*
  *
- * 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
@@ -15,8 +15,38 @@
 
 #include "base.hpp"
 #include "base_alloc_global.h"
-#include "cpp_helpers.hpp"
 #include "test_helpers.h"
+#include "utils/cpp_helpers.hpp"
+
+typedef void *(*pfnProviderParamsCreate)();
+typedef umf_result_t (*pfnProviderParamsDestroy)(void *);
+
+using providerCreateExtParams =
+    std::tuple<const umf_memory_provider_ops_t *, void *>;
+
+std::string providerCreateExtParamsNameGen(
+    const testing::TestParamInfo<providerCreateExtParams> param) {
+    const umf_memory_provider_ops_t *provider_ops = std::get<0>(param.param);
+
+    const char *providerName = NULL;
+    provider_ops->get_name(NULL, &providerName);
+
+    return providerName;
+}
+
+void providerCreateExt(providerCreateExtParams params,
+                       umf_test::provider_unique_handle_t *handle) {
+    umf_memory_provider_handle_t hProvider = nullptr;
+    auto [provider_ops, provider_params] = params;
+
+    auto ret =
+        umfMemoryProviderCreate(provider_ops, provider_params, &hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hProvider, nullptr);
+
+    *handle = umf_test::provider_unique_handle_t(hProvider,
+                                                 &umfMemoryProviderDestroy);
+}
 
 namespace umf_test {
 
@@ -29,75 +59,105 @@ createProviderChecked(umf_memory_provider_ops_t *ops, void *params) {
 }
 
 auto wrapProviderUnique(umf_memory_provider_handle_t hProvider) {
-    return umf::provider_unique_handle_t(hProvider, &umfMemoryProviderDestroy);
+    return umf_test::provider_unique_handle_t(hProvider,
+                                              &umfMemoryProviderDestroy);
 }
 
 typedef struct provider_base_t {
     umf_result_t initialize() noexcept { return UMF_RESULT_SUCCESS; };
     umf_result_t alloc(size_t, size_t, void **) noexcept {
-        return UMF_RESULT_ERROR_UNKNOWN;
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
     umf_result_t free([[maybe_unused]] void *ptr,
                       [[maybe_unused]] size_t size) noexcept {
-        return UMF_RESULT_ERROR_UNKNOWN;
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+    umf_result_t get_last_native_error(const char **, int32_t *) noexcept {
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
-    void get_last_native_error(const char **, int32_t *) noexcept {}
     umf_result_t
     get_recommended_page_size([[maybe_unused]] size_t size,
                               [[maybe_unused]] size_t *pageSize) noexcept {
-        return UMF_RESULT_ERROR_UNKNOWN;
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
-    umf_result_t get_min_page_size([[maybe_unused]] void *ptr,
+    umf_result_t get_min_page_size([[maybe_unused]] const void *ptr,
                                    [[maybe_unused]] size_t *pageSize) noexcept {
-        return UMF_RESULT_ERROR_UNKNOWN;
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
-    const char *get_name() noexcept { return "base"; }
-    umf_result_t purge_lazy([[maybe_unused]] void *ptr,
-                            [[maybe_unused]] size_t size) noexcept {
-        return UMF_RESULT_ERROR_UNKNOWN;
+    umf_result_t get_name(const char **name) noexcept {
+        *name = "base";
+        return UMF_RESULT_SUCCESS;
     }
-    umf_result_t purge_force([[maybe_unused]] void *ptr,
-                             [[maybe_unused]] size_t size) noexcept {
-        return UMF_RESULT_ERROR_UNKNOWN;
+    umf_result_t ext_purge_lazy([[maybe_unused]] void *ptr,
+                                [[maybe_unused]] size_t size) noexcept {
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+    umf_result_t ext_purge_force([[maybe_unused]] void *ptr,
+                                 [[maybe_unused]] size_t size) noexcept {
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
 
-    umf_result_t allocation_merge([[maybe_unused]] void *lowPtr,
-                                  [[maybe_unused]] void *highPtr,
-                                  [[maybe_unused]] size_t totalSize) {
-        return UMF_RESULT_ERROR_UNKNOWN;
+    umf_result_t ext_allocation_merge([[maybe_unused]] void *lowPtr,
+                                      [[maybe_unused]] void *highPtr,
+                                      [[maybe_unused]] size_t totalSize) {
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
 
-    umf_result_t allocation_split([[maybe_unused]] void *ptr,
-                                  [[maybe_unused]] size_t totalSize,
-                                  [[maybe_unused]] size_t firstSize) {
-        return UMF_RESULT_ERROR_UNKNOWN;
+    umf_result_t ext_allocation_split([[maybe_unused]] void *ptr,
+                                      [[maybe_unused]] size_t totalSize,
+                                      [[maybe_unused]] size_t firstSize) {
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
-    umf_result_t get_ipc_handle_size([[maybe_unused]] size_t *size) noexcept {
-        return UMF_RESULT_ERROR_UNKNOWN;
+    umf_result_t
+    ext_get_ipc_handle_size([[maybe_unused]] size_t *size) noexcept {
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
     umf_result_t
-    get_ipc_handle([[maybe_unused]] const void *ptr,
-                   [[maybe_unused]] size_t size,
-                   [[maybe_unused]] void *providerIpcData) noexcept {
-        return UMF_RESULT_ERROR_UNKNOWN;
+    ext_get_ipc_handle([[maybe_unused]] const void *ptr,
+                       [[maybe_unused]] size_t size,
+                       [[maybe_unused]] void *providerIpcData) noexcept {
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
     umf_result_t
-    put_ipc_handle([[maybe_unused]] void *providerIpcData) noexcept {
-        return UMF_RESULT_ERROR_UNKNOWN;
+    ext_put_ipc_handle([[maybe_unused]] void *providerIpcData) noexcept {
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+    umf_result_t ext_open_ipc_handle([[maybe_unused]] void *providerIpcData,
+                                     [[maybe_unused]] void **ptr) noexcept {
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+    umf_result_t ext_close_ipc_handle([[maybe_unused]] void *ptr,
+                                      [[maybe_unused]] size_t size) noexcept {
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
-    umf_result_t open_ipc_handle([[maybe_unused]] void *providerIpcData,
-                                 [[maybe_unused]] void **ptr) noexcept {
+
+    umf_result_t ext_ctl([[maybe_unused]] umf_ctl_query_source_t source,
+                         [[maybe_unused]] const char *name,
+                         [[maybe_unused]] void *arg,
+                         [[maybe_unused]] size_t size,
+                         [[maybe_unused]] umf_ctl_query_type_t queryType,
+                         [[maybe_unused]] va_list args) noexcept {
+        return UMF_RESULT_ERROR_INVALID_CTL_PATH;
+    }
+
+    umf_result_t ext_get_allocation_properties(
+        [[maybe_unused]] const void *ptr,
+        [[maybe_unused]] umf_memory_property_id_t memory_property_id,
+        [[maybe_unused]] void *value) noexcept {
         return UMF_RESULT_ERROR_UNKNOWN;
     }
-    umf_result_t close_ipc_handle([[maybe_unused]] void *ptr,
-                                  [[maybe_unused]] size_t size) noexcept {
+
+    umf_result_t ext_get_allocation_properties_size(
+        [[maybe_unused]] umf_memory_property_id_t memory_property_id,
+        [[maybe_unused]] size_t *size) noexcept {
         return UMF_RESULT_ERROR_UNKNOWN;
     }
+
     virtual ~provider_base_t() = default;
 } provider_base_t;
 
 umf_memory_provider_ops_t BASE_PROVIDER_OPS =
-    umf::providerMakeCOps<provider_base_t, void>();
+    umf_test::providerMakeCOps<provider_base_t, void>();
 
 struct provider_ba_global : public provider_base_t {
     umf_result_t alloc(size_t size, size_t align, void **ptr) noexcept {
@@ -123,16 +183,19 @@ struct provider_ba_global : public provider_base_t {
         umf_ba_global_free(ptr);
         return UMF_RESULT_SUCCESS;
     }
-    const char *get_name() noexcept { return "umf_ba_global"; }
+    umf_result_t get_name(const char **name) noexcept {
+        *name = "umf_ba_global";
+        return UMF_RESULT_SUCCESS;
+    }
 };
 
 umf_memory_provider_ops_t BA_GLOBAL_PROVIDER_OPS =
-    umf::providerMakeCOps<provider_ba_global, void>();
+    umf_test::providerMakeCOps<provider_ba_global, void>();
 
 struct provider_mock_out_of_mem : public provider_base_t {
     provider_ba_global helper_prov;
     int allocNum = 0;
-    umf_result_t initialize(int *inAllocNum) noexcept {
+    umf_result_t initialize(const int *inAllocNum) noexcept {
         allocNum = *inAllocNum;
         return UMF_RESULT_SUCCESS;
     }
@@ -148,11 +211,14 @@ struct provider_mock_out_of_mem : public provider_base_t {
     umf_result_t free(void *ptr, size_t size) noexcept {
         return helper_prov.free(ptr, size);
     }
-    const char *get_name() noexcept { return "mock_out_of_mem"; }
+    umf_result_t get_name(const char **name) noexcept {
+        *name = "mock_out_of_mem";
+        return UMF_RESULT_SUCCESS;
+    }
 };
 
-umf_memory_provider_ops_t MOCK_OUT_OF_MEM_PROVIDER_OPS =
-    umf::providerMakeCOps<provider_mock_out_of_mem, int>();
+const umf_memory_provider_ops_t MOCK_OUT_OF_MEM_PROVIDER_OPS =
+    umf_test::providerMakeCOps<provider_mock_out_of_mem, int>();
 
 } // namespace umf_test
 
diff --git a/test/common/provider_null.c b/test/common/provider_null.c
index 5db389e895..2ce8c78ddb 100644
--- a/test/common/provider_null.c
+++ b/test/common/provider_null.c
@@ -1,27 +1,41 @@
-// 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 <assert.h>
 #include <stdlib.h>
 
-#include "provider_null.h"
 #include <umf/memory_provider_ops.h>
 
-static umf_result_t nullInitialize(void *params, void **pool) {
+#include "provider_null.h"
+#include "utils_common.h"
+
+static umf_result_t nullInitialize(const void *params, void **pool) {
     (void)params;
     *pool = NULL;
     return UMF_RESULT_SUCCESS;
 }
 
-static void nullFinalize(void *pool) { (void)pool; }
+static umf_result_t nullFinalize(void *pool) {
+    (void)pool;
+    return UMF_RESULT_SUCCESS;
+}
 
 static umf_result_t nullAlloc(void *provider, size_t size, size_t alignment,
                               void **ptr) {
     (void)provider;
-    (void)size;
-    (void)alignment;
-    *ptr = NULL;
+
+    if (ptr == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (size == 0) {
+        *ptr = NULL;
+        return UMF_RESULT_SUCCESS;
+    }
+
+    *ptr = (void *)ALIGN_UP_SAFE(0xDEADBEAF, alignment); // any not-NULL value
+
     return UMF_RESULT_SUCCESS;
 }
 
@@ -32,11 +46,12 @@ static umf_result_t nullFree(void *provider, void *ptr, size_t size) {
     return UMF_RESULT_SUCCESS;
 }
 
-static void nullGetLastError(void *provider, const char **ppMsg,
-                             int32_t *pError) {
+static umf_result_t nullGetLastError(void *provider, const char **ppMsg,
+                                     int32_t *pError) {
     (void)provider;
     (void)ppMsg;
     (void)pError;
+    return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t nullGetRecommendedPageSize(void *provider, size_t size,
@@ -47,8 +62,7 @@ static umf_result_t nullGetRecommendedPageSize(void *provider, size_t size,
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t nullGetPageSize(void *provider, void *ptr,
-
+static umf_result_t nullGetPageSize(void *provider, const void *ptr,
                                     size_t *pageSize) {
     (void)provider;
     (void)ptr;
@@ -56,9 +70,10 @@ static umf_result_t nullGetPageSize(void *provider, void *ptr,
     return UMF_RESULT_SUCCESS;
 }
 
-static const char *nullName(void *provider) {
+static umf_result_t nullName(void *provider, const char **name) {
     (void)provider;
-    return "null";
+    *name = "null";
+    return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t nullPurgeLazy(void *provider, void *ptr, size_t size) {
@@ -129,23 +144,43 @@ static umf_result_t nullCloseIpcHandle(void *provider, void *ptr, size_t size) {
     return UMF_RESULT_SUCCESS;
 }
 
+static umf_result_t
+nullGetAllocationProperties(void *provider, const void *ptr,
+                            umf_memory_property_id_t propertyId, void *value) {
+    (void)provider;
+    (void)ptr;
+    (void)propertyId;
+    (void)value;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t nullGetAllocationPropertiesSize(
+    void *provider, umf_memory_property_id_t propertyId, size_t *size) {
+    (void)provider;
+    (void)propertyId;
+    (void)size;
+    return UMF_RESULT_SUCCESS;
+}
+
 umf_memory_provider_ops_t UMF_NULL_PROVIDER_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = nullInitialize,
     .finalize = nullFinalize,
     .alloc = nullAlloc,
+    .free = nullFree,
     .get_last_native_error = nullGetLastError,
     .get_recommended_page_size = nullGetRecommendedPageSize,
     .get_min_page_size = nullGetPageSize,
     .get_name = nullName,
-    .ext.free = nullFree,
-    .ext.purge_lazy = nullPurgeLazy,
-    .ext.purge_force = nullPurgeForce,
-    .ext.allocation_merge = nullAllocationMerge,
-    .ext.allocation_split = nullAllocationSplit,
-    .ipc.get_ipc_handle_size = nullGetIpcHandleSize,
-    .ipc.get_ipc_handle = nullGetIpcHandle,
-    .ipc.put_ipc_handle = nullPutIpcHandle,
-    .ipc.open_ipc_handle = nullOpenIpcHandle,
-    .ipc.close_ipc_handle = nullCloseIpcHandle,
+    .ext_purge_lazy = nullPurgeLazy,
+    .ext_purge_force = nullPurgeForce,
+    .ext_allocation_merge = nullAllocationMerge,
+    .ext_allocation_split = nullAllocationSplit,
+    .ext_get_ipc_handle_size = nullGetIpcHandleSize,
+    .ext_get_ipc_handle = nullGetIpcHandle,
+    .ext_put_ipc_handle = nullPutIpcHandle,
+    .ext_open_ipc_handle = nullOpenIpcHandle,
+    .ext_close_ipc_handle = nullCloseIpcHandle,
+    .ext_get_allocation_properties = nullGetAllocationProperties,
+    .ext_get_allocation_properties_size = nullGetAllocationPropertiesSize,
 };
diff --git a/test/common/provider_trace.c b/test/common/provider_trace.c
index 219dde5cd7..c780197c95 100644
--- a/test/common/provider_trace.c
+++ b/test/common/provider_trace.c
@@ -1,15 +1,17 @@
-// 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 <assert.h>
 #include <stdlib.h>
 
-#include "provider_trace.h"
 #include <umf/memory_provider.h>
 #include <umf/memory_provider_ops.h>
 
-static umf_result_t traceInitialize(void *params, void **pool) {
+#include "memory_properties_internal.h"
+#include "provider_trace.h"
+
+static umf_result_t traceInitialize(const void *params, void **pool) {
     umf_provider_trace_params_t *trace_pool =
         (umf_provider_trace_params_t *)malloc(
             sizeof(umf_provider_trace_params_t));
@@ -17,7 +19,7 @@ static umf_result_t traceInitialize(void *params, void **pool) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    umf_provider_trace_params_t *pub_params = params;
+    const umf_provider_trace_params_t *pub_params = params;
     trace_pool->hUpstreamProvider = pub_params->hUpstreamProvider;
     trace_pool->own_upstream = pub_params->own_upstream;
     trace_pool->trace_context = pub_params->trace_context;
@@ -28,13 +30,18 @@ static umf_result_t traceInitialize(void *params, void **pool) {
     return UMF_RESULT_SUCCESS;
 }
 
-static void traceFinalize(void *provider) {
+static umf_result_t traceFinalize(void *provider) {
     umf_provider_trace_params_t *traceProvider =
         (umf_provider_trace_params_t *)provider;
     if (traceProvider->own_upstream) {
-        umfMemoryProviderDestroy(traceProvider->hUpstreamProvider);
+        umf_result_t ret =
+            umfMemoryProviderDestroy(traceProvider->hUpstreamProvider);
+        if (ret != UMF_RESULT_SUCCESS) {
+            return ret;
+        }
     }
     free(provider);
+    return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t traceAlloc(void *provider, size_t size, size_t alignment,
@@ -55,8 +62,8 @@ static umf_result_t traceFree(void *provider, void *ptr, size_t size) {
     return umfMemoryProviderFree(traceProvider->hUpstreamProvider, ptr, size);
 }
 
-static void traceGetLastError(void *provider, const char **ppMsg,
-                              int32_t *pError) {
+static umf_result_t traceGetLastError(void *provider, const char **ppMsg,
+                                      int32_t *pError) {
     umf_provider_trace_params_t *traceProvider =
         (umf_provider_trace_params_t *)provider;
 
@@ -64,6 +71,7 @@ static void traceGetLastError(void *provider, const char **ppMsg,
                                  "get_last_native_error");
     umfMemoryProviderGetLastNativeError(traceProvider->hUpstreamProvider, ppMsg,
                                         pError);
+    return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t traceGetRecommendedPageSize(void *provider, size_t size,
@@ -77,8 +85,7 @@ static umf_result_t traceGetRecommendedPageSize(void *provider, size_t size,
         traceProvider->hUpstreamProvider, size, pageSize);
 }
 
-static umf_result_t traceGetPageSize(void *provider, void *ptr,
-
+static umf_result_t traceGetPageSize(void *provider, const void *ptr,
                                      size_t *pageSize) {
     umf_provider_trace_params_t *traceProvider =
         (umf_provider_trace_params_t *)provider;
@@ -89,12 +96,17 @@ static umf_result_t traceGetPageSize(void *provider, void *ptr,
                                            ptr, pageSize);
 }
 
-static const char *traceName(void *provider) {
+static umf_result_t traceName(void *provider, const char **name) {
     umf_provider_trace_params_t *traceProvider =
         (umf_provider_trace_params_t *)provider;
 
+    // if ops->get_name is called with null provider it must return default provider name
+    if (!provider) {
+        *name = "trace";
+        return UMF_RESULT_SUCCESS;
+    }
     traceProvider->trace_handler(traceProvider->trace_context, "name");
-    return umfMemoryProviderGetName(traceProvider->hUpstreamProvider);
+    return umfMemoryProviderGetName(traceProvider->hUpstreamProvider, name);
 }
 
 static umf_result_t tracePurgeLazy(void *provider, void *ptr, size_t size) {
@@ -191,22 +203,24 @@ static umf_result_t traceCloseIpcHandle(void *provider, void *ptr,
 }
 
 umf_memory_provider_ops_t UMF_TRACE_PROVIDER_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = traceInitialize,
     .finalize = traceFinalize,
     .alloc = traceAlloc,
+    .free = traceFree,
     .get_last_native_error = traceGetLastError,
     .get_recommended_page_size = traceGetRecommendedPageSize,
     .get_min_page_size = traceGetPageSize,
     .get_name = traceName,
-    .ext.free = traceFree,
-    .ext.purge_lazy = tracePurgeLazy,
-    .ext.purge_force = tracePurgeForce,
-    .ext.allocation_merge = traceAllocationMerge,
-    .ext.allocation_split = traceAllocationSplit,
-    .ipc.get_ipc_handle_size = traceGetIpcHandleSize,
-    .ipc.get_ipc_handle = traceGetIpcHandle,
-    .ipc.put_ipc_handle = tracePutIpcHandle,
-    .ipc.open_ipc_handle = traceOpenIpcHandle,
-    .ipc.close_ipc_handle = traceCloseIpcHandle,
+    .ext_purge_lazy = tracePurgeLazy,
+    .ext_purge_force = tracePurgeForce,
+    .ext_allocation_merge = traceAllocationMerge,
+    .ext_allocation_split = traceAllocationSplit,
+    .ext_get_ipc_handle_size = traceGetIpcHandleSize,
+    .ext_get_ipc_handle = traceGetIpcHandle,
+    .ext_put_ipc_handle = tracePutIpcHandle,
+    .ext_open_ipc_handle = traceOpenIpcHandle,
+    .ext_close_ipc_handle = traceCloseIpcHandle,
+    .ext_ctl = NULL,
+    .ext_get_allocation_properties = NULL,
 };
diff --git a/test/common/test_helpers.c b/test/common/test_helpers.c
index 71f018d0f7..997ff77b2c 100644
--- a/test/common/test_helpers.c
+++ b/test/common/test_helpers.c
@@ -1,4 +1,4 @@
-// Copyright (C) 2023 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
 // This file contains tests for UMF pool API
@@ -8,11 +8,12 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <umf/memory_pool.h>
+#include <umf/memory_provider.h>
+
 #include "pool_null.h"
 #include "pool_trace.h"
 #include "provider_null.h"
-#include "umf/memory_pool.h"
-#include "umf/memory_provider.h"
 
 #include "test_helpers.h"
 
diff --git a/test/common/ze_loopback.cpp b/test/common/ze_loopback.cpp
new file mode 100644
index 0000000000..d43219a3c5
--- /dev/null
+++ b/test/common/ze_loopback.cpp
@@ -0,0 +1,280 @@
+/*
+ *
+ * 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 <cstdlib>
+#include <iostream>
+
+#include "ze_loopback.h"
+
+ZE_APIEXPORT LevelZero *level_zero_mock = nullptr;
+
+static void check_mock_present() {
+    if (level_zero_mock == nullptr) {
+        std::cerr << "level_zero_mock was not set\n";
+        abort();
+    }
+}
+
+#define FAIL_NOT_IMPLEMENTED                                                   \
+    std::cerr << __func__ << " not implemented in ze_loopback.cpp\n";          \
+    abort();
+
+//
+// libze_ops from src/utils/utils_level_zero.cpp
+//
+
+ZE_APIEXPORT ze_result_t ZE_APICALL zeInit(ze_init_flags_t flags) {
+    (void)flags;
+    return ZE_RESULT_SUCCESS;
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL zeDriverGet(uint32_t *pCount,
+                                                ze_driver_handle_t *phDrivers) {
+    (void)phDrivers;
+    (void)pCount;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL zeDeviceGet(ze_driver_handle_t hDriver,
+                                                uint32_t *pCount,
+                                                ze_device_handle_t *phDevices) {
+    (void)hDriver;
+    (void)pCount;
+    (void)phDevices;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL zeDeviceGetProperties(
+    ze_device_handle_t hDevice, ze_device_properties_t *pDeviceProperties) {
+    check_mock_present();
+    return level_zero_mock->zeDeviceGetProperties(hDevice, pDeviceProperties);
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL
+zeContextCreate(ze_driver_handle_t hDriver, const ze_context_desc_t *desc,
+                ze_context_handle_t *phContext) {
+    (void)hDriver;
+    (void)desc;
+    (void)phContext;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL
+zeContextDestroy(ze_context_handle_t hContext) {
+    (void)hContext;
+    FAIL_NOT_IMPLEMENTED;
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL
+zeCommandQueueCreate(ze_context_handle_t hContext, ze_device_handle_t hDevice,
+                     const ze_command_queue_desc_t *desc,
+                     ze_command_queue_handle_t *phCommandQueue) {
+    (void)hContext;
+    (void)hDevice;
+    (void)desc;
+    (void)phCommandQueue;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL
+zeCommandQueueDestroy(ze_command_queue_handle_t hCommandQueue) {
+    (void)hCommandQueue;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL zeCommandQueueExecuteCommandLists(
+    ze_command_queue_handle_t hCommandQueue, uint32_t numCommandLists,
+    ze_command_list_handle_t *phCommandLists, ze_fence_handle_t hFence) {
+    (void)hCommandQueue;
+    (void)numCommandLists;
+    (void)phCommandLists;
+    (void)hFence;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL zeCommandQueueSynchronize(
+    ze_command_queue_handle_t hCommandQueue, uint64_t timeout) {
+    (void)hCommandQueue;
+    (void)timeout;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL
+zeCommandListCreate(ze_context_handle_t hContext, ze_device_handle_t hDevice,
+                    const ze_command_list_desc_t *desc,
+                    ze_command_list_handle_t *phCommandList) {
+    (void)hContext;
+    (void)hDevice;
+    (void)desc;
+    (void)phCommandList;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL
+zeCommandListDestroy(ze_command_list_handle_t hCommandList) {
+    (void)hCommandList;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL
+zeCommandListClose(ze_command_list_handle_t hCommandList) {
+    (void)hCommandList;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL zeCommandListAppendMemoryCopy(
+    ze_command_list_handle_t hCommandList, void *dstptr, const void *srcptr,
+    size_t size, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents,
+    ze_event_handle_t *phWaitEvents) {
+    (void)hCommandList;
+    (void)dstptr;
+    (void)srcptr;
+    (void)size;
+    (void)hSignalEvent;
+    (void)numWaitEvents;
+    (void)phWaitEvents;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL zeCommandListAppendMemoryFill(
+    ze_command_list_handle_t hCommandList, void *ptr, const void *pattern,
+    size_t pattern_size, size_t size, ze_event_handle_t hSignalEvent,
+    uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) {
+    (void)hCommandList;
+    (void)ptr;
+    (void)pattern;
+    (void)pattern_size;
+    (void)size;
+    (void)hSignalEvent;
+    (void)numWaitEvents;
+    (void)phWaitEvents;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL
+zeMemGetAllocProperties(ze_context_handle_t hContext, const void *ptr,
+                        ze_memory_allocation_properties_t *pMemAllocProperties,
+                        ze_device_handle_t *phDevice) {
+    check_mock_present();
+    return level_zero_mock->zeMemGetAllocProperties(
+        hContext, ptr, pMemAllocProperties, phDevice);
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL zeMemAllocDevice(
+    ze_context_handle_t hContext, const ze_device_mem_alloc_desc_t *device_desc,
+    size_t size, size_t alignment, ze_device_handle_t hDevice, void **pptr) {
+    check_mock_present();
+    return level_zero_mock->zeMemAllocDevice(hContext, device_desc, size,
+                                             alignment, hDevice, pptr);
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL zeMemFree(ze_context_handle_t hContext,
+                                              void *ptr) {
+    check_mock_present();
+    return level_zero_mock->zeMemFree(hContext, ptr);
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL
+zeDeviceGetMemoryProperties(ze_device_handle_t hDevice, uint32_t *pCount,
+                            ze_device_memory_properties_t *pMemProperties) {
+    (void)hDevice;
+    (void)pCount;
+    (void)pMemProperties;
+    FAIL_NOT_IMPLEMENTED
+}
+
+//
+// ze_ops_t operations from src/provider/provider_level_zero.c
+//
+
+ze_result_t ZE_APICALL zeMemAllocHost(ze_context_handle_t hContext,
+                                      const ze_host_mem_alloc_desc_t *host_desc,
+                                      size_t size, size_t alignment,
+                                      void **pptr) {
+    (void)hContext;
+    (void)host_desc;
+    (void)size;
+    (void)alignment;
+    (void)pptr;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ze_result_t ZE_APICALL zeMemAllocShared(
+    ze_context_handle_t hContext, const ze_device_mem_alloc_desc_t *device_desc,
+    const ze_host_mem_alloc_desc_t *host_desc, size_t size, size_t alignment,
+    ze_device_handle_t hDevice, void **pptr) {
+    (void)hContext;
+    (void)device_desc;
+    (void)host_desc;
+    (void)size;
+    (void)alignment;
+    (void)hDevice;
+    (void)pptr;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ze_result_t ZE_APICALL zeMemGetIpcHandle(ze_context_handle_t hContext,
+                                         const void *ptr,
+                                         ze_ipc_mem_handle_t *pIpcHandle) {
+    (void)hContext;
+    (void)ptr;
+    (void)pIpcHandle;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ze_result_t ZE_APICALL zeMemPutIpcHandle(ze_context_handle_t hContext,
+                                         ze_ipc_mem_handle_t handle) {
+    (void)hContext;
+    (void)handle;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ze_result_t ZE_APICALL zeMemOpenIpcHandle(ze_context_handle_t hContext,
+                                          ze_device_handle_t hDevice,
+                                          ze_ipc_mem_handle_t handle,
+                                          ze_ipc_memory_flags_t flags,
+                                          void **pptr) {
+    (void)hContext;
+    (void)hDevice;
+    (void)handle;
+    (void)flags;
+    (void)pptr;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ze_result_t ZE_APICALL zeMemCloseIpcHandle(ze_context_handle_t hContext,
+                                           const void *ptr) {
+    (void)hContext;
+    (void)ptr;
+    FAIL_NOT_IMPLEMENTED
+}
+
+ze_result_t ZE_APICALL zeContextMakeMemoryResident(ze_context_handle_t hContext,
+                                                   ze_device_handle_t hDevice,
+                                                   void *ptr, size_t size) {
+    check_mock_present();
+    return level_zero_mock->zeContextMakeMemoryResident(hContext, hDevice, ptr,
+                                                        size);
+}
+
+ze_result_t ZE_APICALL zeContextEvictMemory(ze_context_handle_t hContext,
+                                            ze_device_handle_t hDevice,
+                                            void *ptr, size_t size) {
+    check_mock_present();
+    return level_zero_mock->zeContextEvictMemory(hContext, hDevice, ptr, size);
+}
+
+ze_result_t ZE_APICALL
+zeMemFreeExt(ze_context_handle_t hContext,
+             const ze_memory_free_ext_desc_t *pMemFreeDesc, void *ptr) {
+    (void)hContext;
+    (void)pMemFreeDesc;
+    (void)ptr;
+    FAIL_NOT_IMPLEMENTED
+}
diff --git a/test/common/ze_loopback.def b/test/common/ze_loopback.def
new file mode 100644
index 0000000000..2dc73ab317
--- /dev/null
+++ b/test/common/ze_loopback.def
@@ -0,0 +1,38 @@
+;;;; Begin Copyright Notice
+; 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
+;;;;  End Copyright Notice
+
+LIBRARY UMF_ZE_LOOPBACK
+
+EXPORTS
+	level_zero_mock
+        zeInit
+        zeDriverGet
+        zeDeviceGet
+        zeDeviceGetProperties
+        zeContextCreate
+        zeContextDestroy
+        zeCommandQueueCreate
+        zeCommandQueueDestroy
+        zeCommandQueueExecuteCommandLists
+        zeCommandQueueSynchronize
+        zeCommandListCreate
+        zeCommandListDestroy
+        zeCommandListClose
+        zeCommandListAppendMemoryCopy
+        zeCommandListAppendMemoryFill
+        zeContextMakeMemoryResident
+        zeContextEvictMemory
+        zeMemGetAllocProperties
+        zeMemAllocDevice
+        zeMemAllocHost
+        zeMemAllocShared
+        zeMemFree
+        zeMemFreeExt
+        zeMemGetIpcHandle
+        zeMemPutIpcHandle
+        zeMemOpenIpcHandle
+        zeMemCloseIpcHandle
+        zeDeviceGetMemoryProperties
diff --git a/test/common/ze_loopback.h b/test/common/ze_loopback.h
new file mode 100644
index 0000000000..bbf95f141f
--- /dev/null
+++ b/test/common/ze_loopback.h
@@ -0,0 +1,36 @@
+// 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
+
+#ifndef UMF_TEST_ZE_LOOPBACK_H
+#define UMF_TEST_ZE_LOOPBACK_H
+
+#include "ze_api.h"
+
+class LevelZero {
+  public:
+    virtual ~LevelZero() = default;
+
+    virtual ze_result_t zeContextCreate(ze_driver_handle_t,
+                                        const ze_context_desc_t *,
+                                        ze_context_handle_t *) = 0;
+    virtual ze_result_t zeDeviceGetProperties(ze_device_handle_t,
+                                              ze_device_properties_t *) = 0;
+    virtual ze_result_t zeMemAllocDevice(ze_context_handle_t,
+                                         const ze_device_mem_alloc_desc_t *,
+                                         size_t, size_t, ze_device_handle_t,
+                                         void **) = 0;
+    virtual ze_result_t
+    zeMemGetAllocProperties(ze_context_handle_t, const void *,
+                            ze_memory_allocation_properties_t *,
+                            ze_device_handle_t *) = 0;
+    virtual ze_result_t zeContextMakeMemoryResident(ze_context_handle_t,
+                                                    ze_device_handle_t, void *,
+                                                    size_t) = 0;
+    virtual ze_result_t zeContextEvictMemory(ze_context_handle_t,
+                                             ze_device_handle_t, void *,
+                                             size_t) = 0;
+    virtual ze_result_t zeMemFree(ze_context_handle_t hContext, void *ptr) = 0;
+};
+
+#endif //UMF_TEST_ZE_LOOPBACK_H
diff --git a/test/common/ze_loopback.map b/test/common/ze_loopback.map
new file mode 100644
index 0000000000..35c6ac9093
--- /dev/null
+++ b/test/common/ze_loopback.map
@@ -0,0 +1,40 @@
+# 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
+
+# These functions are meant to be in unnamed scope. They are also not named
+# with any umf prefix, as they should override functions with the same name.
+{
+    global:
+        level_zero_mock;
+        zeInit;
+        zeDriverGet;
+        zeDeviceGet;
+        zeDeviceGetProperties;
+        zeContextCreate;
+        zeContextDestroy;
+        zeCommandQueueCreate;
+        zeCommandQueueDestroy;
+        zeCommandQueueExecuteCommandLists;
+        zeCommandQueueSynchronize;
+        zeCommandListCreate;
+        zeCommandListDestroy;
+        zeCommandListClose;
+        zeCommandListAppendMemoryCopy;
+        zeCommandListAppendMemoryFill;
+        zeContextMakeMemoryResident;
+        zeContextEvictMemory;
+        zeMemGetAllocProperties;
+        zeMemAllocDevice;
+        zeMemAllocHost;
+        zeMemAllocShared;
+        zeMemFree;
+        zeMemFreeExt;
+        zeMemGetIpcHandle;
+        zeMemPutIpcHandle;
+        zeMemOpenIpcHandle;
+        zeMemCloseIpcHandle;
+        zeDeviceGetMemoryProperties;
+    local:
+        *;
+};
diff --git a/test/ctl/config.txt b/test/ctl/config.txt
new file mode 100644
index 0000000000..52c8febadd
--- /dev/null
+++ b/test/ctl/config.txt
@@ -0,0 +1,3 @@
+debug.heap.alloc_pattern=321;
+debug.heap.enable_logging=1;
+debug.heap.log_level=5;
diff --git a/test/ctl/ctl_api.cpp b/test/ctl/ctl_api.cpp
new file mode 100644
index 0000000000..47280d3acf
--- /dev/null
+++ b/test/ctl/ctl_api.cpp
@@ -0,0 +1,559 @@
+/*
+ *
+ * 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 <atomic>
+#include <cstring>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include <umf.h>
+#include <umf/base.h>
+#include <umf/experimental/ctl.h>
+#include <umf/memory_pool.h>
+#include <umf/memory_provider.h>
+#include <umf/pools/pool_disjoint.h>
+#include <umf/providers/provider_os_memory.h>
+
+#include "../common/base.hpp"
+#include "../common/fork_helpers.hpp"
+#include "../common/provider.hpp"
+#include "gtest/gtest.h"
+
+using namespace umf_test;
+
+TEST_F(test, ctl_by_handle_os_provider) {
+    umf_memory_provider_handle_t hProvider = NULL;
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = NULL;
+    const umf_memory_provider_ops_t *os_provider_ops = umfOsMemoryProviderOps();
+    if (os_provider_ops == NULL) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    int ret = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ret = umfMemoryProviderCreate(os_provider_ops, os_memory_provider_params,
+                                  &hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    int ipc_enabled = 0xBAD;
+    ret = umfCtlGet("umf.provider.by_handle.{}.params.ipc_enabled",
+                    &ipc_enabled, sizeof(ipc_enabled), hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(ipc_enabled, 0);
+
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+    umfMemoryProviderDestroy(hProvider);
+}
+
+class CtlTest : public ::testing::Test {
+  public:
+    CtlTest() {}
+
+    void SetUp() override {}
+
+    void TearDown() override {}
+
+  private:
+};
+
+// setting default modifies global state -
+// tests doing so should run in fork to ensure correct test isolation
+TEST_F(CtlTest, ctlDefault) {
+    umf_test::run_in_fork([] {
+        const char *arg = "default_name";
+        ASSERT_EQ(umfCtlSet("umf.pool.default.some_pool.some_path", (void *)arg,
+                            strlen(arg)),
+                  UMF_RESULT_SUCCESS);
+
+        char output[64] = {1};
+        ASSERT_EQ(umfCtlGet("umf.pool.default.some_pool.some_path",
+                            (void *)output, sizeof(output)),
+                  UMF_RESULT_SUCCESS);
+        ASSERT_STREQ(output, arg);
+    });
+}
+
+/* Case: umfCtlSet negative test */
+TEST_F(CtlTest, ctlSetInvalid) {
+    const char *valid_arg = "default_name";
+    const char *valid_path = "umf.pool.default.some_pool.some_path";
+    // umfCtlSet - invalid path
+    auto res = umfCtlSet(NULL, (void *)valid_arg, strlen(valid_arg));
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // umfCtlSet - invalid size
+    res = umfCtlSet(valid_path, (void *)valid_arg, 0);
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // umfCtlSet - invalid arg
+    res = umfCtlSet(valid_path, NULL, strlen(valid_arg));
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+/* Case: umfCtlGet negative test */
+TEST_F(CtlTest, ctlGetInvalid) {
+    const char *valid_arg = "default_name";
+    const char *valid_path = "umf.pool.default.some_pool.some_path";
+
+    // umfCtlGet - invalid path
+    auto res = umfCtlGet(NULL, (void *)valid_arg, strlen(valid_arg));
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // umfCtlGet - invalid arg
+    res = umfCtlGet(valid_path, NULL, strlen(valid_arg));
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+/* Case: multi-threaded test for pool defaults
+ * This test sets a default value in multiple threads and then retrieves it */
+TEST_F(CtlTest, ctlDefaultPoolMultithreaded) {
+    umf_test::run_in_fork([] {
+        const size_t max_size = 10;
+        const size_t num_threads = 8;
+        std::vector<std::thread> threads;
+        std::atomic<size_t> totalRecords = 0;
+        const char *predefined_value = "xyzzyx";
+        std::string name_prefix = "umf.pool.default.some_pool.";
+        for (size_t i = 0; i < num_threads; i++) {
+            threads.emplace_back([i, &totalRecords, &predefined_value,
+                                  &name_prefix, max_size = max_size]() {
+                for (size_t j = 0; j < max_size; j++) {
+                    std::string name = name_prefix + std::to_string(i * 10 + j);
+                    umfCtlSet(name.c_str(), (void *)predefined_value,
+                              strlen(predefined_value));
+                    std::atomic_fetch_add(&totalRecords, 1UL);
+                }
+            });
+        }
+        for (auto &thread : threads) {
+            thread.join();
+        }
+
+        ASSERT_EQ(totalRecords.load(), num_threads * max_size);
+
+        char output[100] = {0};
+        for (size_t i = 0; i < totalRecords.load(); i++) {
+            std::string name = name_prefix + std::to_string(i);
+            umf_result_t status =
+                umfCtlGet(name.c_str(), (void *)output, sizeof(output));
+            ASSERT_EQ(status, UMF_RESULT_SUCCESS);
+            ASSERT_STREQ(output, predefined_value);
+        }
+    });
+}
+
+struct ctl_provider_params {
+    const char *name;
+    int initial_value;
+};
+
+class ctl_provider : public umf_test::provider_base_t {
+  public:
+    ctl_provider() : name_ptr_(kDefaultName), stored_value_(0) {}
+
+    umf_result_t initialize(const ctl_provider_params *params) noexcept {
+        if (!params) {
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+
+        stored_value_ = params->initial_value;
+        if (params->name) {
+            name_storage_ = params->name;
+            name_ptr_ = name_storage_.c_str();
+        } else {
+            name_ptr_ = kDefaultName;
+        }
+
+        return UMF_RESULT_SUCCESS;
+    }
+
+    umf_result_t get_name(const char **name) noexcept {
+        if (!name) {
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+        *name = name_ptr_;
+        return UMF_RESULT_SUCCESS;
+    }
+
+    umf_result_t ext_ctl(umf_ctl_query_source_t, const char *path, void *arg,
+                         size_t size, umf_ctl_query_type_t queryType,
+                         va_list) noexcept {
+        if (std::strcmp(path, "params.value") != 0) {
+            return UMF_RESULT_ERROR_INVALID_CTL_PATH;
+        }
+
+        if (!arg || size != sizeof(int)) {
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+
+        if (queryType == CTL_QUERY_WRITE) {
+            stored_value_ = *static_cast<int *>(arg);
+            return UMF_RESULT_SUCCESS;
+        }
+
+        if (queryType == CTL_QUERY_READ) {
+            *static_cast<int *>(arg) = stored_value_;
+            return UMF_RESULT_SUCCESS;
+        }
+
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+  private:
+    static constexpr const char *kDefaultName = "mock";
+    std::string name_storage_;
+    const char *name_ptr_;
+    int stored_value_;
+};
+
+TEST_F(CtlTest, ctlProviderDefaultsCustomName) {
+    umf_test::run_in_fork([] {
+        static auto provider_ops =
+            umf_test::providerMakeCOps<ctl_provider, ctl_provider_params>();
+
+        int canonical_default = 21;
+        ASSERT_EQ(umfCtlSet("umf.provider.default.mock.params.value",
+                            &canonical_default, sizeof(canonical_default)),
+                  UMF_RESULT_SUCCESS);
+
+        const std::string custom_name = "custom_provider";
+        int custom_default = 37;
+        const std::string custom_path =
+            "umf.provider.default." + custom_name + ".params.value";
+        ASSERT_EQ(umfCtlSet(custom_path.c_str(), &custom_default,
+                            sizeof(custom_default)),
+                  UMF_RESULT_SUCCESS);
+
+        ctl_provider_params custom_params{custom_name.c_str(), 0};
+        umf_memory_provider_handle_t custom_handle = nullptr;
+        ASSERT_EQ(umfMemoryProviderCreate(&provider_ops, &custom_params,
+                                          &custom_handle),
+                  UMF_RESULT_SUCCESS);
+
+        int value = 0;
+        ASSERT_EQ(umfCtlGet("umf.provider.by_handle.{}.params.value", &value,
+                            sizeof(value), custom_handle),
+                  UMF_RESULT_SUCCESS);
+        EXPECT_EQ(value, custom_default);
+        ASSERT_EQ(umfMemoryProviderDestroy(custom_handle), UMF_RESULT_SUCCESS);
+
+        ctl_provider_params canonical_params{nullptr, 7};
+        umf_memory_provider_handle_t canonical_handle = nullptr;
+        ASSERT_EQ(umfMemoryProviderCreate(&provider_ops, &canonical_params,
+                                          &canonical_handle),
+                  UMF_RESULT_SUCCESS);
+
+        ASSERT_EQ(umfCtlGet("umf.provider.by_handle.{}.params.value", &value,
+                            sizeof(value), canonical_handle),
+                  UMF_RESULT_SUCCESS);
+        EXPECT_EQ(value, canonical_default);
+        ASSERT_EQ(umfMemoryProviderDestroy(canonical_handle),
+                  UMF_RESULT_SUCCESS);
+    });
+}
+
+/* Case: overwriting an existing value for pool defaults
+ * This test sets a default value and then overwrites it with a new value */
+TEST_F(CtlTest, ctlDefaultPoolOverwrite) {
+    umf_test::run_in_fork([] {
+        constexpr int max_size = 10;
+        std::vector<std::string> values;
+        const std::string name = "umf.pool.default.some_pool";
+
+        for (int i = 0; i < max_size; i++) {
+            values.push_back("value_" + std::to_string(i));
+            umf_result_t set_status =
+                umfCtlSet(name.c_str(), (void *)values.back().c_str(),
+                          values.back().size());
+            ASSERT_EQ(set_status, UMF_RESULT_SUCCESS);
+        }
+
+        char output[100] = {0};
+        umf_result_t status =
+            umfCtlGet(name.c_str(), (void *)output, sizeof(output));
+        ASSERT_EQ(status, UMF_RESULT_SUCCESS);
+        ASSERT_STREQ(output, values.back().c_str());
+    });
+}
+
+TEST_F(CtlTest, ctlDefaultMultithreadedProvider) {
+    umf_test::run_in_fork([] {
+        std::vector<std::thread> threads;
+        std::atomic<size_t> totalRecords = 0;
+        const char *predefined_value = "xyzzyx";
+        std::string name_prefix = "umf.provider.default.some_provider.";
+        for (int i = 0; i < 8; i++) {
+            threads.emplace_back([i, &totalRecords, &predefined_value,
+                                  &name_prefix]() {
+                for (int j = 0; j < 10; j++) {
+                    std::string name = name_prefix + std::to_string(i * 10 + j);
+                    umfCtlSet(name.c_str(), (void *)predefined_value,
+                              strlen(predefined_value));
+                    std::atomic_fetch_add(&totalRecords, (size_t)1);
+                }
+            });
+        }
+        for (auto &thread : threads) {
+            thread.join();
+        }
+
+        char output[100] = {0};
+        for (size_t i = 0; i < totalRecords.load(); i++) {
+            std::string name = name_prefix + std::to_string(i);
+            umf_result_t status =
+                umfCtlGet(name.c_str(), (void *)output, sizeof(output));
+            ASSERT_EQ(status, UMF_RESULT_SUCCESS);
+            ASSERT_STREQ(output, predefined_value);
+        }
+    });
+}
+
+TEST_F(test, ctl_logger_basic_rw) {
+    bool ts_set = true;
+    ASSERT_EQ(umfCtlSet("umf.logger.timestamp", &ts_set, sizeof(ts_set)),
+              UMF_RESULT_SUCCESS);
+    bool ts_get = false;
+    ASSERT_EQ(umfCtlGet("umf.logger.timestamp", &ts_get, sizeof(ts_get)),
+              UMF_RESULT_SUCCESS);
+    EXPECT_TRUE(ts_get);
+
+    bool pid_set = 1;
+    ASSERT_EQ(umfCtlSet("umf.logger.pid", &pid_set, sizeof(pid_set)),
+              UMF_RESULT_SUCCESS);
+    bool pid_get = 0;
+    ASSERT_EQ(umfCtlGet("umf.logger.pid", &pid_get, sizeof(pid_get)),
+              UMF_RESULT_SUCCESS);
+    EXPECT_EQ(pid_get, 1);
+
+    int level_set = 1;
+    ASSERT_EQ(umfCtlSet("umf.logger.level", &level_set, sizeof(level_set)),
+              UMF_RESULT_SUCCESS);
+    int level_get = 0;
+    ASSERT_EQ(umfCtlGet("umf.logger.level", &level_get, sizeof(level_get)),
+              UMF_RESULT_SUCCESS);
+    EXPECT_EQ(level_get, 1);
+
+    int flush_set = 2;
+    ASSERT_EQ(
+        umfCtlSet("umf.logger.flush_level", &flush_set, sizeof(flush_set)),
+        UMF_RESULT_SUCCESS);
+    int flush_get = 0;
+    ASSERT_EQ(
+        umfCtlGet("umf.logger.flush_level", &flush_get, sizeof(flush_get)),
+        UMF_RESULT_SUCCESS);
+    EXPECT_EQ(flush_get, 2);
+
+    const char out_name[] = "stdout";
+    ASSERT_EQ(
+        umfCtlSet("umf.logger.output", (void *)out_name, sizeof(out_name)),
+        UMF_RESULT_SUCCESS);
+    const char out_get[256] = "";
+    ASSERT_EQ(umfCtlGet("umf.logger.output", (void *)out_get, sizeof(out_get)),
+              UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(out_get, "stdout");
+}
+
+TEST_F(test, ctl_logger_output_file) {
+    const char file_name[] = "ctl_log.txt";
+    ASSERT_EQ(
+        umfCtlSet("umf.logger.output", (void *)file_name, sizeof(file_name)),
+        UMF_RESULT_SUCCESS);
+    const char out_get[256] = "";
+    ASSERT_EQ(umfCtlGet("umf.logger.output", (void *)out_get, sizeof(out_get)),
+              UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(out_get, file_name);
+}
+
+TEST_F(test, ctl_by_name) {
+    umf_memory_provider_handle_t hProvider = NULL;
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = NULL;
+    const umf_memory_provider_ops_t *os_provider_ops = umfOsMemoryProviderOps();
+    if (os_provider_ops == NULL) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    int ret = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ret = umfMemoryProviderCreate(os_provider_ops, os_memory_provider_params,
+                                  &hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
+    umf_disjoint_pool_params_handle_t disjoint_pool_params = NULL;
+    ret = umfDisjointPoolParamsCreate(&disjoint_pool_params);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    const char *pool_name = "test_disjoint_pool";
+    ret = umfDisjointPoolParamsSetName(disjoint_pool_params, pool_name);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    umf_memory_pool_handle_t hPool = NULL;
+    ret = umfPoolCreate(umfDisjointPoolOps(), hProvider, disjoint_pool_params,
+                        0, &hPool);
+
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    const char *pool_name2 = "test_disjoint_pool2";
+    ret = umfDisjointPoolParamsSetName(disjoint_pool_params, pool_name2);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    umf_memory_pool_handle_t hPool2 = NULL;
+    ret = umfPoolCreate(umfDisjointPoolOps(), hProvider, disjoint_pool_params,
+                        0, &hPool2);
+    umfDisjointPoolParamsDestroy(disjoint_pool_params);
+
+    size_t pool_count;
+
+    ret = umfCtlGet("umf.pool.by_name.test_disjoint_pool.count", &pool_count,
+                    sizeof(pool_count));
+
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(pool_count, 1ull);
+
+    ret = umfCtlGet("umf.pool.by_name.test_disjoint_pool2.count", &pool_count,
+                    sizeof(pool_count));
+
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(pool_count, 1ull);
+
+    size_t alloc_count;
+    ret = umfCtlGet("umf.pool.by_name.{}.stats.alloc_count", &alloc_count,
+                    sizeof(alloc_count), pool_name);
+
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(alloc_count, 0ull);
+
+    ret = umfCtlGet("umf.pool.by_name.{}.stats.alloc_count", &alloc_count,
+                    sizeof(alloc_count), pool_name2);
+
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(alloc_count, 0ull);
+
+    // allocate from pool1
+    void *ptr1 = umfPoolMalloc(hPool, 1024);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr1, nullptr);
+
+    // we can use pool name in the string without {} too
+    ret = umfCtlGet("umf.pool.by_name.test_disjoint_pool.stats.alloc_count",
+                    &alloc_count, sizeof(alloc_count));
+
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(alloc_count, 1ull);
+
+    ret = umfCtlGet("umf.pool.by_name.test_disjoint_pool2.stats.alloc_count",
+                    &alloc_count, sizeof(alloc_count));
+
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(alloc_count, 0ull);
+
+    ret = umfPoolFree(hPool, ptr1);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    // we can use index parameter too
+    ret = umfCtlGet("umf.pool.by_name.test_disjoint_pool.0.stats.alloc_count",
+                    &alloc_count, sizeof(alloc_count));
+
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(alloc_count, 0ull);
+
+    ret = umfCtlGet("umf.pool.by_name.test_disjoint_pool2.{}.stats.alloc_count",
+                    &alloc_count, sizeof(alloc_count), 0);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(alloc_count, 0ull);
+
+    // test too big pool index
+    ret = umfCtlGet("umf.pool.by_name.test_disjoint_pool2.10.stats.alloc_count",
+                    &alloc_count, sizeof(alloc_count));
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfPoolDestroy(hPool);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ret = umfPoolDestroy(hPool2);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ret = umfMemoryProviderDestroy(hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+}
+
+TEST_F(test, ctl_by_name_collision) {
+    umf_memory_provider_handle_t hProvider = NULL;
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = NULL;
+    const umf_memory_provider_ops_t *os_provider_ops = umfOsMemoryProviderOps();
+    if (os_provider_ops == NULL) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    int ret = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ret = umfMemoryProviderCreate(os_provider_ops, os_memory_provider_params,
+                                  &hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
+    umf_disjoint_pool_params_handle_t disjoint_pool_params = NULL;
+    ret = umfDisjointPoolParamsCreate(&disjoint_pool_params);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    const char *pool_name = "test_disjoint_pool";
+    ret = umfDisjointPoolParamsSetName(disjoint_pool_params, pool_name);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    umf_memory_pool_handle_t hPool = NULL;
+    ret = umfPoolCreate(umfDisjointPoolOps(), hProvider, disjoint_pool_params,
+                        0, &hPool);
+
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    umf_memory_pool_handle_t hPool2 = NULL;
+    ret = umfPoolCreate(umfDisjointPoolOps(), hProvider, disjoint_pool_params,
+                        0, &hPool2);
+    umfDisjointPoolParamsDestroy(disjoint_pool_params);
+
+    // allocate from pool1
+    void *ptr1 = umfPoolMalloc(hPool, 1024);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr1, nullptr);
+
+    size_t pool_count;
+    ret = umfCtlGet("umf.pool.by_name.test_disjoint_pool.count", &pool_count,
+                    sizeof(pool_count));
+
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(pool_count, 2ull);
+
+    // If there is more than one pool with the same name,
+    // CtlGet by_name will return an error
+    size_t alloc_count;
+    ret = umfCtlGet("umf.pool.by_name.{}.stats.alloc_count", &alloc_count,
+                    sizeof(alloc_count), pool_name);
+
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // ctl set and exec will still work. But there is no CTL entry for now to test it
+
+    // todo: add test when ctl entries will be extended
+
+    // we can read from specific pool with index argument
+    ret = umfCtlGet("umf.pool.by_name.test_disjoint_pool.0.stats.alloc_count",
+                    &alloc_count, sizeof(alloc_count), pool_name, 0);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(alloc_count, 1ull);
+
+    ret = umfCtlGet("umf.pool.by_name.{}.1.stats.alloc_count", &alloc_count,
+                    sizeof(alloc_count), pool_name);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(alloc_count, 0ull);
+
+    ret = umfPoolFree(hPool, ptr1);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ret = umfPoolDestroy(hPool);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ret = umfPoolDestroy(hPool2);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ret = umfMemoryProviderDestroy(hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+}
diff --git a/test/ctl/ctl_debug.c b/test/ctl/ctl_debug.c
new file mode 100644
index 0000000000..ddff10eea6
--- /dev/null
+++ b/test/ctl/ctl_debug.c
@@ -0,0 +1,190 @@
+/*
+ *
+ * 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
+ *
+ */
+
+/*
+ * ctl_debug.c -- implementation of the debug CTL namespace
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "ctl/ctl_internal.h"
+#include "ctl_debug.h"
+
+static struct ctl ctl_debug;
+
+static int alloc_pattern = 0;
+static int enable_logging = 0;
+static int log_level = 0;
+
+struct ctl *get_debug_ctl(void) { return &ctl_debug; }
+
+/*
+ * CTL_WRITE_HANDLER(alloc_pattern) -- sets the alloc_pattern field in heap
+ */
+static umf_result_t
+CTL_WRITE_HANDLER(alloc_pattern)(void *ctx, umf_ctl_query_source_t source,
+                                 void *arg, size_t size,
+                                 umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)ctx, (void)size;
+
+    int arg_in = *(int *)arg;
+    alloc_pattern = arg_in;
+    return UMF_RESULT_SUCCESS;
+}
+
+/*
+ * CTL_READ_HANDLER(alloc_pattern) -- returns alloc_pattern heap field
+ */
+static umf_result_t
+CTL_READ_HANDLER(alloc_pattern)(void *ctx, umf_ctl_query_source_t source,
+                                void *arg, size_t size,
+                                umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)ctx, (void)size;
+
+    int *arg_out = arg;
+    *arg_out = alloc_pattern;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t
+CTL_WRITE_HANDLER(enable_logging)(void *ctx, umf_ctl_query_source_t source,
+                                  void *arg, size_t size,
+                                  umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)ctx, (void)size;
+
+    int arg_in = *(int *)arg;
+    enable_logging = arg_in;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t
+CTL_READ_HANDLER(enable_logging)(void *ctx, umf_ctl_query_source_t source,
+                                 void *arg, size_t size,
+                                 umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)ctx, (void)size;
+
+    int *arg_out = arg;
+    *arg_out = enable_logging;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t
+CTL_WRITE_HANDLER(log_level)(void *ctx, umf_ctl_query_source_t source,
+                             void *arg, size_t size,
+                             umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)ctx, (void)size;
+
+    int arg_in = *(int *)arg;
+    log_level = arg_in;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t
+CTL_READ_HANDLER(log_level)(void *ctx, umf_ctl_query_source_t source, void *arg,
+                            size_t size, umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)ctx, (void)size;
+
+    int *arg_out = arg;
+    *arg_out = log_level;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t
+CTL_READ_HANDLER(arg_value)(void *ctx, umf_ctl_query_source_t source, void *arg,
+                            size_t size, umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)ctx, (void)size;
+
+    if (indexes == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    if (indexes->next != NULL) {
+        // argument list should have exactly one argument
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    if (strcmp(indexes->name, "arg_test") != 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    if (indexes->arg_size != sizeof(int)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    if (indexes->arg == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    int *arg_out = arg;
+    *arg_out = *(int *)indexes->arg;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t CTL_READ_HANDLER(CTL_NONAME, final_node)(
+    void *ctx, umf_ctl_query_source_t source, void *arg, size_t size,
+    umf_ctl_index_utlist_t *indexes) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)ctx, (void)size;
+
+    if (indexes == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    if (indexes->next != NULL) {
+        // argument list should have exactly one argument
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    if (strcmp(indexes->name, "arg_test_final") != 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    if (indexes->arg_size != sizeof(int)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    if (indexes->arg == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    int *arg_out = arg;
+    *arg_out = *(int *)indexes->arg;
+    return UMF_RESULT_SUCCESS;
+}
+
+static const struct ctl_argument CTL_ARG(alloc_pattern) = CTL_ARG_LONG_LONG;
+
+static const struct ctl_argument CTL_ARG(enable_logging) = CTL_ARG_BOOLEAN;
+
+static const struct ctl_argument CTL_ARG(log_level) = CTL_ARG_INT;
+static const struct ctl_argument CTL_ARG(arg_test) = CTL_ARG_INT;
+static const struct ctl_argument CTL_ARG(arg_test_final) = CTL_ARG_INT;
+
+const umf_ctl_node_t CTL_NODE(arg_test)[] = {CTL_LEAF_RO(arg_value),
+                                             CTL_NODE_END};
+const umf_ctl_node_t CTL_NODE(arg_test_final)[] = {
+    CTL_LEAF_RO(CTL_NONAME, final_node), CTL_NODE_END};
+
+static const umf_ctl_node_t CTL_NODE(heap)[] = {
+    CTL_LEAF_RW(alloc_pattern), CTL_LEAF_RW(enable_logging),
+    CTL_LEAF_RW(log_level), CTL_NODE_END};
+
+static const umf_ctl_node_t CTL_NODE(debug)[] = {
+    CTL_CHILD(heap), CTL_CHILD_WITH_ARG(arg_test),
+    CTL_CHILD_WITH_ARG(arg_test_final), CTL_NODE_END};
+
+/*
+ * debug_ctl_register -- registers ctl nodes for "debug" module
+ */
+void debug_ctl_register(struct ctl *ctl) { CTL_REGISTER_MODULE(ctl, debug); }
+
+void initialize_debug_ctl(void) {
+    debug_ctl_register(&ctl_debug);
+    ctl_init(malloc, free);
+}
diff --git a/test/ctl/ctl_debug.h b/test/ctl/ctl_debug.h
new file mode 100644
index 0000000000..1d928c8be6
--- /dev/null
+++ b/test/ctl/ctl_debug.h
@@ -0,0 +1,32 @@
+/*
+ *
+ * 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
+ *
+ */
+
+/*
+ * ctl_debug.h -- definitions for CTL tests
+ */
+
+#ifndef UMF_TEST_CTL_DEBUG_H
+#define UMF_TEST_CTL_DEBUG_H 1
+
+#include "ctl/ctl_internal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void debug_ctl_register(struct ctl *ctl);
+struct ctl *get_debug_ctl(void);
+void initialize_debug_ctl(void);
+void deinitialize_debug_ctl(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_TEST_CTL_DEBUG_H */
diff --git a/test/ctl/ctl_env_app.cpp b/test/ctl/ctl_env_app.cpp
new file mode 100644
index 0000000000..bb068e361d
--- /dev/null
+++ b/test/ctl/ctl_env_app.cpp
@@ -0,0 +1,177 @@
+/*
+ *
+ * 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 <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <string>
+
+#include <umf.h>
+#include <umf/experimental/ctl.h>
+#include <umf/pools/pool_disjoint.h>
+#include <umf/providers/provider_os_memory.h>
+
+static int test_env_defaults(int argc, char **argv) {
+    char buf[64] = {0};
+
+    if (argc % 2 != 0) {
+        std::cerr << "expected even number of arguments" << std::endl;
+        std::cerr << "Usage: env_defaults key1 value1 key2 value2 ..."
+                  << std::endl;
+        return 1;
+    }
+    for (int i = 0; i < argc; i += 2) {
+        const char *key = argv[i];
+        const char *value = argv[i + 1];
+        if (umfCtlGet(key, buf, sizeof(buf)) != UMF_RESULT_SUCCESS) {
+            fprintf(stderr, "Failed to get control for '%s'\n", key);
+            return 1;
+        }
+
+        if (strcmp(buf, value) != 0) {
+            std::cerr << "Expected value for '" << key << "' to be '" << value
+                      << "', but got '" << buf << "'" << std::endl;
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static int test_logger(int argc, char **argv) {
+    char buf[256] = {0};
+    int level = 0;
+
+    if (argc != 2) {
+        std::cerr << "expected two arguments" << std::endl;
+        std::cerr << "Usage: logger log_output log_level" << std::endl;
+        return 1;
+    }
+    umfCtlGet("umf.logger.output", buf, sizeof(buf));
+    if (strcmp(buf, argv[0]) != 0) {
+        std::cerr << "Expected log_output to be '" << argv[0] << "', but got '"
+                  << buf << "'" << std::endl;
+        return 1;
+    }
+
+    umfCtlGet("umf.logger.level", &level, sizeof(level));
+    if (level != atoi(argv[1])) {
+        std::cerr << "Expected log_level to be '" << argv[1] << "', but got '"
+                  << level << "'" << std::endl;
+        return 1;
+    }
+
+    return 0;
+}
+
+static int test_disjoint_pool(int argc, char **argv) {
+    if (argc % 2 != 0) {
+        std::cerr << "expected even number of arguments" << std::endl;
+        std::cerr << "Usage: disjoint_pool param value [param value]..."
+                  << std::endl;
+        return 1;
+    }
+
+    if (umfInit() != UMF_RESULT_SUCCESS) {
+        std::cerr << "umfInit failed" << std::endl;
+        return 1;
+    }
+
+    int ret = 1;
+    umf_os_memory_provider_params_handle_t os_params = nullptr;
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_memory_pool_handle_t pool = nullptr;
+
+    if (UMF_RESULT_ERROR_NOT_SUPPORTED ==
+        umfOsMemoryProviderParamsCreate(&os_params)) {
+        return 0;
+    }
+
+    if (umfMemoryProviderCreate(umfOsMemoryProviderOps(), os_params,
+                                &provider) != UMF_RESULT_SUCCESS) {
+        std::cerr << "Failed to create provider" << std::endl;
+        goto out;
+    }
+
+    if (umfPoolCreate(umfDisjointPoolOps(), provider, nullptr, 0, &pool) !=
+        UMF_RESULT_SUCCESS) {
+        std::cerr << "Failed to create disjoint pool" << std::endl;
+        goto out;
+    }
+
+    for (int i = 0; i < argc; i += 2) {
+        const char *name = argv[i];
+        const char *value = argv[i + 1];
+        char path[128];
+        snprintf(path, sizeof(path), "umf.pool.by_handle.{}.params.%s", name);
+
+        if (strcmp(name, "pool_trace") == 0) {
+            int got = 0;
+            if (umfCtlGet(path, &got, sizeof(got), pool) !=
+                UMF_RESULT_SUCCESS) {
+                std::cerr << "Failed to get " << name << std::endl;
+                goto out;
+            }
+            if (got != atoi(value)) {
+                std::cerr << "Expected " << name << " to be " << value
+                          << ", but got " << got << std::endl;
+                goto out;
+            }
+        } else {
+            size_t got = 0;
+            if (umfCtlGet(path, &got, sizeof(got), pool) !=
+                UMF_RESULT_SUCCESS) {
+                std::cerr << "Failed to get " << name << std::endl;
+                goto out;
+            }
+            if (got != strtoull(value, nullptr, 10)) {
+                std::cerr << "Expected " << name << " to be " << value
+                          << ", but got " << got << std::endl;
+                goto out;
+            }
+        }
+    }
+
+    ret = 0;
+
+out:
+    if (pool) {
+        umfPoolDestroy(pool);
+    }
+    if (provider) {
+        umfMemoryProviderDestroy(provider);
+    }
+    if (os_params) {
+        umfOsMemoryProviderParamsDestroy(os_params);
+    }
+
+    return ret;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 2) {
+        std::cerr << "Usage: " << argv[0] << " <test_name> args..."
+                  << std::endl;
+        return 1;
+    }
+    const char *test_name = argv[1];
+    argc -= 2;
+    argv += 2;
+    if (strcmp(test_name, "env_defaults") == 0) {
+        return test_env_defaults(argc, argv);
+    }
+
+    if (strcmp(test_name, "logger") == 0) {
+        return test_logger(argc, argv);
+    }
+
+    if (strcmp(test_name, "disjoint_pool") == 0) {
+        return test_disjoint_pool(argc, argv);
+    }
+    return 1;
+}
diff --git a/test/ctl/ctl_env_config1.cfg b/test/ctl/ctl_env_config1.cfg
new file mode 100644
index 0000000000..9831dc352e
--- /dev/null
+++ b/test/ctl/ctl_env_config1.cfg
@@ -0,0 +1,4 @@
+# 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
+umf.pool.default.test_pool.opt_one=opt_one_value1; # test comment
diff --git a/test/ctl/ctl_env_config2.cfg b/test/ctl/ctl_env_config2.cfg
new file mode 100644
index 0000000000..ca2b52d625
--- /dev/null
+++ b/test/ctl/ctl_env_config2.cfg
@@ -0,0 +1,5 @@
+# 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
+umf.pool.default.test_pool.opt_one=opt_one_value2;
+umf.pool.default.test_pool.opt_two=opt_two_value2;
diff --git a/test/ctl/ctl_env_disjoint_pool.cfg b/test/ctl/ctl_env_disjoint_pool.cfg
new file mode 100644
index 0000000000..7fd2635cd9
--- /dev/null
+++ b/test/ctl/ctl_env_disjoint_pool.cfg
@@ -0,0 +1,7 @@
+# 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
+umf.pool.default.disjoint.params.slab_min_size=65536;
+umf.pool.default.disjoint.params.capacity=4;
+umf.pool.default.disjoint.params.min_bucket_size=8;
+umf.pool.default.disjoint.params.pool_trace=0;
diff --git a/test/ctl/ctl_env_driver.cpp b/test/ctl/ctl_env_driver.cpp
new file mode 100644
index 0000000000..63a805abe5
--- /dev/null
+++ b/test/ctl/ctl_env_driver.cpp
@@ -0,0 +1,145 @@
+/*
+ *
+ * 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 <string>
+#include <vector>
+#ifdef _WIN32
+#include <process.h>
+#else
+#include <sys/wait.h>
+#include <unistd.h>
+#endif
+
+#include <umf.h>
+#include <umf/base.h>
+#include <umf/experimental/ctl.h>
+
+#include "../common/base.hpp"
+#include "gtest/gtest.h"
+
+using namespace umf_test;
+
+#ifndef CTL_ENV_APP
+#define CTL_ENV_APP "./ctl_env_app"
+#endif
+
+#ifndef CTL_CONF_FILE_DIR
+#define CTL_CONF_FILE_DIR "./ctl"
+#endif
+
+void set_env(std::pair<const std::string, const std::string> env) {
+    const auto &name = env.first;
+    const auto &value = env.second;
+
+    if (name.empty()) {
+        return;
+    }
+#ifdef _WIN32
+    _putenv_s(name.c_str(), value.c_str());
+#else
+    setenv(name.c_str(), value.c_str(), 1);
+#endif
+}
+
+static void run_case(
+    const std::vector<std::pair<const std::string, const std::string>> &env,
+    const std::vector<std::string> &args) {
+    for (const auto &e : env) {
+        set_env(e);
+    }
+
+#ifdef _WIN32
+    std::vector<const char *> cargs;
+    cargs.push_back(CTL_ENV_APP);
+    for (const auto &s : args) {
+        cargs.push_back(s.c_str());
+    }
+
+    cargs.push_back(nullptr);
+    intptr_t status = _spawnv(_P_WAIT, CTL_ENV_APP, cargs.data());
+    ASSERT_EQ(status, 0);
+#else
+    pid_t pid = fork();
+    if (pid == 0) {
+        std::vector<char *> cargs;
+        cargs.push_back(const_cast<char *>(CTL_ENV_APP));
+        for (const auto &s : args) {
+            cargs.push_back(const_cast<char *>(s.c_str()));
+        }
+        cargs.push_back(nullptr);
+        execv(CTL_ENV_APP, cargs.data());
+        std::cerr << "Failed to execute " << CTL_ENV_APP << std::endl;
+        _exit(127);
+    }
+    int status = 0;
+    waitpid(pid, &status, 0);
+    ASSERT_EQ(status, 0);
+#endif
+    for (const auto &e : env) {
+        set_env({e.first, ""}); // Clear the environment variable
+    }
+}
+
+TEST_F(test, ctl_env_defaults) {
+    run_case(
+        {{"UMF_CONF", "umf.pool.default.test_pool.opt_one=test_value"}},
+        {"env_defaults", "umf.pool.default.test_pool.opt_one", "test_value"});
+
+    run_case({{"UMF_CONF", "umf.pool.default.test_pool.opt_one=second"}},
+             {"env_defaults", "umf.pool.default.test_pool.opt_one", "second"});
+}
+
+TEST_F(test, ctl_env_file) {
+    std::string cfg1 = CTL_CONF_FILE_DIR "/ctl_env_config1.cfg";
+    std::string cfg2 = CTL_CONF_FILE_DIR "/ctl_env_config2.cfg";
+
+    run_case({{"UMF_CONF_FILE", cfg1}},
+             {"env_defaults", "umf.pool.default.test_pool.opt_one",
+              "opt_one_value1"});
+
+    run_case({{"UMF_CONF_FILE", cfg2}},
+             {"env_defaults", "umf.pool.default.test_pool.opt_one",
+              "opt_one_value2", "umf.pool.default.test_pool.opt_two",
+              "opt_two_value2"});
+}
+
+TEST_F(test, ctl_env_plus_file) {
+    std::string cfg = CTL_CONF_FILE_DIR "/ctl_env_config2.cfg";
+
+    // it is expected that configuration from file will override configuration from environment variable
+    run_case({{"UMF_CONF_FILE", cfg},
+              {"UMF_CONF", "umf.pool.default.test_pool.opt_one=first;umf.pool."
+                           "default.test_pool.opt_three=second"}},
+             {"env_defaults", "umf.pool.default.test_pool.opt_one",
+              "opt_one_value2", "umf.pool.default.test_pool.opt_two",
+              "opt_two_value2", "umf.pool.default.test_pool.opt_three",
+              "second"});
+}
+
+TEST_F(test, ctl_env_logger) {
+    run_case({{"UMF_CONF", "umf.logger.output=stdout;umf.logger.level=0"}},
+             {"logger", "stdout", "0"});
+}
+
+TEST_F(test, ctl_env_disjoint_pool_env) {
+    run_case(
+        {{"UMF_CONF", "umf.pool.default.disjoint.params.slab_min_size=65536;"
+                      "umf.pool.default.disjoint.params.capacity=4;"
+                      "umf.pool.default.disjoint.params.min_bucket_size=8;"
+                      "umf.pool.default.disjoint.params.pool_trace=0"}},
+        {"disjoint_pool", "slab_min_size", "65536", "capacity", "4",
+         "min_bucket_size", "8", "pool_trace", "0"});
+}
+
+TEST_F(test, ctl_env_disjoint_pool_file) {
+    std::string cfg = CTL_CONF_FILE_DIR "/ctl_env_disjoint_pool.cfg";
+    run_case({{"UMF_CONF_FILE", cfg}},
+             {"disjoint_pool", "slab_min_size", "65536", "capacity", "4",
+              "min_bucket_size", "8", "pool_trace", "0"});
+}
diff --git a/test/ctl/ctl_unittest.cpp b/test/ctl/ctl_unittest.cpp
new file mode 100644
index 0000000000..7ae2a12148
--- /dev/null
+++ b/test/ctl/ctl_unittest.cpp
@@ -0,0 +1,196 @@
+/*
+ *
+ * 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
+ *
+ */
+
+#include "../common/base.hpp"
+#include "ctl/ctl_debug.h"
+#include "ctl/ctl_internal.h"
+
+using namespace umf_test;
+
+void get_test_va_list(va_list *a, ...) { va_start(*a, a); }
+
+TEST_F(test, ctl_debug_read_from_string) {
+    initialize_debug_ctl();
+    auto ctl_handler = get_debug_ctl();
+    va_list empty_args;
+    get_test_va_list(&empty_args);
+    ASSERT_EQ(ctl_load_config_from_string(ctl_handler, NULL,
+                                          "debug.heap.alloc_pattern=1"),
+              UMF_RESULT_SUCCESS);
+
+    int value = 0;
+    ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
+              "debug.heap.alloc_pattern", CTL_QUERY_READ, &value, sizeof(value),
+              empty_args);
+    ASSERT_EQ(value, 1);
+
+    // Test setting alloc_pattern to 2
+    ASSERT_EQ(ctl_load_config_from_string(ctl_handler, NULL,
+                                          "debug.heap.alloc_pattern=2"),
+              UMF_RESULT_SUCCESS);
+    ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
+              "debug.heap.alloc_pattern", CTL_QUERY_READ, &value, sizeof(value),
+              empty_args);
+    ASSERT_EQ(value, 2);
+
+    // Test setting alloc_pattern to 0
+    ASSERT_EQ(ctl_load_config_from_string(ctl_handler, NULL,
+                                          "debug.heap.alloc_pattern=0"),
+              UMF_RESULT_SUCCESS);
+    ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
+              "debug.heap.alloc_pattern", CTL_QUERY_READ, &value, sizeof(value),
+              empty_args);
+    ASSERT_EQ(value, 0);
+
+    // Negative test: non-existent configuration
+    ASSERT_NE(ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
+                        "debug.heap.non_existent", CTL_QUERY_READ, &value,
+                        sizeof(value), empty_args),
+              UMF_RESULT_SUCCESS);
+
+    // Negative test: invalid path
+    ASSERT_NE(ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
+                        "invalid.path.alloc_pattern", CTL_QUERY_READ, &value,
+                        sizeof(value), empty_args),
+              UMF_RESULT_SUCCESS);
+    va_end(empty_args);
+}
+
+int ctl_config_write_to_file(const char *filename, const char *data) {
+    FILE *file = fopen(filename == NULL ? "config.txt" : filename, "w+");
+    if (file == NULL) {
+        return -1;
+    }
+    fputs(data, file);
+    fclose(file);
+    return 0;
+}
+
+TEST_F(test, ctl_debug_read_from_file) {
+    va_list empty_args;
+    get_test_va_list(&empty_args);
+#ifndef _WIN32
+    ASSERT_EQ(ctl_config_write_to_file(
+                  "config.txt", "debug.heap.alloc_pattern=321;\ndebug.heap."
+                                "enable_logging=1;\ndebug.heap.log_level=5;\n"),
+              0);
+    initialize_debug_ctl();
+    auto ctl_handler = get_debug_ctl();
+    ASSERT_EQ(ctl_load_config_from_file(ctl_handler, NULL, "config.txt"),
+              UMF_RESULT_SUCCESS);
+
+    int value = 0;
+    ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
+              "debug.heap.alloc_pattern", CTL_QUERY_READ, &value, 0,
+              empty_args);
+    ASSERT_EQ(value, 321);
+
+    value = 0;
+    ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC, "debug.heap.log_level",
+              CTL_QUERY_READ, &value, 0, empty_args);
+    ASSERT_EQ(value, 5);
+
+    value = 0;
+    ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
+              "debug.heap.enable_logging", CTL_QUERY_READ, &value, 0,
+              empty_args);
+    ASSERT_EQ(value, 1);
+#endif
+    va_end(empty_args);
+}
+
+void ctl_helper(struct ctl *ctl_handler, const char *name, int *out, ...) {
+    va_list args;
+    va_start(args, out);
+    umf_result_t ret = ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
+                                 name, CTL_QUERY_READ, out, sizeof(*out), args);
+    va_end(args);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+}
+
+TEST_F(test, ctl_debug_node_arg) {
+    initialize_debug_ctl();
+    auto ctl_handler = get_debug_ctl();
+    int arg;
+    va_list empty_args;
+    get_test_va_list(&empty_args);
+
+    // Following ctl_query calls are expected to return a int value
+    // passed as a parameter inside of the name
+    umf_result_t ret = ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
+                                 "debug.arg_test.972.arg_value", CTL_QUERY_READ,
+                                 &arg, sizeof(arg), empty_args);
+
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(arg, 972);
+
+    ret = ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
+                    "debug.arg_test.1410.arg_value", CTL_QUERY_READ, &arg,
+                    sizeof(arg), empty_args);
+
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(arg, 1410);
+
+    ret = ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
+                    "debug.arg_test_final.1514", CTL_QUERY_READ, &arg,
+                    sizeof(arg), empty_args);
+
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(arg, 1514);
+
+    ret = ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
+                    "debug.arg_test_final.1621", CTL_QUERY_READ, &arg,
+                    sizeof(arg), empty_args);
+
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(arg, 1621);
+
+    ASSERT_NO_FATAL_FAILURE(
+        ctl_helper(ctl_handler, "debug.arg_test.{}.arg_value", &arg, 1651));
+
+    ASSERT_EQ(arg, 1651);
+
+    ASSERT_NO_FATAL_FAILURE(ctl_helper(ctl_handler, "debug.{}.{}.arg_value",
+                                       &arg, "arg_test", 1655));
+
+    ASSERT_EQ(arg, 1655);
+
+    ASSERT_NO_FATAL_FAILURE(ctl_helper(ctl_handler, "{}.{}.{}.{}", &arg,
+                                       "debug", "arg_test", 1920, "arg_value"));
+
+    ASSERT_EQ(arg, 1920);
+    va_end(empty_args);
+}
+
+TEST_F(test, ctl_debug_node_arg_invalid) {
+    initialize_debug_ctl();
+    auto ctl_handler = get_debug_ctl();
+    int arg;
+    va_list empty_args;
+    get_test_va_list(&empty_args);
+
+    umf_result_t ret = ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
+                                 "debug.arg_test.42", CTL_QUERY_READ, &arg,
+                                 sizeof(arg), empty_args);
+
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_CTL_PATH);
+
+    ret = ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
+                    "debug.arg_test.arg_value", CTL_QUERY_READ, &arg,
+                    sizeof(arg), empty_args);
+
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_CTL_PATH);
+
+    ret = ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
+                    "debug.arg_test.wrong_type.arg_value", CTL_QUERY_READ, &arg,
+                    sizeof(arg), empty_args);
+
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_CTL_PATH);
+    va_end(empty_args);
+}
diff --git a/test/disjointCoarseMallocPool.cpp b/test/disjointCoarseMallocPool.cpp
deleted file mode 100644
index 32e1d24f36..0000000000
--- a/test/disjointCoarseMallocPool.cpp
+++ /dev/null
@@ -1,580 +0,0 @@
-/*
- * Copyright (C) 2023-2024 Intel Corporation
- *
- * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-*/
-
-#include <random>
-
-#include "provider.hpp"
-
-#include <umf/pools/pool_disjoint.h>
-#include <umf/providers/provider_coarse.h>
-
-using umf_test::KB;
-using umf_test::MB;
-using umf_test::test;
-
-#define GetStats umfCoarseMemoryProviderGetStats
-
-umf_memory_provider_ops_t UMF_MALLOC_MEMORY_PROVIDER_OPS =
-    umf::providerMakeCOps<umf_test::provider_ba_global, void>();
-
-struct CoarseWithMemoryStrategyTest
-    : umf_test::test,
-      ::testing::WithParamInterface<coarse_memory_provider_strategy_t> {
-    void SetUp() override {
-        test::SetUp();
-        allocation_strategy = this->GetParam();
-    }
-
-    coarse_memory_provider_strategy_t allocation_strategy;
-};
-
-INSTANTIATE_TEST_SUITE_P(
-    CoarseWithMemoryStrategyTest, CoarseWithMemoryStrategyTest,
-    ::testing::Values(UMF_COARSE_MEMORY_STRATEGY_FASTEST,
-                      UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE,
-                      UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE));
-
-TEST_P(CoarseWithMemoryStrategyTest, disjointCoarseMallocPool_basic) {
-    umf_memory_provider_handle_t malloc_memory_provider;
-    umf_result_t umf_result;
-
-    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
-                                         &malloc_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(malloc_memory_provider, nullptr);
-
-    const size_t init_buffer_size = 20 * MB;
-
-    coarse_memory_provider_params_t coarse_memory_provider_params;
-    // make sure there are no undefined members - prevent a UB
-    memset(&coarse_memory_provider_params, 0,
-           sizeof(coarse_memory_provider_params));
-    coarse_memory_provider_params.allocation_strategy = allocation_strategy;
-    coarse_memory_provider_params.upstream_memory_provider =
-        malloc_memory_provider;
-    coarse_memory_provider_params.destroy_upstream_memory_provider = true;
-    coarse_memory_provider_params.immediate_init_from_upstream = true;
-    coarse_memory_provider_params.init_buffer = nullptr;
-    coarse_memory_provider_params.init_buffer_size = init_buffer_size;
-
-    umf_memory_provider_handle_t coarse_memory_provider;
-    umf_result = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(),
-                                         &coarse_memory_provider_params,
-                                         &coarse_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(coarse_memory_provider, nullptr);
-
-    umf_disjoint_pool_params_handle_t disjoint_pool_params = NULL;
-    umf_result = umfDisjointPoolParamsCreate(&disjoint_pool_params);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(disjoint_pool_params, nullptr);
-    umf_result =
-        umfDisjointPoolParamsSetSlabMinSize(disjoint_pool_params, 4096);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    umf_result =
-        umfDisjointPoolParamsSetMaxPoolableSize(disjoint_pool_params, 4096);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    umf_result = umfDisjointPoolParamsSetCapacity(disjoint_pool_params, 4);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    umf_result =
-        umfDisjointPoolParamsSetMinBucketSize(disjoint_pool_params, 64);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    umf_result = umfDisjointPoolParamsSetTrace(disjoint_pool_params, 1);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-
-    umf_memory_pool_handle_t pool;
-    umf_result = umfPoolCreate(umfDisjointPoolOps(), coarse_memory_provider,
-                               disjoint_pool_params,
-                               UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &pool);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(pool, nullptr);
-
-    umf_result = umfDisjointPoolParamsDestroy(disjoint_pool_params);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-
-    // test
-
-    umf_memory_provider_handle_t prov = NULL;
-    umf_result = umfPoolGetMemoryProvider(pool, &prov);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(prov, nullptr);
-
-    // alloc 2x 2MB
-    void *p1 = umfPoolMalloc(pool, 2 * MB);
-    ASSERT_NE(p1, nullptr);
-    ASSERT_EQ(GetStats(prov).used_size, 2 * MB);
-    ASSERT_EQ(GetStats(prov).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(prov).num_all_blocks, 2);
-
-    void *p2 = umfPoolMalloc(pool, 2 * MB);
-    ASSERT_NE(p2, nullptr);
-    ASSERT_EQ(GetStats(prov).used_size, 4 * MB);
-    ASSERT_EQ(GetStats(prov).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(prov).num_all_blocks, 3);
-    ASSERT_NE(p1, p2);
-
-    // swap pointers to get p1 < p2
-    if (p1 > p2) {
-        std::swap(p1, p2);
-    }
-
-    // free + alloc first block
-    // the block should be reused
-    // currently there is no purging, so the alloc size shouldn't change
-    // there should be no block merging between used and not-used blocks
-    umf_result = umfPoolFree(pool, p1);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(GetStats(prov).used_size, 2 * MB);
-    ASSERT_EQ(GetStats(prov).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(prov).num_all_blocks, 3);
-
-    p1 = umfPoolMalloc(pool, 2 * MB);
-    ASSERT_EQ(GetStats(prov).used_size, 4 * MB);
-    ASSERT_EQ(GetStats(prov).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(prov).num_all_blocks, 3);
-
-    // free all allocs
-    // overall alloc size shouldn't change
-    // block p2 should merge with the prev free block p1
-    // and the remaining init block
-    umf_result = umfPoolFree(pool, p1);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(GetStats(prov).num_all_blocks, 3);
-    umf_result = umfPoolFree(pool, p2);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(GetStats(prov).used_size, 0 * MB);
-    ASSERT_EQ(GetStats(prov).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(prov).num_all_blocks, 1);
-
-    // test allocations with alignment
-    // TODO: what about holes?
-    p1 = umfPoolAlignedMalloc(pool, 1 * MB - 4, 128);
-    ASSERT_NE(p1, nullptr);
-    ASSERT_EQ((uintptr_t)p1 & 127, 0);
-    p2 = umfPoolAlignedMalloc(pool, 1 * MB - 4, 128);
-    ASSERT_NE(p2, nullptr);
-    ASSERT_EQ((uintptr_t)p1 & 127, 0);
-    umf_result = umfPoolFree(pool, p1);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    umf_result = umfPoolFree(pool, p2);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-
-    // alloc whole buffer
-    // after this, there should be one single block
-    p1 = umfPoolMalloc(pool, init_buffer_size);
-    ASSERT_EQ(GetStats(prov).used_size, init_buffer_size);
-    ASSERT_EQ(GetStats(prov).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(prov).num_all_blocks, 1);
-
-    // free all memory
-    // alloc 2 MB block - the init block should be split
-    umf_result = umfPoolFree(pool, p1);
-    p1 = umfPoolMalloc(pool, 2 * MB);
-    ASSERT_EQ(GetStats(prov).used_size, 2 * MB);
-    ASSERT_EQ(GetStats(prov).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(prov).num_all_blocks, 2);
-
-    // alloc additional 2 MB
-    // the non-used block should be used
-    p2 = umfPoolMalloc(pool, 2 * MB);
-    ASSERT_EQ(GetStats(prov).used_size, 4 * MB);
-    ASSERT_EQ(GetStats(prov).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(prov).num_all_blocks, 3);
-    ASSERT_NE(p1, p2);
-
-    // make sure that p1 < p2
-    if (p1 > p2) {
-        std::swap(p1, p2);
-    }
-
-    // free blocks in order: p2, p1
-    // block p1 should merge with the next block p2
-    // swap pointers to get p1 < p2
-    umfPoolFree(pool, p2);
-    umfPoolFree(pool, p1);
-    ASSERT_EQ(GetStats(prov).used_size, 0 * MB);
-    ASSERT_EQ(GetStats(prov).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(prov).num_all_blocks, 1);
-
-    // alloc 10x 2 MB - this should occupy all allocated memory
-    constexpr int allocs_size = 10;
-    void *allocs[allocs_size] = {0};
-    for (int i = 0; i < allocs_size; i++) {
-        ASSERT_EQ(GetStats(prov).used_size, i * 2 * MB);
-        allocs[i] = umfPoolMalloc(pool, 2 * MB);
-        ASSERT_NE(allocs[i], nullptr);
-    }
-    ASSERT_EQ(GetStats(prov).used_size, 20 * MB);
-    ASSERT_EQ(GetStats(prov).alloc_size, init_buffer_size);
-    // there should be no block with the free memory
-    ASSERT_EQ(GetStats(prov).num_all_blocks, allocs_size);
-
-    // free all memory
-    for (int i = 0; i < allocs_size; i++) {
-        umf_result = umfPoolFree(pool, allocs[i]);
-        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    }
-
-    ASSERT_EQ(GetStats(prov).num_all_blocks, 1);
-    ASSERT_EQ(GetStats(prov).used_size, 0 * MB);
-    ASSERT_EQ(GetStats(prov).alloc_size, init_buffer_size);
-
-    umfPoolDestroy(pool);
-    // Both coarse_memory_provider and malloc_memory_provider
-    // have already been destroyed by umfPoolDestroy(), because:
-    // UMF_POOL_CREATE_FLAG_OWN_PROVIDER was set in umfPoolCreate() and
-    // coarse_memory_provider_params.destroy_upstream_memory_provider = true;
-}
-
-TEST_P(CoarseWithMemoryStrategyTest, disjointCoarseMallocPool_simple1) {
-    umf_memory_provider_handle_t malloc_memory_provider;
-    umf_result_t umf_result;
-
-    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
-                                         &malloc_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(malloc_memory_provider, nullptr);
-
-    const size_t init_buffer_size = 20 * MB;
-
-    coarse_memory_provider_params_t coarse_memory_provider_params;
-    // make sure there are no undefined members - prevent a UB
-    memset(&coarse_memory_provider_params, 0,
-           sizeof(coarse_memory_provider_params));
-    coarse_memory_provider_params.allocation_strategy = allocation_strategy;
-    coarse_memory_provider_params.upstream_memory_provider =
-        malloc_memory_provider;
-    coarse_memory_provider_params.immediate_init_from_upstream = true;
-    coarse_memory_provider_params.init_buffer = NULL;
-    coarse_memory_provider_params.init_buffer_size = init_buffer_size;
-
-    umf_memory_provider_handle_t coarse_memory_provider;
-    umf_result = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(),
-                                         &coarse_memory_provider_params,
-                                         &coarse_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(coarse_memory_provider, nullptr);
-
-    umf_disjoint_pool_params_handle_t disjoint_pool_params = NULL;
-    umf_result = umfDisjointPoolParamsCreate(&disjoint_pool_params);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(disjoint_pool_params, nullptr);
-    umf_result =
-        umfDisjointPoolParamsSetSlabMinSize(disjoint_pool_params, 4096);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    umf_result =
-        umfDisjointPoolParamsSetMaxPoolableSize(disjoint_pool_params, 4096);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    umf_result = umfDisjointPoolParamsSetCapacity(disjoint_pool_params, 4);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    umf_result =
-        umfDisjointPoolParamsSetMinBucketSize(disjoint_pool_params, 64);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    umf_result = umfDisjointPoolParamsSetTrace(disjoint_pool_params, 1);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-
-    umf_memory_pool_handle_t pool;
-    umf_result =
-        umfPoolCreate(umfDisjointPoolOps(), coarse_memory_provider,
-                      disjoint_pool_params, UMF_POOL_CREATE_FLAG_NONE, &pool);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(pool, nullptr);
-
-    umf_result = umfDisjointPoolParamsDestroy(disjoint_pool_params);
-
-    umf_memory_provider_handle_t prov = NULL;
-    umfPoolGetMemoryProvider(pool, &prov);
-    ASSERT_NE(prov, nullptr);
-
-    // test 1
-
-    size_t s1 = 74659 * KB;
-    size_t s2 = 8206 * KB;
-
-    size_t max_alloc_size = 0;
-
-    const int nreps = 2;
-    const int nptrs = 6;
-
-    // s1
-    for (int j = 0; j < nreps; j++) {
-        void *t[nptrs] = {0};
-        for (int i = 0; i < nptrs; i++) {
-            t[i] = umfPoolMalloc(pool, s1);
-            ASSERT_NE(t[i], nullptr);
-        }
-
-        if (max_alloc_size == 0) {
-            max_alloc_size = GetStats(prov).alloc_size;
-        }
-
-        for (int i = 0; i < nptrs; i++) {
-            umf_result = umfPoolFree(pool, t[i]);
-            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-        }
-    }
-
-    // s2
-    for (int j = 0; j < nreps; j++) {
-        void *t[nptrs] = {0};
-        for (int i = 0; i < nptrs; i++) {
-            t[i] = umfPoolMalloc(pool, s2);
-            ASSERT_NE(t[i], nullptr);
-        }
-
-        // all s2 should fit into single block leaved after freeing s1
-        ASSERT_LE(GetStats(prov).alloc_size, max_alloc_size);
-
-        for (int i = 0; i < nptrs; i++) {
-            umf_result = umfPoolFree(pool, t[i]);
-            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-        }
-    }
-
-    umfPoolDestroy(pool);
-    umfMemoryProviderDestroy(coarse_memory_provider);
-    umfMemoryProviderDestroy(malloc_memory_provider);
-}
-
-TEST_P(CoarseWithMemoryStrategyTest, disjointCoarseMallocPool_simple2) {
-    umf_memory_provider_handle_t malloc_memory_provider;
-    umf_result_t umf_result;
-
-    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
-                                         &malloc_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(malloc_memory_provider, nullptr);
-
-    const size_t init_buffer_size = 20 * MB;
-
-    coarse_memory_provider_params_t coarse_memory_provider_params;
-    // make sure there are no undefined members - prevent a UB
-    memset(&coarse_memory_provider_params, 0,
-           sizeof(coarse_memory_provider_params));
-    coarse_memory_provider_params.allocation_strategy = allocation_strategy;
-    coarse_memory_provider_params.upstream_memory_provider =
-        malloc_memory_provider;
-    coarse_memory_provider_params.immediate_init_from_upstream = true;
-    coarse_memory_provider_params.init_buffer = NULL;
-    coarse_memory_provider_params.init_buffer_size = init_buffer_size;
-
-    umf_memory_provider_handle_t coarse_memory_provider;
-    umf_result = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(),
-                                         &coarse_memory_provider_params,
-                                         &coarse_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(coarse_memory_provider, nullptr);
-
-    umf_disjoint_pool_params_handle_t disjoint_pool_params = NULL;
-    umf_result = umfDisjointPoolParamsCreate(&disjoint_pool_params);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(disjoint_pool_params, nullptr);
-    umf_result =
-        umfDisjointPoolParamsSetSlabMinSize(disjoint_pool_params, 4096);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    umf_result =
-        umfDisjointPoolParamsSetMaxPoolableSize(disjoint_pool_params, 4096);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    umf_result = umfDisjointPoolParamsSetCapacity(disjoint_pool_params, 4);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    umf_result =
-        umfDisjointPoolParamsSetMinBucketSize(disjoint_pool_params, 64);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    umf_result = umfDisjointPoolParamsSetTrace(disjoint_pool_params, 1);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-
-    umf_memory_pool_handle_t pool;
-    umf_result =
-        umfPoolCreate(umfDisjointPoolOps(), coarse_memory_provider,
-                      disjoint_pool_params, UMF_POOL_CREATE_FLAG_NONE, &pool);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(pool, nullptr);
-
-    umf_result = umfDisjointPoolParamsDestroy(disjoint_pool_params);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-
-    // test
-    double sizes[] = {2, 4, 0.5, 1, 8, 0.25};
-    size_t alignment[] = {0, 4, 0, 16, 32, 128};
-    for (int i = 0; i < 6; i++) {
-        size_t s = (size_t)(sizes[i] * MB);
-        void *t[8] = {0};
-        for (int j = 0; j < 8; j++) {
-            t[j] = umfPoolAlignedMalloc(pool, s, alignment[i]);
-            ASSERT_NE(t[j], nullptr);
-        }
-
-        for (int j = 0; j < 8; j++) {
-            umf_result = umfPoolFree(pool, t[j]);
-            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-        }
-    }
-
-    umfPoolDestroy(pool);
-    umfMemoryProviderDestroy(coarse_memory_provider);
-    umfMemoryProviderDestroy(malloc_memory_provider);
-}
-
-struct alloc_ptr_size {
-    void *ptr;
-    size_t size;
-
-    bool operator<(const alloc_ptr_size &other) const {
-        if (ptr == other.ptr) {
-            return size < other.size;
-        }
-        return ptr < other.ptr;
-    }
-};
-
-TEST_P(CoarseWithMemoryStrategyTest, disjointCoarseMMapPool_random) {
-    umf_result_t umf_result;
-
-    const size_t init_buffer_size = 200 * MB;
-
-    // preallocate some memory and initialize the vector with zeros
-    std::vector<char> buffer(init_buffer_size, 0);
-    void *buf = (void *)buffer.data();
-    ASSERT_NE(buf, nullptr);
-
-    const unsigned char alloc_check_val = 11;
-
-    coarse_memory_provider_params_t coarse_memory_provider_params;
-    // make sure there are no undefined members - prevent a UB
-    memset(&coarse_memory_provider_params, 0,
-           sizeof(coarse_memory_provider_params));
-    coarse_memory_provider_params.allocation_strategy = allocation_strategy;
-    coarse_memory_provider_params.upstream_memory_provider = NULL;
-    coarse_memory_provider_params.immediate_init_from_upstream = false;
-    coarse_memory_provider_params.init_buffer = buf;
-    coarse_memory_provider_params.init_buffer_size = init_buffer_size;
-
-    umf_memory_provider_handle_t coarse_memory_provider;
-    umf_result = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(),
-                                         &coarse_memory_provider_params,
-                                         &coarse_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(coarse_memory_provider, nullptr);
-
-    umf_disjoint_pool_params_handle_t disjoint_pool_params = NULL;
-    umf_result = umfDisjointPoolParamsCreate(&disjoint_pool_params);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(disjoint_pool_params, nullptr);
-    umf_result =
-        umfDisjointPoolParamsSetSlabMinSize(disjoint_pool_params, 1024);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    umf_result =
-        umfDisjointPoolParamsSetMaxPoolableSize(disjoint_pool_params, 1024);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    umf_result = umfDisjointPoolParamsSetCapacity(disjoint_pool_params, 2);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    umf_result =
-        umfDisjointPoolParamsSetMinBucketSize(disjoint_pool_params, 16);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    umf_result = umfDisjointPoolParamsSetTrace(disjoint_pool_params, 1);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-
-    umf_memory_pool_handle_t pool;
-    umf_result =
-        umfPoolCreate(umfDisjointPoolOps(), coarse_memory_provider,
-                      disjoint_pool_params, UMF_POOL_CREATE_FLAG_NONE, &pool);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(pool, nullptr);
-
-    umf_result = umfDisjointPoolParamsDestroy(disjoint_pool_params);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-
-    // set constant seed so each test run will have the same scenario
-    uint32_t seed = 1234;
-    std::mt19937 mt(seed);
-
-    // different sizes to alloc
-    std::vector<size_t> sizes = {15,        49,     588,      1025,
-                                 2 * KB,    5 * KB, 160 * KB, 511 * KB,
-                                 1000 * KB, MB,     3 * MB,   7 * MB};
-    std::uniform_int_distribution<int> sizes_dist(0, (int)(sizes.size() - 1));
-
-    // each alloc would be done few times
-    std::vector<size_t> counts = {1, 3, 4, 8, 9, 11};
-    std::uniform_int_distribution<int> counts_dist(0, (int)(counts.size() - 1));
-
-    // action to take will be random
-    // alloc = <0, .5), free = <.5, 1)
-    std::uniform_real_distribution<float> actions_dist(0, 1);
-
-    std::set<alloc_ptr_size> allocs;
-    const int nreps = 100;
-
-    for (size_t i = 0; i < nreps; i++) {
-        size_t count = counts[counts_dist(mt)];
-        float action = actions_dist(mt);
-
-        if (action < 0.5) {
-            size_t size = sizes[sizes_dist(mt)];
-            std::cout << "size: " << size << " count: " << count
-                      << " action: alloc" << std::endl;
-
-            // alloc
-            for (size_t j = 0; j < count; j++) {
-                void *ptr = umfPoolMalloc(pool, size);
-                ASSERT_NE(ptr, nullptr);
-
-                if (ptr == nullptr) {
-                    break;
-                }
-
-                // check if first and last bytes are empty and fill them with control data
-                ASSERT_EQ(((unsigned char *)ptr)[0], 0);
-                ASSERT_EQ(((unsigned char *)ptr)[size - 1], 0);
-                ((unsigned char *)ptr)[0] = alloc_check_val;
-                ((unsigned char *)ptr)[size - 1] = alloc_check_val;
-
-                allocs.insert({ptr, size});
-            }
-        } else {
-            std::cout << "count: " << count << " action: free" << std::endl;
-
-            // free random allocs
-            for (size_t j = 0; j < count; j++) {
-                if (allocs.size() == 0) {
-                    continue;
-                }
-
-                std::uniform_int_distribution<int> free_dist(
-                    0, (int)(allocs.size() - 1));
-                size_t free_id = free_dist(mt);
-                auto it = allocs.begin();
-                std::advance(it, free_id);
-                auto [ptr, size] = (*it);
-                ASSERT_NE(ptr, nullptr);
-
-                // check if control bytes are set and clean them
-
-                ASSERT_EQ(((unsigned char *)ptr)[0], alloc_check_val);
-                ASSERT_EQ(((unsigned char *)ptr)[size - 1], alloc_check_val);
-                ((unsigned char *)ptr)[0] = 0;
-                ((unsigned char *)ptr)[size - 1] = 0;
-
-                umf_result_t ret = umfPoolFree(pool, ptr);
-                ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-
-                allocs.erase(it);
-            }
-        }
-    }
-
-    std::cout << "cleanup" << std::endl;
-
-    while (allocs.size()) {
-        umf_result_t ret = umfPoolFree(pool, (*allocs.begin()).ptr);
-        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-        allocs.erase(allocs.begin());
-    }
-
-    umfPoolDestroy(pool);
-    umfMemoryProviderDestroy(coarse_memory_provider);
-}
diff --git a/test/disjoint_pool_file_prov.cpp b/test/disjoint_pool_file_prov.cpp
new file mode 100644
index 0000000000..817a0c1088
--- /dev/null
+++ b/test/disjoint_pool_file_prov.cpp
@@ -0,0 +1,377 @@
+/*
+ * 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 <random>
+
+#include <umf/pools/pool_disjoint.h>
+#include <umf/providers/provider_file_memory.h>
+
+#include "coarse.h"
+#include "provider.hpp"
+
+using umf_test::KB;
+using umf_test::MB;
+using umf_test::test;
+
+#define FILE_PATH ((char *)"tmp_file")
+
+umf_memory_provider_ops_t UMF_MALLOC_MEMORY_PROVIDER_OPS =
+    umf_test::providerMakeCOps<umf_test::provider_ba_global, void>();
+
+struct FileWithMemoryStrategyTest
+    : umf_test::test,
+      ::testing::WithParamInterface<coarse_strategy_t> {
+    void SetUp() override {
+        test::SetUp();
+        allocation_strategy = this->GetParam();
+    }
+
+    coarse_strategy_t allocation_strategy;
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    FileWithMemoryStrategyTest, FileWithMemoryStrategyTest,
+    ::testing::Values(UMF_COARSE_MEMORY_STRATEGY_FASTEST,
+                      UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE,
+                      UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE),
+    ([](auto const &info) -> std::string {
+        const char *names[] = {"UMF_COARSE_MEMORY_STRATEGY_FASTEST",
+                               "UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE",
+                               "UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE"};
+        return names[info.index];
+    }));
+
+TEST_P(FileWithMemoryStrategyTest, disjointFileMallocPool_simple1) {
+    umf_memory_provider_handle_t malloc_memory_provider = nullptr;
+    umf_result_t umf_result;
+
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS,
+                                         nullptr, &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    umf_file_memory_provider_params_handle_t file_params = nullptr;
+    umf_result = umfFileMemoryProviderParamsCreate(FILE_PATH, &file_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(file_params, nullptr);
+
+    umf_memory_provider_handle_t file_memory_provider;
+    umf_result = umfMemoryProviderCreate(umfFileMemoryProviderOps(),
+                                         file_params, &file_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(file_memory_provider, nullptr);
+
+    umf_result = umfFileMemoryProviderParamsDestroy(file_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_disjoint_pool_params_handle_t disjoint_pool_params = nullptr;
+    umf_result = umfDisjointPoolParamsCreate(&disjoint_pool_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(disjoint_pool_params, nullptr);
+    umf_result =
+        umfDisjointPoolParamsSetSlabMinSize(disjoint_pool_params, 4096);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result =
+        umfDisjointPoolParamsSetMaxPoolableSize(disjoint_pool_params, 4096);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfDisjointPoolParamsSetCapacity(disjoint_pool_params, 4);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result =
+        umfDisjointPoolParamsSetMinBucketSize(disjoint_pool_params, 64);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfDisjointPoolParamsSetTrace(disjoint_pool_params, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_memory_pool_handle_t pool;
+    umf_result =
+        umfPoolCreate(umfDisjointPoolOps(), file_memory_provider,
+                      disjoint_pool_params, UMF_POOL_CREATE_FLAG_NONE, &pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(pool, nullptr);
+
+    umf_result = umfDisjointPoolParamsDestroy(disjoint_pool_params);
+
+    umf_memory_provider_handle_t prov = nullptr;
+    umfPoolGetMemoryProvider(pool, &prov);
+    ASSERT_NE(prov, nullptr);
+
+    // test 1
+
+    size_t s1 = 74659 * KB;
+    size_t s2 = 8206 * KB;
+
+    const int nreps = 2;
+    const int nptrs = 6;
+
+    // s1
+    for (int j = 0; j < nreps; j++) {
+        void *t[nptrs] = {0};
+        for (int i = 0; i < nptrs; i++) {
+            t[i] = umfPoolMalloc(pool, s1);
+            ASSERT_NE(t[i], nullptr);
+        }
+
+        for (int i = 0; i < nptrs; i++) {
+            umf_result = umfPoolFree(pool, t[i]);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+    }
+
+    // s2
+    for (int j = 0; j < nreps; j++) {
+        void *t[nptrs] = {0};
+        for (int i = 0; i < nptrs; i++) {
+            t[i] = umfPoolMalloc(pool, s2);
+            ASSERT_NE(t[i], nullptr);
+        }
+
+        for (int i = 0; i < nptrs; i++) {
+            umf_result = umfPoolFree(pool, t[i]);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+    }
+
+    umf_result = umfPoolDestroy(pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(file_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(FileWithMemoryStrategyTest, disjointFileMallocPool_simple2) {
+    umf_memory_provider_handle_t malloc_memory_provider = nullptr;
+    umf_result_t umf_result;
+
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS,
+                                         nullptr, &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    umf_file_memory_provider_params_handle_t file_params = nullptr;
+    umf_result = umfFileMemoryProviderParamsCreate(FILE_PATH, &file_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(file_params, nullptr);
+
+    umf_memory_provider_handle_t file_memory_provider;
+    umf_result = umfMemoryProviderCreate(umfFileMemoryProviderOps(),
+                                         file_params, &file_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(file_memory_provider, nullptr);
+
+    umf_result = umfFileMemoryProviderParamsDestroy(file_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_disjoint_pool_params_handle_t disjoint_pool_params = nullptr;
+    umf_result = umfDisjointPoolParamsCreate(&disjoint_pool_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(disjoint_pool_params, nullptr);
+    umf_result =
+        umfDisjointPoolParamsSetSlabMinSize(disjoint_pool_params, 4096);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result =
+        umfDisjointPoolParamsSetMaxPoolableSize(disjoint_pool_params, 4096);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfDisjointPoolParamsSetCapacity(disjoint_pool_params, 4);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result =
+        umfDisjointPoolParamsSetMinBucketSize(disjoint_pool_params, 64);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfDisjointPoolParamsSetTrace(disjoint_pool_params, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_memory_pool_handle_t pool;
+    umf_result =
+        umfPoolCreate(umfDisjointPoolOps(), file_memory_provider,
+                      disjoint_pool_params, UMF_POOL_CREATE_FLAG_NONE, &pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(pool, nullptr);
+
+    umf_result = umfDisjointPoolParamsDestroy(disjoint_pool_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // test
+    double sizes[] = {2, 4, 0.5, 1, 8, 0.25};
+    size_t alignment[] = {0, 4, 0, 16, 32, 128};
+    for (int i = 0; i < 6; i++) {
+        size_t s = (size_t)(sizes[i] * MB);
+        void *t[8] = {0};
+        for (int j = 0; j < 8; j++) {
+            t[j] = umfPoolAlignedMalloc(pool, s, alignment[i]);
+            ASSERT_NE(t[j], nullptr);
+        }
+
+        for (int j = 0; j < 8; j++) {
+            umf_result = umfPoolFree(pool, t[j]);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+    }
+
+    umf_result = umfPoolDestroy(pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(file_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+struct alloc_ptr_size {
+    void *ptr;
+    size_t size;
+
+    bool operator<(const alloc_ptr_size &other) const {
+        if (ptr == other.ptr) {
+            return size < other.size;
+        }
+        return ptr < other.ptr;
+    }
+};
+
+TEST_P(FileWithMemoryStrategyTest, disjointFileMMapPool_random) {
+    umf_result_t umf_result;
+
+    const size_t init_buffer_size = 200 * MB;
+
+    // preallocate some memory and initialize the vector with zeros
+    std::vector<char> buffer(init_buffer_size, 0);
+    void *buf = (void *)buffer.data();
+    ASSERT_NE(buf, nullptr);
+
+    const unsigned char alloc_check_val = 11;
+
+    umf_file_memory_provider_params_handle_t file_params = nullptr;
+    umf_result = umfFileMemoryProviderParamsCreate(FILE_PATH, &file_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(file_params, nullptr);
+
+    umf_memory_provider_handle_t file_memory_provider;
+    umf_result = umfMemoryProviderCreate(umfFileMemoryProviderOps(),
+                                         file_params, &file_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(file_memory_provider, nullptr);
+
+    umf_result = umfFileMemoryProviderParamsDestroy(file_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_disjoint_pool_params_handle_t disjoint_pool_params = nullptr;
+    umf_result = umfDisjointPoolParamsCreate(&disjoint_pool_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(disjoint_pool_params, nullptr);
+    umf_result =
+        umfDisjointPoolParamsSetSlabMinSize(disjoint_pool_params, 1024);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result =
+        umfDisjointPoolParamsSetMaxPoolableSize(disjoint_pool_params, 1024);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfDisjointPoolParamsSetCapacity(disjoint_pool_params, 2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result =
+        umfDisjointPoolParamsSetMinBucketSize(disjoint_pool_params, 16);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfDisjointPoolParamsSetTrace(disjoint_pool_params, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_memory_pool_handle_t pool;
+    umf_result =
+        umfPoolCreate(umfDisjointPoolOps(), file_memory_provider,
+                      disjoint_pool_params, UMF_POOL_CREATE_FLAG_NONE, &pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(pool, nullptr);
+
+    umf_result = umfDisjointPoolParamsDestroy(disjoint_pool_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // set constant seed so each test run will have the same scenario
+    uint32_t seed = 1234;
+    std::mt19937 mt(seed);
+
+    // different sizes to alloc
+    std::vector<size_t> sizes = {15,        49,     588,      1025,
+                                 2 * KB,    5 * KB, 160 * KB, 511 * KB,
+                                 1000 * KB, MB,     3 * MB,   7 * MB};
+    std::uniform_int_distribution<int> sizes_dist(0, (int)(sizes.size() - 1));
+
+    // each alloc would be done few times
+    std::vector<size_t> counts = {1, 3, 4, 8, 9, 11};
+    std::uniform_int_distribution<int> counts_dist(0, (int)(counts.size() - 1));
+
+    // action to take will be random
+    // alloc = <0, .5), free = <.5, 1)
+    std::uniform_real_distribution<float> actions_dist(0, 1);
+
+    std::set<alloc_ptr_size> allocs;
+    const int nreps = 100;
+
+    for (size_t i = 0; i < nreps; i++) {
+        size_t count = counts[counts_dist(mt)];
+        float action = actions_dist(mt);
+
+        if (action < 0.5) {
+            size_t size = sizes[sizes_dist(mt)];
+            std::cout << "size: " << size << " count: " << count
+                      << " action: alloc" << std::endl;
+
+            // alloc
+            for (size_t j = 0; j < count; j++) {
+                void *ptr = umfPoolCalloc(pool, 1, size);
+                if (ptr == nullptr) {
+                    break;
+                }
+
+                // check if first and last bytes are empty and fill them with control data
+                ASSERT_EQ(((unsigned char *)ptr)[0], 0);
+                ASSERT_EQ(((unsigned char *)ptr)[size - 1], 0);
+                ((unsigned char *)ptr)[0] = alloc_check_val;
+                ((unsigned char *)ptr)[size - 1] = alloc_check_val;
+
+                allocs.insert({ptr, size});
+            }
+        } else {
+            std::cout << "count: " << count << " action: free" << std::endl;
+
+            // free random allocs
+            for (size_t j = 0; j < count; j++) {
+                if (allocs.size() == 0) {
+                    continue;
+                }
+
+                std::uniform_int_distribution<int> free_dist(
+                    0, (int)(allocs.size() - 1));
+                size_t free_id = free_dist(mt);
+                auto it = allocs.begin();
+                std::advance(it, free_id);
+                auto [ptr, size] = (*it);
+                ASSERT_NE(ptr, nullptr);
+
+                // check if control bytes are set and clean them
+
+                ASSERT_EQ(((unsigned char *)ptr)[0], alloc_check_val);
+                ASSERT_EQ(((unsigned char *)ptr)[size - 1], alloc_check_val);
+                ((unsigned char *)ptr)[0] = 0;
+                ((unsigned char *)ptr)[size - 1] = 0;
+
+                umf_result_t ret = umfPoolFree(pool, ptr);
+                ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+                allocs.erase(it);
+            }
+        }
+    }
+
+    std::cout << "cleanup" << std::endl;
+
+    while (allocs.size()) {
+        umf_result_t ret = umfPoolFree(pool, (*allocs.begin()).ptr);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        allocs.erase(allocs.begin());
+    }
+
+    umf_result = umfPoolDestroy(pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(file_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
diff --git a/test/fuzz/umfFuzz.cpp b/test/fuzz/umfFuzz.cpp
index 360184c731..a4936ff5fc 100644
--- a/test/fuzz/umfFuzz.cpp
+++ b/test/fuzz/umfFuzz.cpp
@@ -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
 
@@ -12,7 +12,7 @@ constexpr int MAX_POOLS_ALLOC_SIZE = 1 * 1024;      // 1 kB
 constexpr int MAX_PROVIDER_ALLOC_SIZE = 100 * 1024; // 100 kB
 
 int umf_memory_provider_create(TestState &test_state) {
-    umf_memory_provider_ops_t *provider_ops = umfOsMemoryProviderOps();
+    const umf_memory_provider_ops_t *provider_ops = umfOsMemoryProviderOps();
     umf_os_memory_provider_params_handle_t params = NULL;
 
     umf_result_t res = umfOsMemoryProviderParamsCreate(&params);
@@ -79,7 +79,7 @@ int umf_pool_create(TestState &test_state) {
         return -1;
     }
 
-    umf_memory_pool_ops_t *pool_ops = umfScalablePoolOps();
+    const umf_memory_pool_ops_t *pool_ops = umfScalablePoolOps();
     void *pool_params = NULL;
     umf_pool_create_flags_t flags = 0;
     umf_memory_pool_handle_t pool;
diff --git a/test/fuzz/utils.hpp b/test/fuzz/utils.hpp
index 645353fb24..b8ff271123 100644
--- a/test/fuzz/utils.hpp
+++ b/test/fuzz/utils.hpp
@@ -1,18 +1,19 @@
-// 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
 
 #ifndef UMF_TEST_FUZZ_UTILS_HPP
 #define UMF_TEST_FUZZ_UTILS_HPP
 
-#include "umf/pools/pool_scalable.h"
-#include "umf/providers/provider_os_memory.h"
 #include <fuzzer/FuzzedDataProvider.h>
 #include <iostream>
 #include <map>
 #include <memory>
 #include <vector>
 
+#include <umf/pools/pool_scalable.h>
+#include <umf/providers/provider_os_memory.h>
+
 namespace fuzz {
 
 enum FuzzerAPICall : uint8_t {
diff --git a/test/ipcAPI.cpp b/test/ipcAPI.cpp
index 4df32a1c9b..c9496f863d 100644
--- a/test/ipcAPI.cpp
+++ b/test/ipcAPI.cpp
@@ -1,4 +1,4 @@
-// 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
 // This file contains tests for UMF pool API
@@ -38,6 +38,7 @@ struct provider_mock_ipc : public umf_test::provider_base_t {
         }
         return ret;
     }
+
     umf_result_t free(void *ptr, size_t size) noexcept {
         allocations_write_lock_type lock(alloc_mutex);
         allocations.erase(ptr);
@@ -45,13 +46,19 @@ struct provider_mock_ipc : public umf_test::provider_base_t {
         auto ret = helper_prov.free(ptr, size);
         return ret;
     }
-    const char *get_name() noexcept { return "mock_ipc"; }
-    umf_result_t get_ipc_handle_size(size_t *size) noexcept {
+
+    umf_result_t get_name(const char **name) noexcept {
+        *name = "mock_ipc";
+        return UMF_RESULT_SUCCESS;
+    }
+
+    umf_result_t ext_get_ipc_handle_size(size_t *size) noexcept {
         *size = sizeof(provider_ipc_data_t);
         return UMF_RESULT_SUCCESS;
     }
-    umf_result_t get_ipc_handle(const void *ptr, size_t size,
-                                void *providerIpcData) noexcept {
+
+    umf_result_t ext_get_ipc_handle(const void *ptr, size_t size,
+                                    void *providerIpcData) noexcept {
         provider_ipc_data_t *ipcData =
             static_cast<provider_ipc_data_t *>(providerIpcData);
         // we do not need lock for allocations map here, because we just read
@@ -69,11 +76,14 @@ struct provider_mock_ipc : public umf_test::provider_base_t {
         ipcData->size = size; // size of the base allocation
         return UMF_RESULT_SUCCESS;
     }
-    umf_result_t put_ipc_handle(void *providerIpcData) noexcept {
+
+    umf_result_t ext_put_ipc_handle(void *providerIpcData) noexcept {
         (void)providerIpcData;
         return UMF_RESULT_SUCCESS;
     }
-    umf_result_t open_ipc_handle(void *providerIpcData, void **ptr) noexcept {
+
+    umf_result_t ext_open_ipc_handle(void *providerIpcData,
+                                     void **ptr) noexcept {
         provider_ipc_data_t *ipcData =
             static_cast<provider_ipc_data_t *>(providerIpcData);
 
@@ -98,7 +108,8 @@ struct provider_mock_ipc : public umf_test::provider_base_t {
 
         return UMF_RESULT_SUCCESS;
     }
-    umf_result_t close_ipc_handle(void *ptr, size_t size) noexcept {
+
+    umf_result_t ext_close_ipc_handle(void *ptr, size_t size) noexcept {
         (void)size;
         std::free(ptr);
         return UMF_RESULT_SUCCESS;
@@ -109,11 +120,13 @@ provider_mock_ipc::allocations_mutex_type provider_mock_ipc::alloc_mutex;
 provider_mock_ipc::allocations_map_type provider_mock_ipc::allocations;
 
 static umf_memory_provider_ops_t IPC_MOCK_PROVIDER_OPS =
-    umf::providerMakeCOps<provider_mock_ipc, void>();
+    umf_test::providerMakeCOps<provider_mock_ipc, void>();
 
 HostMemoryAccessor hostMemoryAccessor;
 
 INSTANTIATE_TEST_SUITE_P(umfIpcTestSuite, umfIpcTest,
                          ::testing::Values(ipcTestParams{
-                             umfProxyPoolOps(), nullptr, &IPC_MOCK_PROVIDER_OPS,
-                             nullptr, &hostMemoryAccessor, false}));
+                             umfProxyPoolOps(), nullptr, nullptr,
+                             &IPC_MOCK_PROVIDER_OPS, nullptr, nullptr,
+                             &hostMemoryAccessor}),
+                         ipcTestParamsNameGen);
diff --git a/test/ipcFixtures.hpp b/test/ipcFixtures.hpp
index 8dca83f10e..104ca3c26d 100644
--- a/test/ipcFixtures.hpp
+++ b/test/ipcFixtures.hpp
@@ -1,29 +1,33 @@
-// 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
 
 #ifndef UMF_TEST_IPC_FIXTURES_HPP
 #define UMF_TEST_IPC_FIXTURES_HPP
 
-#include "base.hpp"
-#include "multithread_helpers.hpp"
-#include "pool.hpp"
-#include "test_helpers.h"
+#include <algorithm>
+#include <cstring>
+#include <numeric>
+#include <random>
+#include <tuple>
 
 #include <umf/ipc.h>
 #include <umf/memory_pool.h>
 #include <umf/memory_provider.h>
 #include <umf/pools/pool_proxy.h>
 
-#include <cstring>
-#include <numeric>
-#include <tuple>
+#include "base.hpp"
+#include "multithread_helpers.hpp"
+#include "pool.hpp"
+#include "test_helpers.h"
 
 class MemoryAccessor {
   public:
+    virtual ~MemoryAccessor() = default;
     virtual void fill(void *ptr, size_t size, const void *pattern,
                       size_t pattern_size) = 0;
     virtual void copy(void *dst_ptr, void *src_ptr, size_t size) = 0;
+    virtual const char *getName() = 0;
 };
 
 class HostMemoryAccessor : public MemoryAccessor {
@@ -44,42 +48,100 @@ class HostMemoryAccessor : public MemoryAccessor {
     void copy(void *dst_ptr, void *src_ptr, size_t size) override {
         std::memcpy(dst_ptr, src_ptr, size);
     }
+
+    const char *getName() override { return "HostMemoryAccessor"; }
 };
 
+typedef void *(*pfnPoolParamsCreate)();
+typedef umf_result_t (*pfnPoolParamsDestroy)(void *);
+
+typedef void *(*pfnProviderParamsCreate)();
+typedef umf_result_t (*pfnProviderParamsDestroy)(void *);
+
 // ipcTestParams:
-// pool_ops, pool_params, provider_ops, provider_params, memoryAccessor, free_not_supp
-// free_not_supp (bool) - provider does not support the free() op
+// pool_ops, pfnPoolParamsCreate,pfnPoolParamsDestroy,
+// provider_ops, pfnProviderParamsCreate, pfnProviderParamsDestroy,
+// memoryAccessor
 using ipcTestParams =
-    std::tuple<umf_memory_pool_ops_t *, void *, umf_memory_provider_ops_t *,
-               void *, MemoryAccessor *, bool>;
+    std::tuple<const umf_memory_pool_ops_t *, pfnPoolParamsCreate,
+               pfnPoolParamsDestroy, const umf_memory_provider_ops_t *,
+               pfnProviderParamsCreate, pfnProviderParamsDestroy,
+               MemoryAccessor *>;
+
+std::string
+ipcTestParamsNameGen(const ::testing::TestParamInfo<ipcTestParams> &info) {
+    const umf_memory_pool_ops_t *pool_ops = std::get<0>(info.param);
+    const umf_memory_provider_ops_t *provider_ops = std::get<3>(info.param);
+
+    const char *poolName = NULL;
+    pool_ops->get_name(NULL, &poolName);
+
+    const char *providerName = NULL;
+    provider_ops->get_name(NULL, &providerName);
+
+    // if there are multiple cases with the same pool and provider combination,
+    // add index to the name
+    std::string poolParams = std::get<1>(info.param)
+                                 ? "_w_params_" + std::to_string(info.index)
+                                 : "";
+
+    MemoryAccessor *memAccessor = std::get<6>(info.param);
+
+    return std::string(poolName) + poolParams + "_" + providerName + "_" +
+           memAccessor->getName();
+}
 
 struct umfIpcTest : umf_test::test,
                     ::testing::WithParamInterface<ipcTestParams> {
     umfIpcTest() {}
+    size_t getOpenedIpcCacheSize() {
+        const char *max_size_str = getenv("UMF_MAX_OPENED_IPC_HANDLES");
+        if (max_size_str) {
+            char *endptr;
+            size_t max_size = strtoul(max_size_str, &endptr, 10);
+            EXPECT_EQ(*endptr, '\0');
+            if (*endptr == '\0') {
+                return max_size;
+            }
+        }
+        return 0;
+    }
     void SetUp() override {
         test::SetUp();
-        auto [pool_ops, pool_params, provider_ops, provider_params, accessor,
-              free_not_supp] = this->GetParam();
+        auto [pool_ops, pool_params_create, pool_params_destroy, provider_ops,
+              provider_params_create, provider_params_destroy, accessor] =
+            this->GetParam();
         poolOps = pool_ops;
-        poolParams = pool_params;
+        poolParamsCreate = pool_params_create;
+        poolParamsDestroy = pool_params_destroy;
         providerOps = provider_ops;
-        providerParams = provider_params;
+        providerParamsCreate = provider_params_create;
+        providerParamsDestroy = provider_params_destroy;
         memAccessor = accessor;
-        freeNotSupported = free_not_supp;
+        openedIpcCacheSize = getOpenedIpcCacheSize();
     }
 
     void TearDown() override { test::TearDown(); }
 
-    umf::pool_unique_handle_t makePool() {
+    umf_test::pool_unique_handle_t makePool() {
         // TODO: The function is similar to poolCreateExt function
         //       from memoryPool.hpp
         umf_memory_provider_handle_t hProvider = NULL;
         umf_memory_pool_handle_t hPool = NULL;
 
+        void *providerParams = nullptr;
+        if (providerParamsCreate) {
+            providerParams = providerParamsCreate();
+        }
+
         auto ret =
             umfMemoryProviderCreate(providerOps, providerParams, &hProvider);
         EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
+        if (providerParamsDestroy) {
+            providerParamsDestroy(providerParams);
+        }
+
         auto trace = [](void *trace_context, const char *name) {
             stats_type *stat = static_cast<stats_type *>(trace_context);
             if (std::strcmp(name, "alloc") == 0) {
@@ -98,11 +160,20 @@ struct umfIpcTest : umf_test::test,
         umf_memory_provider_handle_t hTraceProvider =
             traceProviderCreate(hProvider, true, (void *)&stat, trace);
 
+        void *poolParams = nullptr;
+        if (poolParamsCreate) {
+            poolParams = poolParamsCreate();
+        }
+
         ret = umfPoolCreate(poolOps, hTraceProvider, poolParams,
                             UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &hPool);
         EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
-        return umf::pool_unique_handle_t(hPool, &umfPoolDestroy);
+        if (poolParamsDestroy) {
+            poolParamsDestroy(poolParams);
+        }
+
+        return umf_test::pool_unique_handle_t(hPool, &umfPoolDestroy);
     }
 
     struct stats_type {
@@ -120,29 +191,279 @@ struct umfIpcTest : umf_test::test,
     static constexpr int NTHREADS = 10;
     stats_type stat;
     MemoryAccessor *memAccessor = nullptr;
-    umf_memory_pool_ops_t *poolOps = nullptr;
-    void *poolParams = nullptr;
-    umf_memory_provider_ops_t *providerOps = nullptr;
-    void *providerParams = nullptr;
-    bool freeNotSupported = false;
-};
 
-static inline umf_result_t
-get_umf_result_of_free(bool freeNotSupported, umf_result_t expected_result) {
-    if (freeNotSupported) {
-        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    const umf_memory_pool_ops_t *poolOps = nullptr;
+    pfnPoolParamsCreate poolParamsCreate = nullptr;
+    pfnPoolParamsDestroy poolParamsDestroy = nullptr;
+
+    const umf_memory_provider_ops_t *providerOps = nullptr;
+    pfnProviderParamsCreate providerParamsCreate = nullptr;
+    pfnProviderParamsDestroy providerParamsDestroy = nullptr;
+    size_t openedIpcCacheSize = 0;
+
+    void concurrentGetConcurrentPutHandles(bool shuffle) {
+        std::vector<void *> ptrs;
+        constexpr size_t ALLOC_SIZE = 100;
+        constexpr size_t NUM_POINTERS = 100;
+        umf_test::pool_unique_handle_t pool = makePool();
+        ASSERT_NE(pool.get(), nullptr);
+
+        for (size_t i = 0; i < NUM_POINTERS; ++i) {
+            void *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);
+            EXPECT_NE(ptr, nullptr);
+            ptrs.push_back(ptr);
+        }
+
+        std::array<std::vector<umf_ipc_handle_t>, NTHREADS> ipcHandles;
+
+        umf_test::syncthreads_barrier syncthreads(NTHREADS);
+
+        auto getHandlesFn = [shuffle, &ipcHandles, &ptrs,
+                             &syncthreads](size_t tid) {
+            // Each thread gets a copy of the pointers to shuffle them
+            std::vector<void *> localPtrs = ptrs;
+            if (shuffle) {
+                std::random_device rd;
+                std::mt19937 g(rd());
+                std::shuffle(localPtrs.begin(), localPtrs.end(), g);
+            }
+            syncthreads();
+            for (void *ptr : localPtrs) {
+                umf_ipc_handle_t ipcHandle;
+                size_t handleSize;
+                umf_result_t ret =
+                    umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
+                ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+                ipcHandles[tid].push_back(ipcHandle);
+            }
+        };
+
+        umf_test::parallel_exec(NTHREADS, getHandlesFn);
+
+        auto putHandlesFn = [&ipcHandles, &syncthreads](size_t tid) {
+            syncthreads();
+            for (umf_ipc_handle_t ipcHandle : ipcHandles[tid]) {
+                umf_result_t ret = umfPutIPCHandle(ipcHandle);
+                EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+            }
+        };
+
+        umf_test::parallel_exec(NTHREADS, putHandlesFn);
+
+        for (void *ptr : ptrs) {
+            umf_result_t ret = umfPoolFree(pool.get(), ptr);
+            EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        }
+
+        pool.reset(nullptr);
+        EXPECT_EQ(stat.putCount, stat.getCount);
     }
 
-    return expected_result;
-}
+    void concurrentGetPutHandles(bool shuffle) {
+        std::vector<void *> ptrs;
+        constexpr size_t ALLOC_SIZE = 100;
+        constexpr size_t NUM_POINTERS = 100;
+        umf_test::pool_unique_handle_t pool = makePool();
+        ASSERT_NE(pool.get(), nullptr);
+
+        for (size_t i = 0; i < NUM_POINTERS; ++i) {
+            void *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);
+            EXPECT_NE(ptr, nullptr);
+            ptrs.push_back(ptr);
+        }
+
+        umf_test::syncthreads_barrier syncthreads(NTHREADS);
+
+        auto getPutHandlesFn = [shuffle, &ptrs, &syncthreads](size_t) {
+            // Each thread gets a copy of the pointers to shuffle them
+            std::vector<void *> localPtrs = ptrs;
+            if (shuffle) {
+                std::random_device rd;
+                std::mt19937 g(rd());
+                std::shuffle(localPtrs.begin(), localPtrs.end(), g);
+            }
+            syncthreads();
+            for (void *ptr : localPtrs) {
+                umf_ipc_handle_t ipcHandle;
+                size_t handleSize;
+                umf_result_t ret =
+                    umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
+                ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+                ret = umfPutIPCHandle(ipcHandle);
+                EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+            }
+        };
+
+        umf_test::parallel_exec(NTHREADS, getPutHandlesFn);
+
+        for (void *ptr : ptrs) {
+            umf_result_t ret = umfPoolFree(pool.get(), ptr);
+            EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        }
+
+        pool.reset(nullptr);
+        EXPECT_EQ(stat.putCount, stat.getCount);
+    }
+
+    void concurrentOpenConcurrentCloseHandles(bool shuffle) {
+        umf_result_t ret;
+        std::vector<void *> ptrs;
+        constexpr size_t ALLOC_SIZE = 100;
+        constexpr size_t NUM_POINTERS = 100;
+        umf_test::pool_unique_handle_t pool = makePool();
+        ASSERT_NE(pool.get(), nullptr);
+
+        for (size_t i = 0; i < NUM_POINTERS; ++i) {
+            void *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);
+            EXPECT_NE(ptr, nullptr);
+            ptrs.push_back(ptr);
+        }
+
+        std::vector<umf_ipc_handle_t> ipcHandles;
+        for (size_t i = 0; i < NUM_POINTERS; ++i) {
+            umf_ipc_handle_t ipcHandle;
+            size_t handleSize;
+            ret = umfGetIPCHandle(ptrs[i], &ipcHandle, &handleSize);
+            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+            ipcHandles.push_back(ipcHandle);
+        }
+
+        std::array<std::vector<void *>, NTHREADS> openedIpcHandles;
+        umf_ipc_handler_handle_t ipcHandler = nullptr;
+        ret = umfPoolGetIPCHandler(pool.get(), &ipcHandler);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ipcHandler, nullptr);
+
+        umf_test::syncthreads_barrier syncthreads(NTHREADS);
+
+        auto openHandlesFn = [shuffle, &ipcHandles, &openedIpcHandles,
+                              &syncthreads, ipcHandler](size_t tid) {
+            // Each thread gets a copy of the pointers to shuffle them
+            std::vector<umf_ipc_handle_t> localIpcHandles = ipcHandles;
+            if (shuffle) {
+                std::random_device rd;
+                std::mt19937 g(rd());
+                std::shuffle(localIpcHandles.begin(), localIpcHandles.end(), g);
+            }
+            syncthreads();
+            for (auto ipcHandle : localIpcHandles) {
+                void *ptr;
+                umf_result_t ret =
+                    umfOpenIPCHandle(ipcHandler, ipcHandle, &ptr);
+                ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+                openedIpcHandles[tid].push_back(ptr);
+            }
+        };
+
+        umf_test::parallel_exec(NTHREADS, openHandlesFn);
+
+        auto closeHandlesFn = [&openedIpcHandles, &syncthreads](size_t tid) {
+            syncthreads();
+            for (void *ptr : openedIpcHandles[tid]) {
+                umf_result_t ret = umfCloseIPCHandle(ptr);
+                EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+            }
+        };
+
+        umf_test::parallel_exec(NTHREADS, closeHandlesFn);
+
+        for (auto ipcHandle : ipcHandles) {
+            ret = umfPutIPCHandle(ipcHandle);
+            EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        }
+
+        for (void *ptr : ptrs) {
+            ret = umfPoolFree(pool.get(), ptr);
+            EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        }
+
+        pool.reset(nullptr);
+        EXPECT_EQ(stat.getCount, stat.allocCount);
+        EXPECT_EQ(stat.putCount, stat.getCount);
+        EXPECT_EQ(stat.openCount, stat.allocCount);
+        EXPECT_EQ(stat.openCount, stat.closeCount);
+    }
+
+    void concurrentOpenCloseHandles(bool shuffle) {
+        umf_result_t ret;
+        std::vector<void *> ptrs;
+        constexpr size_t ALLOC_SIZE = 100;
+        constexpr size_t NUM_POINTERS = 100;
+        umf_test::pool_unique_handle_t pool = makePool();
+        ASSERT_NE(pool.get(), nullptr);
+
+        for (size_t i = 0; i < NUM_POINTERS; ++i) {
+            void *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);
+            EXPECT_NE(ptr, nullptr);
+            ptrs.push_back(ptr);
+        }
+
+        std::vector<umf_ipc_handle_t> ipcHandles;
+        for (size_t i = 0; i < NUM_POINTERS; ++i) {
+            umf_ipc_handle_t ipcHandle;
+            size_t handleSize;
+            ret = umfGetIPCHandle(ptrs[i], &ipcHandle, &handleSize);
+            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+            ipcHandles.push_back(ipcHandle);
+        }
+
+        umf_ipc_handler_handle_t ipcHandler = nullptr;
+        ret = umfPoolGetIPCHandler(pool.get(), &ipcHandler);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ipcHandler, nullptr);
+
+        umf_test::syncthreads_barrier syncthreads(NTHREADS);
+
+        auto openCloseHandlesFn = [shuffle, &ipcHandles, &syncthreads,
+                                   ipcHandler](size_t) {
+            // Each thread gets a copy of the pointers to shuffle them
+            std::vector<umf_ipc_handle_t> localIpcHandles = ipcHandles;
+            if (shuffle) {
+                std::random_device rd;
+                std::mt19937 g(rd());
+                std::shuffle(localIpcHandles.begin(), localIpcHandles.end(), g);
+            }
+            syncthreads();
+            for (auto ipcHandle : localIpcHandles) {
+                void *ptr;
+                umf_result_t ret =
+                    umfOpenIPCHandle(ipcHandler, ipcHandle, &ptr);
+                ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+                ret = umfCloseIPCHandle(ptr);
+                EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+            }
+        };
+
+        umf_test::parallel_exec(NTHREADS, openCloseHandlesFn);
+
+        for (auto ipcHandle : ipcHandles) {
+            ret = umfPutIPCHandle(ipcHandle);
+            EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        }
+
+        for (void *ptr : ptrs) {
+            ret = umfPoolFree(pool.get(), ptr);
+            EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        }
+
+        pool.reset(nullptr);
+        EXPECT_EQ(stat.getCount, stat.allocCount);
+        EXPECT_EQ(stat.putCount, stat.getCount);
+        if (openedIpcCacheSize == 0) {
+            EXPECT_EQ(stat.openCount, stat.allocCount);
+        }
+        EXPECT_EQ(stat.openCount, stat.closeCount);
+    }
+};
 
 TEST_P(umfIpcTest, GetIPCHandleSize) {
     size_t size = 0;
-    umf::pool_unique_handle_t pool = makePool();
+    umf_test::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
 
     umf_result_t ret = umfPoolGetIPCHandleSize(pool.get(), &size);
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
-    EXPECT_GT(size, 0);
+    EXPECT_GT(size, (size_t)0);
 }
 
 TEST_P(umfIpcTest, GetIPCHandleSizeInvalidArgs) {
@@ -150,7 +471,9 @@ TEST_P(umfIpcTest, GetIPCHandleSizeInvalidArgs) {
     umf_result_t ret = umfPoolGetIPCHandleSize(nullptr, &size);
     EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
-    umf::pool_unique_handle_t pool = makePool();
+    umf_test::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
+
     ret = umfPoolGetIPCHandleSize(pool.get(), nullptr);
     EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
@@ -166,7 +489,9 @@ TEST_P(umfIpcTest, GetIPCHandleInvalidArgs) {
     ret = umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
     EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
-    umf::pool_unique_handle_t pool = makePool();
+    umf_test::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
+
     ptr = umfPoolMalloc(pool.get(), SIZE);
     EXPECT_NE(ptr, nullptr);
 
@@ -177,8 +502,7 @@ TEST_P(umfIpcTest, GetIPCHandleInvalidArgs) {
     EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     ret = umfFree(ptr);
-    EXPECT_EQ(ret,
-              get_umf_result_of_free(freeNotSupported, UMF_RESULT_SUCCESS));
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 TEST_P(umfIpcTest, CloseIPCHandleInvalidPtr) {
@@ -190,7 +514,9 @@ TEST_P(umfIpcTest, CloseIPCHandleInvalidPtr) {
 TEST_P(umfIpcTest, BasicFlow) {
     constexpr size_t SIZE = 100;
     std::vector<int> expected_data(SIZE);
-    umf::pool_unique_handle_t pool = makePool();
+    umf_test::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
+
     int *ptr = (int *)umfPoolMalloc(pool.get(), SIZE * sizeof(int));
     EXPECT_NE(ptr, nullptr);
 
@@ -244,83 +570,20 @@ TEST_P(umfIpcTest, BasicFlow) {
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
     ret = umfPoolFree(pool.get(), ptr);
-    EXPECT_EQ(ret,
-              get_umf_result_of_free(freeNotSupported, UMF_RESULT_SUCCESS));
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
     pool.reset(nullptr);
-    EXPECT_EQ(stat.getCount, 1);
+    EXPECT_EQ(stat.getCount, (size_t)1);
     EXPECT_EQ(stat.putCount, stat.getCount);
-    EXPECT_EQ(stat.openCount, 1);
+    EXPECT_EQ(stat.openCount, (size_t)1);
     EXPECT_EQ(stat.closeCount, stat.openCount);
 }
 
-TEST_P(umfIpcTest, GetPoolByOpenedHandle) {
-    constexpr size_t SIZE = 100;
-    constexpr size_t NUM_ALLOCS = 100;
-    constexpr size_t NUM_POOLS = 4;
-    void *ptrs[NUM_ALLOCS];
-    void *openedPtrs[NUM_POOLS][NUM_ALLOCS];
-    std::vector<umf::pool_unique_handle_t> pools_to_open;
-    umf::pool_unique_handle_t pool = makePool();
-
-    for (size_t i = 0; i < NUM_POOLS; ++i) {
-        pools_to_open.push_back(makePool());
-    }
-
-    for (size_t i = 0; i < NUM_ALLOCS; ++i) {
-        void *ptr = umfPoolMalloc(pool.get(), SIZE);
-        ASSERT_NE(ptr, nullptr);
-        ptrs[i] = ptr;
-    }
-
-    for (size_t i = 0; i < NUM_ALLOCS; ++i) {
-        umf_ipc_handle_t ipcHandle = nullptr;
-        size_t handleSize = 0;
-        umf_result_t ret = umfGetIPCHandle(ptrs[i], &ipcHandle, &handleSize);
-        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-
-        for (size_t pool_id = 0; pool_id < NUM_POOLS; pool_id++) {
-            void *ptr = nullptr;
-            umf_ipc_handler_handle_t ipcHandler = nullptr;
-            ret =
-                umfPoolGetIPCHandler(pools_to_open[pool_id].get(), &ipcHandler);
-            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-            ASSERT_NE(ipcHandler, nullptr);
-
-            ret = umfOpenIPCHandle(ipcHandler, ipcHandle, &ptr);
-            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-            openedPtrs[pool_id][i] = ptr;
-        }
-
-        ret = umfPutIPCHandle(ipcHandle);
-        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-    }
-
-    for (size_t pool_id = 0; pool_id < NUM_POOLS; pool_id++) {
-        for (size_t i = 0; i < NUM_ALLOCS; ++i) {
-            umf_memory_pool_handle_t openedPool =
-                umfPoolByPtr(openedPtrs[pool_id][i]);
-            EXPECT_EQ(openedPool, pools_to_open[pool_id].get());
-        }
-    }
-
-    for (size_t pool_id = 0; pool_id < NUM_POOLS; pool_id++) {
-        for (size_t i = 0; i < NUM_ALLOCS; ++i) {
-            umf_result_t ret = umfCloseIPCHandle(openedPtrs[pool_id][i]);
-            EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
-        }
-    }
-
-    for (size_t i = 0; i < NUM_ALLOCS; ++i) {
-        umf_result_t ret = umfFree(ptrs[i]);
-        EXPECT_EQ(ret,
-                  get_umf_result_of_free(freeNotSupported, UMF_RESULT_SUCCESS));
-    }
-}
-
 TEST_P(umfIpcTest, AllocFreeAllocTest) {
     constexpr size_t SIZE = 64 * 1024;
-    umf::pool_unique_handle_t pool = makePool();
+    umf_test::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
+
     umf_ipc_handler_handle_t ipcHandler = nullptr;
 
     umf_result_t ret = umfPoolGetIPCHandler(pool.get(), &ipcHandler);
@@ -346,8 +609,7 @@ TEST_P(umfIpcTest, AllocFreeAllocTest) {
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
     ret = umfPoolFree(pool.get(), ptr);
-    EXPECT_EQ(ret,
-              get_umf_result_of_free(freeNotSupported, UMF_RESULT_SUCCESS));
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
     ptr = umfPoolMalloc(pool.get(), SIZE);
     ASSERT_NE(ptr, nullptr);
@@ -369,8 +631,7 @@ TEST_P(umfIpcTest, AllocFreeAllocTest) {
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
     ret = umfPoolFree(pool.get(), ptr);
-    EXPECT_EQ(ret,
-              get_umf_result_of_free(freeNotSupported, UMF_RESULT_SUCCESS));
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
     pool.reset(nullptr);
     EXPECT_EQ(stat.getCount, stat.putCount);
@@ -381,8 +642,10 @@ TEST_P(umfIpcTest, AllocFreeAllocTest) {
 TEST_P(umfIpcTest, openInTwoIpcHandlers) {
     constexpr size_t SIZE = 100;
     std::vector<int> expected_data(SIZE);
-    umf::pool_unique_handle_t pool1 = makePool();
-    umf::pool_unique_handle_t pool2 = makePool();
+    umf_test::pool_unique_handle_t pool1 = makePool();
+    ASSERT_NE(pool1.get(), nullptr);
+    umf_test::pool_unique_handle_t pool2 = makePool();
+    ASSERT_NE(pool2.get(), nullptr);
     umf_ipc_handler_handle_t ipcHandler1 = nullptr;
     umf_ipc_handler_handle_t ipcHandler2 = nullptr;
 
@@ -432,134 +695,136 @@ TEST_P(umfIpcTest, openInTwoIpcHandlers) {
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
     ret = umfPoolFree(pool1.get(), ptr);
-    EXPECT_EQ(ret,
-              get_umf_result_of_free(freeNotSupported, UMF_RESULT_SUCCESS));
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
     pool1.reset(nullptr);
     pool2.reset(nullptr);
-    EXPECT_EQ(stat.getCount, 1);
+    EXPECT_EQ(stat.getCount, (size_t)1);
     EXPECT_EQ(stat.putCount, stat.getCount);
-    EXPECT_EQ(stat.openCount, 2);
+    EXPECT_EQ(stat.openCount, (size_t)2);
     EXPECT_EQ(stat.closeCount, stat.openCount);
 }
 
-TEST_P(umfIpcTest, ConcurrentGetPutHandles) {
-    std::vector<void *> ptrs;
-    constexpr size_t ALLOC_SIZE = 100;
-    constexpr size_t NUM_POINTERS = 100;
-    umf::pool_unique_handle_t pool = makePool();
+TEST_P(umfIpcTest, PutIPCHandleAfterFree) {
+    constexpr size_t SIZE = 100;
+    umf_test::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
 
-    for (size_t i = 0; i < NUM_POINTERS; ++i) {
-        void *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);
-        EXPECT_NE(ptr, nullptr);
-        ptrs.push_back(ptr);
-    }
+    void *ptr = umfPoolMalloc(pool.get(), SIZE);
+    EXPECT_NE(ptr, nullptr);
 
-    std::array<std::vector<umf_ipc_handle_t>, NTHREADS> ipcHandles;
+    umf_ipc_handle_t ipcHandle = nullptr;
+    size_t handleSize = 0;
+    umf_result_t ret = umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    umf_test::syncthreads_barrier syncthreads(NTHREADS);
+    ret = umfPoolFree(pool.get(), ptr);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    auto getHandlesFn = [&ipcHandles, &ptrs, &syncthreads](size_t tid) {
-        syncthreads();
-        for (void *ptr : ptrs) {
-            umf_ipc_handle_t ipcHandle;
-            size_t handleSize;
-            umf_result_t ret = umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
-            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-            ipcHandles[tid].push_back(ipcHandle);
-        }
-    };
+    ret = umfPutIPCHandle(ipcHandle);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    umf_test::parallel_exec(NTHREADS, getHandlesFn);
+    pool.reset(nullptr);
+    EXPECT_EQ(stat.putCount, stat.getCount);
+}
 
-    auto putHandlesFn = [&ipcHandles, &syncthreads](size_t tid) {
-        syncthreads();
-        for (umf_ipc_handle_t ipcHandle : ipcHandles[tid]) {
-            umf_result_t ret = umfPutIPCHandle(ipcHandle);
-            EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
-        }
-    };
+TEST_P(umfIpcTest, ConcurrentGetConcurrentPutHandles) {
+    concurrentGetConcurrentPutHandles(false);
+}
 
-    umf_test::parallel_exec(NTHREADS, putHandlesFn);
+TEST_P(umfIpcTest, ConcurrentGetConcurrentPutHandlesShuffled) {
+    concurrentGetConcurrentPutHandles(true);
+}
 
-    for (void *ptr : ptrs) {
-        umf_result_t ret = umfPoolFree(pool.get(), ptr);
-        EXPECT_EQ(ret,
-                  get_umf_result_of_free(freeNotSupported, UMF_RESULT_SUCCESS));
-    }
+TEST_P(umfIpcTest, ConcurrentGetPutHandles) { concurrentGetPutHandles(false); }
 
-    pool.reset(nullptr);
-    EXPECT_EQ(stat.putCount, stat.getCount);
+TEST_P(umfIpcTest, ConcurrentGetPutHandlesShuffled) {
+    concurrentGetPutHandles(true);
+}
+
+TEST_P(umfIpcTest, ConcurrentOpenConcurrentCloseHandles) {
+    concurrentOpenConcurrentCloseHandles(false);
+}
+
+TEST_P(umfIpcTest, ConcurrentOpenConcurrentCloseHandlesShuffled) {
+    concurrentOpenConcurrentCloseHandles(true);
 }
 
 TEST_P(umfIpcTest, ConcurrentOpenCloseHandles) {
-    umf_result_t ret;
-    std::vector<void *> ptrs;
-    constexpr size_t ALLOC_SIZE = 100;
-    constexpr size_t NUM_POINTERS = 100;
-    umf::pool_unique_handle_t pool = makePool();
-
-    for (size_t i = 0; i < NUM_POINTERS; ++i) {
-        void *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);
-        EXPECT_NE(ptr, nullptr);
-        ptrs.push_back(ptr);
+    concurrentOpenCloseHandles(false);
+}
+
+TEST_P(umfIpcTest, ConcurrentOpenCloseHandlesShuffled) {
+    concurrentOpenCloseHandles(true);
+}
+
+TEST_P(umfIpcTest, ConcurrentDestroyIpcHandlers) {
+    constexpr size_t SIZE = 100;
+    constexpr size_t NUM_ALLOCS = 100;
+    constexpr size_t NUM_POOLS = 10;
+    void *ptrs[NUM_ALLOCS];
+    void *openedPtrs[NUM_POOLS][NUM_ALLOCS];
+    std::vector<umf_test::pool_unique_handle_t> consumerPools;
+    umf_test::pool_unique_handle_t producerPool = makePool();
+    ASSERT_NE(producerPool.get(), nullptr);
+
+    for (size_t i = 0; i < NUM_POOLS; ++i) {
+        consumerPools.push_back(makePool());
+        ASSERT_NE(consumerPools[i].get(), nullptr);
     }
 
-    std::array<umf_ipc_handle_t, NUM_POINTERS> ipcHandles;
-    for (size_t i = 0; i < NUM_POINTERS; ++i) {
-        umf_ipc_handle_t ipcHandle;
-        size_t handleSize;
-        ret = umfGetIPCHandle(ptrs[i], &ipcHandle, &handleSize);
-        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-        ipcHandles[i] = ipcHandle;
+    for (size_t i = 0; i < NUM_ALLOCS; ++i) {
+        void *ptr = umfPoolMalloc(producerPool.get(), SIZE);
+        ASSERT_NE(ptr, nullptr);
+        ptrs[i] = ptr;
     }
 
-    std::array<std::vector<void *>, NTHREADS> openedIpcHandles;
-    umf_ipc_handler_handle_t ipcHandler = nullptr;
-    ret = umfPoolGetIPCHandler(pool.get(), &ipcHandler);
-    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-    ASSERT_NE(ipcHandler, nullptr);
+    for (size_t i = 0; i < NUM_ALLOCS; ++i) {
+        umf_ipc_handle_t ipcHandle = nullptr;
+        size_t handleSize = 0;
+        umf_result_t ret = umfGetIPCHandle(ptrs[i], &ipcHandle, &handleSize);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    umf_test::syncthreads_barrier syncthreads(NTHREADS);
+        for (size_t poolId = 0; poolId < NUM_POOLS; poolId++) {
+            void *ptr = nullptr;
+            umf_ipc_handler_handle_t ipcHandler = nullptr;
+            ret =
+                umfPoolGetIPCHandler(consumerPools[poolId].get(), &ipcHandler);
+            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+            ASSERT_NE(ipcHandler, nullptr);
 
-    auto openHandlesFn = [&ipcHandles, &openedIpcHandles, &syncthreads,
-                          ipcHandler](size_t tid) {
-        syncthreads();
-        for (auto ipcHandle : ipcHandles) {
-            void *ptr;
-            umf_result_t ret = umfOpenIPCHandle(ipcHandler, ipcHandle, &ptr);
+            ret = umfOpenIPCHandle(ipcHandler, ipcHandle, &ptr);
             ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-            openedIpcHandles[tid].push_back(ptr);
+            openedPtrs[poolId][i] = ptr;
         }
-    };
 
-    umf_test::parallel_exec(NTHREADS, openHandlesFn);
+        ret = umfPutIPCHandle(ipcHandle);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    }
 
-    auto closeHandlesFn = [&openedIpcHandles, &syncthreads](size_t tid) {
-        syncthreads();
-        for (void *ptr : openedIpcHandles[tid]) {
-            umf_result_t ret = umfCloseIPCHandle(ptr);
+    for (size_t poolId = 0; poolId < NUM_POOLS; poolId++) {
+        for (size_t i = 0; i < NUM_ALLOCS; ++i) {
+            umf_result_t ret = umfCloseIPCHandle(openedPtrs[poolId][i]);
             EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
         }
-    };
-
-    umf_test::parallel_exec(NTHREADS, closeHandlesFn);
+    }
 
-    for (auto ipcHandle : ipcHandles) {
-        ret = umfPutIPCHandle(ipcHandle);
+    for (size_t i = 0; i < NUM_ALLOCS; ++i) {
+        umf_result_t ret = umfFree(ptrs[i]);
         EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
     }
 
-    for (void *ptr : ptrs) {
-        ret = umfPoolFree(pool.get(), ptr);
-        EXPECT_EQ(ret,
-                  get_umf_result_of_free(freeNotSupported, UMF_RESULT_SUCCESS));
-    }
+    // Destroy pools in parallel to cause IPC cache cleanup in parallel.
+    umf_test::syncthreads_barrier syncthreads(NUM_POOLS);
+    auto poolDestroyFn = [&consumerPools, &syncthreads](size_t tid) {
+        syncthreads();
+        consumerPools[tid].reset(nullptr);
+    };
+    umf_test::parallel_exec(NUM_POOLS, poolDestroyFn);
+
+    producerPool.reset(nullptr);
 
-    pool.reset(nullptr);
-    EXPECT_EQ(stat.getCount, stat.allocCount);
     EXPECT_EQ(stat.putCount, stat.getCount);
-    EXPECT_EQ(stat.openCount, stat.allocCount);
     EXPECT_EQ(stat.openCount, stat.closeCount);
 }
 
diff --git a/test/ipc_devdax_prov.sh b/test/ipc_devdax_prov.sh
index 7c5ba36752..43f177c713 100755
--- a/test/ipc_devdax_prov.sh
+++ b/test/ipc_devdax_prov.sh
@@ -1,5 +1,5 @@
 #
-# 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
@@ -25,10 +25,10 @@ PORT=$(( 1024 + ( $$ % ( 65535 - 1024 ))))
 UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
 
 echo "Starting ipc_devdax_prov CONSUMER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_devdax_prov_consumer $PORT &
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_devdax_prov_consumer $PORT &
 
 echo "Waiting 1 sec ..."
 sleep 1
 
 echo "Starting ipc_devdax_prov PRODUCER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_devdax_prov_producer $PORT
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_devdax_prov_producer $PORT
diff --git a/test/ipc_devdax_prov_consumer.c b/test/ipc_devdax_prov_consumer.c
index 286b6de785..105ddd864b 100644
--- a/test/ipc_devdax_prov_consumer.c
+++ b/test/ipc_devdax_prov_consumer.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -23,20 +23,20 @@ int main(int argc, char *argv[]) {
     int port = atoi(argv[1]);
 
     char *path = getenv("UMF_TESTS_DEVDAX_PATH");
-    if (path == NULL || path[0] == 0) {
+    if (path == NULL || path[0] == '\0') {
         fprintf(stderr, "Test skipped, UMF_TESTS_DEVDAX_PATH is not set\n");
         return 0;
     }
 
     char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
-    if (size == NULL || size[0] == 0) {
+    if (size == NULL || size[0] == '\0') {
         fprintf(stderr, "Test skipped, UMF_TESTS_DEVDAX_SIZE is not set\n");
         return 0;
     }
 
     umf_devdax_memory_provider_params_handle_t devdax_params = NULL;
     umf_result_t umf_result =
-        umfDevDaxMemoryProviderParamsCreate(&devdax_params, path, atol(size));
+        umfDevDaxMemoryProviderParamsCreate(path, atol(size), &devdax_params);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "[consumer] ERROR: creating DevDax Memory Provider "
                         "params failed\n");
diff --git a/test/ipc_devdax_prov_producer.c b/test/ipc_devdax_prov_producer.c
index 479c1f9457..2445db07ec 100644
--- a/test/ipc_devdax_prov_producer.c
+++ b/test/ipc_devdax_prov_producer.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -23,20 +23,20 @@ int main(int argc, char *argv[]) {
     int port = atoi(argv[1]);
 
     char *path = getenv("UMF_TESTS_DEVDAX_PATH");
-    if (path == NULL || path[0] == 0) {
+    if (path == NULL || path[0] == '\0') {
         fprintf(stderr, "Test skipped, UMF_TESTS_DEVDAX_PATH is not set\n");
         return 0;
     }
 
     char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
-    if (size == NULL || size[0] == 0) {
+    if (size == NULL || size[0] == '\0') {
         fprintf(stderr, "Test skipped, UMF_TESTS_DEVDAX_SIZE is not set\n");
         return 0;
     }
 
     umf_devdax_memory_provider_params_handle_t devdax_params = NULL;
     umf_result_t umf_result =
-        umfDevDaxMemoryProviderParamsCreate(&devdax_params, path, atol(size));
+        umfDevDaxMemoryProviderParamsCreate(path, atol(size), &devdax_params);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "[producer] ERROR: creating DevDax Memory Provider "
                         "params failed\n");
diff --git a/test/ipc_file_prov.sh b/test/ipc_file_prov.sh
index b3e3091a8f..ffb849f25a 100755
--- a/test/ipc_file_prov.sh
+++ b/test/ipc_file_prov.sh
@@ -1,5 +1,5 @@
 #
-# 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
@@ -9,7 +9,12 @@
 
 set -e
 
-FILE_NAME="/tmp/umf_file_provider_$$"
+FILE_BASE="/tmp/umf_file_provider"
+
+# remove old SHM files (left from the previous runs, because of crashes)
+rm -f ${FILE_BASE}*
+
+FILE_NAME="${FILE_BASE}_$$"
 
 # port should be a number from the range <1024, 65535>
 PORT=$(( 1024 + ( $$ % ( 65535 - 1024 ))))
@@ -20,13 +25,13 @@ UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
 rm -f ${FILE_NAME}
 
 echo "Starting ipc_file_prov CONSUMER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_file_prov_consumer $PORT ${FILE_NAME}_consumer &
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_file_prov_consumer $PORT ${FILE_NAME}_consumer &
 
 echo "Waiting 1 sec ..."
 sleep 1
 
 echo "Starting ipc_file_prov PRODUCER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_file_prov_producer $PORT ${FILE_NAME}_producer
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_file_prov_producer $PORT ${FILE_NAME}_producer
 
 # remove the SHM file
 rm -f ${FILE_NAME}
diff --git a/test/ipc_file_prov_consumer.c b/test/ipc_file_prov_consumer.c
index 0c50991a9b..e6e0eb2597 100644
--- a/test/ipc_file_prov_consumer.c
+++ b/test/ipc_file_prov_consumer.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -28,7 +28,7 @@ int main(int argc, char *argv[]) {
 
     umf_file_memory_provider_params_handle_t file_params = NULL;
     umf_result_t umf_result =
-        umfFileMemoryProviderParamsCreate(&file_params, file_name);
+        umfFileMemoryProviderParamsCreate(file_name, &file_params);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(
             stderr,
diff --git a/test/ipc_file_prov_fsdax.sh b/test/ipc_file_prov_fsdax.sh
index 4e908869b7..314d0aa667 100755
--- a/test/ipc_file_prov_fsdax.sh
+++ b/test/ipc_file_prov_fsdax.sh
@@ -1,5 +1,5 @@
 #
-# 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
@@ -31,13 +31,13 @@ UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
 rm -f ${FILE_NAME}
 
 echo "Starting ipc_file_prov_fsdax CONSUMER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_file_prov_consumer $PORT $FILE_NAME &
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_file_prov_consumer $PORT $FILE_NAME &
 
 echo "Waiting 1 sec ..."
 sleep 1
 
 echo "Starting ipc_file_prov_fsdax PRODUCER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_file_prov_producer $PORT $FILE_NAME_2
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_file_prov_producer $PORT $FILE_NAME_2
 
 # remove the SHM file
 rm -f ${FILE_NAME}
diff --git a/test/ipc_file_prov_producer.c b/test/ipc_file_prov_producer.c
index c620437e08..11c399b70e 100644
--- a/test/ipc_file_prov_producer.c
+++ b/test/ipc_file_prov_producer.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -28,7 +28,7 @@ int main(int argc, char *argv[]) {
 
     umf_file_memory_provider_params_handle_t file_params = NULL;
     umf_result_t umf_result =
-        umfFileMemoryProviderParamsCreate(&file_params, file_name);
+        umfFileMemoryProviderParamsCreate(file_name, &file_params);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(
             stderr,
diff --git a/test/ipc_negative.cpp b/test/ipc_negative.cpp
index 5c4cccf22b..7cbeb36688 100644
--- a/test/ipc_negative.cpp
+++ b/test/ipc_negative.cpp
@@ -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
 
@@ -16,11 +16,11 @@ struct IpcNotSupported : umf_test::test {
   protected:
     void SetUp() override {
         umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
-        provider_ops.ipc.get_ipc_handle_size = nullptr;
-        provider_ops.ipc.get_ipc_handle = nullptr;
-        provider_ops.ipc.open_ipc_handle = nullptr;
-        provider_ops.ipc.put_ipc_handle = nullptr;
-        provider_ops.ipc.close_ipc_handle = nullptr;
+        provider_ops.ext_get_ipc_handle_size = nullptr;
+        provider_ops.ext_get_ipc_handle = nullptr;
+        provider_ops.ext_open_ipc_handle = nullptr;
+        provider_ops.ext_put_ipc_handle = nullptr;
+        provider_ops.ext_close_ipc_handle = nullptr;
 
         umf_result_t ret;
         ret = umfMemoryProviderCreate(&provider_ops, nullptr, &provider);
diff --git a/test/ipc_os_prov_anon_fd.sh b/test/ipc_os_prov_anon_fd.sh
index c5738e9893..4e9a0f8327 100755
--- a/test/ipc_os_prov_anon_fd.sh
+++ b/test/ipc_os_prov_anon_fd.sh
@@ -1,5 +1,5 @@
 #
-# 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
@@ -12,28 +12,13 @@ set -e
 # port should be a number from the range <1024, 65535>
 PORT=$(( 1024 + ( $$ % ( 65535 - 1024 ))))
 
-# The ipc_os_prov_anon_fd example requires using pidfd_getfd(2)
-# to obtain a duplicate of another process's file descriptor.
-# Permission to duplicate another process's file descriptor
-# is governed by a ptrace access mode PTRACE_MODE_ATTACH_REALCREDS check (see ptrace(2))
-# that can be changed using the /proc/sys/kernel/yama/ptrace_scope interface.
-PTRACE_SCOPE_FILE="/proc/sys/kernel/yama/ptrace_scope"
-VAL=0
-if [ -f $PTRACE_SCOPE_FILE ]; then
-	PTRACE_SCOPE_VAL=$(cat $PTRACE_SCOPE_FILE)
-	if [ $PTRACE_SCOPE_VAL -ne $VAL ]; then
-		echo "SKIP: ptrace_scope is not set to 0 (classic ptrace permissions) - skipping the test"
-		exit 125 # skip code defined in CMakeLists.txt
-	fi
-fi
-
 UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
 
 echo "Starting ipc_os_prov_anon_fd CONSUMER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_os_prov_consumer $PORT &
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_os_prov_consumer $PORT &
 
 echo "Waiting 1 sec ..."
 sleep 1
 
 echo "Starting ipc_os_prov_anon_fd PRODUCER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_os_prov_producer $PORT
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_os_prov_producer $PORT
diff --git a/test/ipc_os_prov_proxy.sh b/test/ipc_os_prov_proxy.sh
index 86b95a2356..9bd02dad84 100755
--- a/test/ipc_os_prov_proxy.sh
+++ b/test/ipc_os_prov_proxy.sh
@@ -1,5 +1,5 @@
 #
-# 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
@@ -17,10 +17,10 @@ LD_PRELOAD_VAL="../lib/libumf_proxy.so"
 PORT=$(( 1024 + ( $$ % ( 65535 - 1024 ))))
 
 echo "Starting CONSUMER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_os_prov_consumer $PORT &
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_os_prov_consumer $PORT &
 
 echo "Waiting 1 sec ..."
 sleep 1
 
 echo "Starting ipc_os_prov_proxy PRODUCER on port $PORT ..."
-LD_PRELOAD=$LD_PRELOAD_VAL UMF_LOG=$UMF_LOG_VAL UMF_PROXY=$UMF_PROXY_VAL ./umf_test-ipc_os_prov_proxy $PORT
+LD_PRELOAD=$LD_PRELOAD_VAL UMF_LOG=$UMF_LOG_VAL UMF_PROXY=$UMF_PROXY_VAL ./test_ipc_os_prov_proxy $PORT
diff --git a/test/ipc_os_prov_shm.sh b/test/ipc_os_prov_shm.sh
index efa2de35ae..7bde3c6135 100755
--- a/test/ipc_os_prov_shm.sh
+++ b/test/ipc_os_prov_shm.sh
@@ -1,5 +1,5 @@
 #
-# 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
@@ -20,13 +20,13 @@ UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
 rm -f /dev/shm/${SHM_NAME}
 
 echo "Starting ipc_os_prov_shm CONSUMER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_os_prov_consumer $PORT &
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_os_prov_consumer $PORT &
 
 echo "Waiting 1 sec ..."
 sleep 1
 
 echo "Starting ipc_os_prov_shm PRODUCER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_os_prov_producer $PORT $SHM_NAME
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_os_prov_producer $PORT $SHM_NAME
 
 # remove the SHM file
 rm -f /dev/shm/${SHM_NAME}
diff --git a/test/malloc_compliance_tests.cpp b/test/malloc_compliance_tests.cpp
index 06e3b5dd78..b828281987 100644
--- a/test/malloc_compliance_tests.cpp
+++ b/test/malloc_compliance_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2023 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
 
@@ -11,9 +11,10 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <umf/memory_pool.h>
+
 #include "malloc_compliance_tests.hpp"
 #include "test_helpers.h"
-#include "umf/memory_pool.h"
 
 #include "base.hpp"
 using umf_test::test;
@@ -119,7 +120,7 @@ void realloc_compliance_test(umf_memory_pool_handle_t hPool) {
             << "malloc returned NULL, couldn't allocate much memory";
 
         // Fit memory region with data and store
-        // it's content somehere before realloc
+        // it's content somewhere before realloc
         void *saved_obj = umfPoolMalloc(hPool, alloc_size);
         ASSERT_NE(saved_obj, nullptr)
             << "malloc returned NULL, couldn't allocate much memory";
diff --git a/test/malloc_compliance_tests.hpp b/test/malloc_compliance_tests.hpp
index d76c2b9451..00fed53ef7 100644
--- a/test/malloc_compliance_tests.hpp
+++ b/test/malloc_compliance_tests.hpp
@@ -1,11 +1,11 @@
-// Copyright (C) 2023 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
 
 #ifndef UMF_TEST_MALLOC_COMPLIANCE_TESTS_H
 #define UMF_TEST_MALLOC_COMPLIANCE_TESTS_H
 
-#include "umf/memory_pool.h"
+#include <umf/memory_pool.h>
 
 void malloc_compliance_test(umf_memory_pool_handle_t hPool);
 void calloc_compliance_test(umf_memory_pool_handle_t hPool);
diff --git a/test/memoryPoolAPI.cpp b/test/memoryPoolAPI.cpp
index 1c6d83f2af..f2cfb61bb7 100644
--- a/test/memoryPoolAPI.cpp
+++ b/test/memoryPoolAPI.cpp
@@ -1,29 +1,37 @@
-// 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
 // This file contains tests for UMF pool API
 
-#include "base.hpp"
-#include "pool.hpp"
-#include "poolFixtures.hpp"
-#include "provider.hpp"
-#include "provider_null.h"
-#include "provider_trace.h"
-#include "test_helpers.h"
+#include <array>
+#include <string>
+#include <thread>
+#include <type_traits>
+#include <unordered_map>
+#include <variant>
 
 #include <umf/memory_provider.h>
+#include <umf/pools/pool_disjoint.h>
+#include <umf/pools/pool_jemalloc.h>
 #include <umf/pools/pool_proxy.h>
+#include <umf/pools/pool_scalable.h>
+
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+#include <umf/pools/pool_jemalloc.h>
+#include <umf/providers/provider_os_memory.h>
+#endif
 
 #ifdef UMF_PROXY_LIB_ENABLED
 #include <umf/proxy_lib_new_delete.h>
 #endif
 
-#include <array>
-#include <string>
-#include <thread>
-#include <type_traits>
-#include <unordered_map>
-#include <variant>
+#include "base.hpp"
+#include "pool.hpp"
+#include "poolFixtures.hpp"
+#include "provider.hpp"
+#include "provider_null.h"
+#include "provider_trace.h"
+#include "test_helpers.h"
 
 using umf_test::test;
 using namespace umf_test;
@@ -41,7 +49,7 @@ struct umfPoolWithCreateFlagsTest
 };
 
 TEST_P(umfPoolWithCreateFlagsTest, memoryPoolTrace) {
-    using calls_type = std::unordered_map<std::string, size_t>;
+    using calls_type = std::unordered_map<std::string, unsigned int>;
     calls_type poolCalls;
     calls_type providerCalls;
     auto tracePool = [](void *handler, const char *name) {
@@ -70,43 +78,52 @@ TEST_P(umfPoolWithCreateFlagsTest, memoryPoolTrace) {
     size_t provider_call_count = 0;
 
     umfPoolMalloc(tracingPool.get(), 0);
-    ASSERT_EQ(poolCalls["malloc"], 1);
+    ASSERT_EQ(poolCalls["malloc"], 1UL);
     ASSERT_EQ(poolCalls.size(), ++pool_call_count);
 
-    ASSERT_EQ(providerCalls["alloc"], 1);
+    ASSERT_EQ(providerCalls["alloc"], 1UL);
     ASSERT_EQ(providerCalls.size(), ++provider_call_count);
 
-    umfPoolMallocUsableSize(tracingPool.get(), nullptr);
-    ASSERT_EQ(poolCalls["malloc_usable_size"], 1);
+    size_t tmpSize;
+    umfPoolMallocUsableSize(tracingPool.get(), nullptr, &tmpSize);
+    // we ignore return value of umfPoolMallocUsableSize(), as it might be not
+    // supported
+    ASSERT_EQ(poolCalls["malloc_usable_size"], 1UL);
     ASSERT_EQ(poolCalls.size(), ++pool_call_count);
 
     ASSERT_EQ(providerCalls.size(), provider_call_count);
 
     umfPoolFree(tracingPool.get(), nullptr);
-    ASSERT_EQ(poolCalls["free"], 1);
+    ASSERT_EQ(poolCalls["free"], 1UL);
     ASSERT_EQ(poolCalls.size(), ++pool_call_count);
 
-    ASSERT_EQ(providerCalls["free"], 1);
+    ASSERT_EQ(providerCalls["free"], 1UL);
     ASSERT_EQ(providerCalls.size(), ++provider_call_count);
 
     umfPoolCalloc(tracingPool.get(), 0, 0);
-    ASSERT_EQ(poolCalls["calloc"], 1);
+    ASSERT_EQ(poolCalls["calloc"], 1UL);
     ASSERT_EQ(poolCalls.size(), ++pool_call_count);
 
     umfPoolRealloc(tracingPool.get(), nullptr, 0);
-    ASSERT_EQ(poolCalls["realloc"], 1);
+    ASSERT_EQ(poolCalls["realloc"], 1UL);
     ASSERT_EQ(poolCalls.size(), ++pool_call_count);
 
     umfPoolAlignedMalloc(tracingPool.get(), 0, 0);
-    ASSERT_EQ(poolCalls["aligned_malloc"], 1);
+    ASSERT_EQ(poolCalls["aligned_malloc"], 1UL);
     ASSERT_EQ(poolCalls.size(), ++pool_call_count);
 
-    ASSERT_EQ(providerCalls["alloc"], 2);
+    ASSERT_EQ(providerCalls["alloc"], 2UL);
     ASSERT_EQ(providerCalls.size(), provider_call_count);
 
     auto ret = umfPoolGetLastAllocationError(tracingPool.get());
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(poolCalls["get_last_native_error"], 1);
+    ASSERT_EQ(poolCalls["get_last_native_error"], 1UL);
+    ASSERT_EQ(poolCalls.size(), ++pool_call_count);
+
+    umfPoolTrimMemory(tracingPool.get(), 0);
+    // we ignore return value of umfPoolTrimMemory(), as it might be not
+    // supported
+    ASSERT_EQ(poolCalls["trim_memory"], 1UL);
     ASSERT_EQ(poolCalls.size(), ++pool_call_count);
 
     if (manuallyDestroyProvider) {
@@ -123,8 +140,15 @@ TEST_P(umfPoolWithCreateFlagsTest, memoryPoolWithCustomProvider) {
             EXPECT_NE_NOEXCEPT(provider, nullptr);
             return UMF_RESULT_SUCCESS;
         }
+
+        umf_result_t get_name(const char **name) noexcept {
+            if (name) {
+                *name = "pool";
+            }
+            return UMF_RESULT_SUCCESS;
+        }
     };
-    umf_memory_pool_ops_t pool_ops = umf::poolMakeCOps<pool, void>();
+    umf_memory_pool_ops_t pool_ops = umf_test::poolMakeCOps<pool, void>();
 
     umf_memory_pool_handle_t hPool;
     auto ret = umfPoolCreate(&pool_ops, hProvider, nullptr, flags, &hPool);
@@ -165,36 +189,197 @@ TEST_F(test, BasicPoolByPtrTest) {
     char *ptr = (char *)umfPoolMalloc(expected_pool, SIZE);
     ASSERT_NE(ptr, nullptr);
 
-    auto ret_pool = umfPoolByPtr(ptr);
+    umf_memory_pool_handle_t ret_pool = nullptr;
+    ret = umfPoolByPtr(ptr, &ret_pool);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     EXPECT_EQ(ret_pool, expected_pool);
 
-    ret_pool = umfPoolByPtr(ptr + SIZE);
+    ret = umfPoolByPtr(ptr + SIZE, &ret_pool);
+    ASSERT_NE(ret, UMF_RESULT_SUCCESS);
     EXPECT_EQ(ret_pool, nullptr);
 
-    ret_pool = umfPoolByPtr(ptr + SIZE - 1);
+    ret = umfPoolByPtr(ptr + SIZE - 1, &ret_pool);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     EXPECT_EQ(ret_pool, expected_pool);
 
     ret = umfFree(ptr);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
+struct tagTest : umf_test::test {
+    void SetUp() override {
+        test::SetUp();
+        provider = umf_test::wrapProviderUnique(nullProviderCreate());
+        pool = umf_test::wrapPoolUnique(
+            createPoolChecked(umfProxyPoolOps(), provider.get(), nullptr));
+    }
+
+    umf_test::provider_unique_handle_t provider;
+    umf_test::pool_unique_handle_t pool;
+};
+
+TEST_F(tagTest, SetAndGet) {
+    umf_result_t ret = umfPoolSetTag(pool.get(), (void *)0x99, nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    void *tag;
+    ret = umfPoolGetTag(pool.get(), &tag);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(tag, (void *)0x99);
+
+    void *oldTag;
+    ret = umfPoolSetTag(pool.get(), (void *)0x100, &oldTag);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(oldTag, (void *)0x99);
+
+    ret = umfPoolGetTag(pool.get(), &tag);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(tag, (void *)0x100);
+}
+
+TEST_F(tagTest, SetAndGetNull) {
+    umf_result_t ret = umfPoolSetTag(pool.get(), nullptr, nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    void *tag;
+    ret = umfPoolGetTag(pool.get(), &tag);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(tag, nullptr);
+}
+
+TEST_F(tagTest, NoSetAndGet) {
+    void *tag;
+    umf_result_t ret = umfPoolGetTag(pool.get(), &tag);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(tag, nullptr);
+}
+
+TEST_F(tagTest, SetAndGetMt) {
+    static constexpr size_t NUM_THREADS = 8;
+    static constexpr size_t NUM_OPS_PER_THREAD = 16;
+
+    std::vector<std::thread> threads;
+
+    auto encodeTag = [](size_t thread, size_t op) -> void * {
+        return reinterpret_cast<void *>(thread * NUM_OPS_PER_THREAD + op);
+    };
+
+    auto decodeTag = [](void *tag) -> std::pair<size_t, size_t> {
+        auto op = reinterpret_cast<size_t>(tag) & (NUM_OPS_PER_THREAD - 1);
+        auto thread = reinterpret_cast<size_t>(tag) / NUM_OPS_PER_THREAD;
+        return {thread, op};
+    };
+
+    for (size_t i = 0; i < NUM_THREADS; i++) {
+        threads.emplace_back([this, i, encodeTag, decodeTag] {
+            for (size_t j = 0; j < NUM_OPS_PER_THREAD; j++) {
+                void *oldTag;
+                umf_result_t ret =
+                    umfPoolSetTag(pool.get(), encodeTag(i, j), &oldTag);
+                ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+                void *queriedTag;
+                ret = umfPoolGetTag(pool.get(), &queriedTag);
+                ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+                auto [t1, op1] = decodeTag(oldTag);
+                auto [t2, op2] = decodeTag(queriedTag);
+                // if the tag was set by the same thread, the op part should be the same or higher
+                ASSERT_TRUE(t1 != t2 || op2 >= op1);
+            }
+        });
+    }
+
+    for (auto &thread : threads) {
+        thread.join();
+    }
+
+    void *tag;
+    auto ret = umfPoolGetTag(pool.get(), &tag);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    auto [t, op] = decodeTag(tag);
+    ASSERT_TRUE(t < NUM_THREADS);
+    ASSERT_TRUE(op == NUM_OPS_PER_THREAD - 1);
+}
+
+TEST_F(tagTest, SetAndGetInvalidPtr) {
+    umf_result_t ret = umfPoolSetTag(pool.get(), nullptr, nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfPoolGetTag(pool.get(), nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(tagTest, SetAndGetInvalidPool) {
+    umf_result_t ret =
+        umfPoolSetTag(nullptr, reinterpret_cast<void *>(0x1), nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    void *tag;
+    ret = umfPoolGetTag(nullptr, &tag);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+static void *createOsMemoryProviderParams() {
+    umf_os_memory_provider_params_handle_t params = nullptr;
+    umf_result_t res = umfOsMemoryProviderParamsCreate(&params);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error("Failed to create os memory provider params");
+    }
+
+    return params;
+}
+
+static umf_result_t destroyOsMemoryProviderParams(void *params) {
+    return umfOsMemoryProviderParamsDestroy(
+        (umf_os_memory_provider_params_handle_t)params);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    jemallocPoolTest, umfPoolTest,
+    ::testing::Values(poolCreateExtParams{
+        umfJemallocPoolOps(), nullptr, nullptr, umfOsMemoryProviderOps(),
+        createOsMemoryProviderParams, destroyOsMemoryProviderParams}),
+    poolCreateExtParamsNameGen);
+
+#endif /* UMF_POOL_JEMALLOC_ENABLED */
+
 INSTANTIATE_TEST_SUITE_P(
     mallocPoolTest, umfPoolTest,
-    ::testing::Values(poolCreateExtParams{&MALLOC_POOL_OPS, nullptr,
-                                          &UMF_NULL_PROVIDER_OPS, nullptr,
-                                          nullptr},
-                      poolCreateExtParams{umfProxyPoolOps(), nullptr,
-                                          &BA_GLOBAL_PROVIDER_OPS, nullptr,
-                                          nullptr}));
+    ::testing::Values(
+        poolCreateExtParams{&MALLOC_POOL_OPS, nullptr, nullptr,
+                            &UMF_NULL_PROVIDER_OPS, nullptr, nullptr},
+        poolCreateExtParams{umfProxyPoolOps(), nullptr, nullptr,
+                            &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr},
+        poolCreateExtParams{umfDisjointPoolOps(), defaultDisjointPoolConfig,
+                            defaultDisjointPoolConfigDestroy,
+                            &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}),
+    poolCreateExtParamsNameGen);
+
+#ifdef UMF_POOL_SCALABLE_ENABLED
+INSTANTIATE_TEST_SUITE_P(mallocPoolTestScalable, umfPoolTest,
+                         ::testing::Values(poolCreateExtParams{
+                             umfScalablePoolOps(), nullptr, nullptr,
+                             &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}),
+                         poolCreateExtParamsNameGen);
+#endif
 
 INSTANTIATE_TEST_SUITE_P(mallocMultiPoolTest, umfMultiPoolTest,
                          ::testing::Values(poolCreateExtParams{
-                             umfProxyPoolOps(), nullptr,
-                             &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}));
+                             umfProxyPoolOps(), nullptr, nullptr,
+                             &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}),
+                         poolCreateExtParamsNameGen);
 
 INSTANTIATE_TEST_SUITE_P(umfPoolWithCreateFlagsTest, umfPoolWithCreateFlagsTest,
                          ::testing::Values(0,
-                                           UMF_POOL_CREATE_FLAG_OWN_PROVIDER));
+                                           UMF_POOL_CREATE_FLAG_OWN_PROVIDER),
+                         ([](auto const &info) -> std::string {
+                             static const char *names[] = {
+                                 "NONE", "UMF_POOL_CREATE_FLAG_OWN_PROVIDER"};
+                             return names[info.index];
+                         }));
 
 ////////////////// Negative test cases /////////////////
 
@@ -231,6 +416,25 @@ TEST_P(umfPoolWithCreateFlagsTest, umfPoolCreateFlagsInvalidProviders) {
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
 
+// logical sum (OR) of all umf_pool_create_flags_t flags
+static constexpr umf_pool_create_flags_t UMF_POOL_CREATE_FLAG_ALL =
+    UMF_POOL_CREATE_FLAG_OWN_PROVIDER | UMF_POOL_CREATE_FLAG_DISABLE_TRACKING;
+
+TEST_P(umfPoolWithCreateFlagsTest, umfPoolCreateInvalidFlags) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t ret =
+        umfMemoryProviderCreate(&UMF_NULL_PROVIDER_OPS, nullptr, &provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    umf_memory_pool_handle_t pool = nullptr;
+    ret = umfPoolCreate(&MALLOC_POOL_OPS, provider, nullptr,
+                        (UMF_POOL_CREATE_FLAG_ALL + 1), &pool);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umfMemoryProviderDestroy(provider);
+}
+
 struct poolInitializeTest : umf_test::test,
                             ::testing::WithParamInterface<umf_result_t> {};
 
@@ -239,7 +443,14 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::Values(UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY,
                       UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC,
                       UMF_RESULT_ERROR_INVALID_ARGUMENT,
-                      UMF_RESULT_ERROR_UNKNOWN));
+                      UMF_RESULT_ERROR_UNKNOWN),
+    ([](auto const &info) -> std::string {
+        static const char *names[] = {
+            "UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY",
+            "UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC",
+            "UMF_RESULT_ERROR_INVALID_ARGUMENT", "UMF_RESULT_ERROR_UNKNOWN"};
+        return names[info.index];
+    }));
 
 TEST_P(poolInitializeTest, errorPropagation) {
     auto nullProvider = umf_test::wrapProviderUnique(nullProviderCreate());
@@ -248,11 +459,12 @@ TEST_P(poolInitializeTest, errorPropagation) {
     struct pool : public umf_test::pool_base_t {
         umf_result_t
         initialize([[maybe_unused]] umf_memory_provider_handle_t provider,
-                   umf_result_t *errorToReturn) noexcept {
+                   const umf_result_t *errorToReturn) noexcept {
             return *errorToReturn;
         }
     };
-    umf_memory_pool_ops_t pool_ops = umf::poolMakeCOps<pool, umf_result_t>();
+    umf_memory_pool_ops_t pool_ops =
+        umf_test::poolMakeCOps<pool, umf_result_t>();
 
     umf_memory_pool_handle_t hPool;
     auto ret = umfPoolCreate(&pool_ops, hProvider, (void *)&this->GetParam(), 0,
@@ -277,8 +489,8 @@ TEST_F(test, getLastFailedMemoryProvider) {
     static umf_result_t allocResult = UMF_RESULT_SUCCESS;
 
     struct memory_provider : public umf_test::provider_base_t {
-        umf_result_t initialize(const char *inName) {
-            name = inName;
+        umf_result_t initialize(const char *name) {
+            provider_name = name;
             return UMF_RESULT_SUCCESS;
         }
 
@@ -297,12 +509,15 @@ TEST_F(test, getLastFailedMemoryProvider) {
             return UMF_RESULT_SUCCESS;
         }
 
-        const char *get_name() noexcept { return this->name; }
+        umf_result_t get_name(const char **name) noexcept {
+            *name = this->provider_name;
+            return UMF_RESULT_SUCCESS;
+        }
 
-        const char *name;
+        const char *provider_name;
     };
     umf_memory_provider_ops_t provider_ops =
-        umf::providerMakeCOps<memory_provider, char>();
+        umf_test::providerMakeCOps<memory_provider, char>();
 
     auto providerUnique1 = wrapProviderUnique(
         createProviderChecked(&provider_ops, (void *)"provider1"));
@@ -321,25 +536,32 @@ TEST_F(test, getLastFailedMemoryProvider) {
     allocResult = UMF_RESULT_ERROR_UNKNOWN;
     ptr = umfPoolMalloc(pool.get(), allocSize);
     ASSERT_EQ(ptr, nullptr);
-    ASSERT_EQ(std::string_view(
-                  umfMemoryProviderGetName(umfGetLastFailedMemoryProvider())),
-              "provider1");
+    umf_memory_provider_handle_t lastProv = nullptr;
+    umf_result_t ret = umfGetLastFailedMemoryProvider(&lastProv);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    const char *lastName = nullptr;
+    ret = umfMemoryProviderGetName(lastProv, &lastName);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(std::string_view(lastName), "provider1");
 
-    auto ret =
-        umfMemoryProviderAlloc(providerUnique2.get(), allocSize, 0, &ptr);
+    ret = umfMemoryProviderAlloc(providerUnique2.get(), allocSize, 0, &ptr);
     ASSERT_NE(ret, UMF_RESULT_SUCCESS);
     ASSERT_EQ(ptr, nullptr);
-    ASSERT_EQ(std::string_view(
-                  umfMemoryProviderGetName(umfGetLastFailedMemoryProvider())),
-              "provider2");
+    ret = umfGetLastFailedMemoryProvider(&lastProv);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ret = umfMemoryProviderGetName(lastProv, &lastName);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(std::string_view(lastName), "provider2");
 
     // successful provider should not be returned by umfGetLastFailedMemoryProvider
     allocResult = UMF_RESULT_SUCCESS;
     ptr = umfPoolMalloc(pool.get(), allocSize);
     ASSERT_NE(ptr, nullptr);
-    ASSERT_EQ(std::string_view(
-                  umfMemoryProviderGetName(umfGetLastFailedMemoryProvider())),
-              "provider2");
+    ret = umfGetLastFailedMemoryProvider(&lastProv);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ret = umfMemoryProviderGetName(lastProv, &lastName);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(std::string_view(lastName), "provider2");
     umfPoolFree(pool.get(), ptr);
 
     // error in another thread should not impact umfGetLastFailedMemoryProvider on this thread
@@ -347,15 +569,21 @@ TEST_F(test, getLastFailedMemoryProvider) {
     std::thread t([&, hPool = pool.get()] {
         ptr = umfPoolMalloc(hPool, allocSize);
         ASSERT_EQ(ptr, nullptr);
-        ASSERT_EQ(std::string_view(umfMemoryProviderGetName(
-                      umfGetLastFailedMemoryProvider())),
-                  "provider1");
+        umf_memory_provider_handle_t prov = nullptr;
+        umf_result_t ret = umfGetLastFailedMemoryProvider(&prov);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        const char *name = nullptr;
+        ret = umfMemoryProviderGetName(prov, &name);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_EQ(std::string_view(name), "provider1");
     });
     t.join();
 
-    ASSERT_EQ(std::string_view(
-                  umfMemoryProviderGetName(umfGetLastFailedMemoryProvider())),
-              "provider2");
+    ret = umfGetLastFailedMemoryProvider(&lastProv);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ret = umfMemoryProviderGetName(lastProv, &lastName);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(std::string_view(lastName), "provider2");
 }
 
 // This fixture can be instantiated with any function that accepts void
@@ -394,4 +622,24 @@ INSTANTIATE_TEST_SUITE_P(
         umf_test::withGeneratedArgs(umfPoolCalloc),
         umf_test::withGeneratedArgs(umfPoolRealloc),
         umf_test::withGeneratedArgs(umfPoolMallocUsableSize),
-        umf_test::withGeneratedArgs(umfPoolGetLastAllocationError)));
+        umf_test::withGeneratedArgs(umfPoolGetLastAllocationError),
+        umf_test::withGeneratedArgs(umfPoolGetName),
+        umf_test::withGeneratedArgs(umfPoolGetMemoryProvider),
+        umf_test::withGeneratedArgs(umfPoolByPtr),
+        umf_test::withGeneratedArgs(umfPoolSetTag),
+        umf_test::withGeneratedArgs(umfPoolGetTag)),
+    ([](auto const &info) -> std::string {
+        static const char *names[] = {"umfPoolMalloc",
+                                      "umfPoolAlignedMalloc",
+                                      "umfPoolFree",
+                                      "umfPoolCalloc",
+                                      "umfPoolRealloc",
+                                      "umfPoolMallocUsableSize",
+                                      "umfPoolGetLastAllocationError",
+                                      "umfPoolGetName",
+                                      "umfPoolGetMemoryProvider",
+                                      "umfPoolByPtr",
+                                      "umfPoolSetTag",
+                                      "umfPoolGetTag"};
+        return names[info.index];
+    }));
diff --git a/test/memoryProviderAPI.cpp b/test/memoryProviderAPI.cpp
index 866ae6dae3..5cbc8c2cac 100644
--- a/test/memoryProviderAPI.cpp
+++ b/test/memoryProviderAPI.cpp
@@ -1,20 +1,22 @@
-// 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
 // This file contains tests for UMF provider API
 
-#include "provider.hpp"
-#include "provider_null.h"
-#include "test_helpers.h"
-
+#include <gtest/gtest.h>
 #include <string>
 #include <unordered_map>
 #include <variant>
 
+#include "memory_properties_internal.h"
+#include "provider.hpp"
+#include "provider_null.h"
+#include "test_helpers.h"
+
 using umf_test::test;
 
 TEST_F(test, memoryProviderTrace) {
-    using calls_type = std::unordered_map<std::string, size_t>;
+    using calls_type = std::unordered_map<std::string, unsigned int>;
     calls_type calls;
     auto trace = [](void *handler, const char *name) {
         auto &calls = *static_cast<calls_type *>(handler);
@@ -25,52 +27,58 @@ TEST_F(test, memoryProviderTrace) {
     auto tracingProvider = umf_test::wrapProviderUnique(
         traceProviderCreate(nullProvider, true, &calls, trace));
 
-    size_t call_count = 0;
+    size_t call_count = 1; // get_name is called during initialization
 
     void *ptr;
     auto ret = umfMemoryProviderAlloc(tracingProvider.get(), 0, 0, &ptr);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(calls["alloc"], 1);
+    ASSERT_EQ(calls["alloc"], 1UL);
     ASSERT_EQ(calls.size(), ++call_count);
 
     ret = umfMemoryProviderFree(tracingProvider.get(), nullptr, 0);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(calls["free"], 1);
+    ASSERT_EQ(calls["free"], 1UL);
     ASSERT_EQ(calls.size(), ++call_count);
 
-    umfMemoryProviderGetLastNativeError(tracingProvider.get(), nullptr,
-                                        nullptr);
-    ASSERT_EQ(calls["get_last_native_error"], 1);
+    const char *buffer;
+    int err;
+    ret = umfMemoryProviderGetLastNativeError(tracingProvider.get(), &buffer,
+                                              &err);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(calls["get_last_native_error"], 1UL);
     ASSERT_EQ(calls.size(), ++call_count);
 
     size_t page_size;
     ret = umfMemoryProviderGetRecommendedPageSize(tracingProvider.get(), 0,
                                                   &page_size);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(calls["get_recommended_page_size"], 1);
+    ASSERT_EQ(calls["get_recommended_page_size"], 1UL);
     ASSERT_EQ(calls.size(), ++call_count);
 
     ret = umfMemoryProviderGetMinPageSize(tracingProvider.get(), nullptr,
                                           &page_size);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(calls["get_min_page_size"], 1);
+    ASSERT_EQ(calls["get_min_page_size"], 1UL);
     ASSERT_EQ(calls.size(), ++call_count);
 
-    const char *pName = umfMemoryProviderGetName(tracingProvider.get());
-    ASSERT_EQ(calls["name"], 1);
-    ASSERT_EQ(calls.size(), ++call_count);
+    const char *pName = nullptr;
+    ret = umfMemoryProviderGetName(tracingProvider.get(), &pName);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(pName, nullptr);
+    ASSERT_EQ(calls["name"], 2UL);
+    ASSERT_EQ(calls.size(), call_count);
     ASSERT_EQ(std::string(pName), std::string("null"));
 
     ret = umfMemoryProviderPurgeLazy(tracingProvider.get(), &page_size,
                                      sizeof(page_size));
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(calls["purge_lazy"], 1);
+    ASSERT_EQ(calls["purge_lazy"], 1UL);
     ASSERT_EQ(calls.size(), ++call_count);
 
     ret = umfMemoryProviderPurgeForce(tracingProvider.get(), &page_size,
                                       sizeof(page_size));
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(calls["purge_force"], 1);
+    ASSERT_EQ(calls["purge_force"], 1UL);
     ASSERT_EQ(calls.size(), ++call_count);
 
     void *lowPtr = (void *)0xBAD;
@@ -78,33 +86,20 @@ TEST_F(test, memoryProviderTrace) {
     ret = umfMemoryProviderAllocationMerge(tracingProvider.get(), lowPtr,
                                            highPtr, 2 * 4096);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(calls["allocation_merge"], 1);
+    ASSERT_EQ(calls["allocation_merge"], 1UL);
     ASSERT_EQ(calls.size(), ++call_count);
 
     ptr = (void *)0xBAD;
     ret = umfMemoryProviderAllocationSplit(tracingProvider.get(), ptr, 2 * 4096,
                                            4096);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(calls["allocation_split"], 1);
+    ASSERT_EQ(calls["allocation_split"], 1UL);
     ASSERT_EQ(calls.size(), ++call_count);
 }
 
-TEST_F(test, memoryProviderOpsNullFreeField) {
-    umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
-    provider_ops.ext.free = nullptr;
-    umf_memory_provider_handle_t hProvider;
-    auto ret = umfMemoryProviderCreate(&provider_ops, nullptr, &hProvider);
-    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-
-    ret = umfMemoryProviderFree(hProvider, nullptr, 0);
-    ASSERT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
-
-    umfMemoryProviderDestroy(hProvider);
-}
-
 TEST_F(test, memoryProviderOpsNullPurgeLazyField) {
     umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
-    provider_ops.ext.purge_lazy = nullptr;
+    provider_ops.ext_purge_lazy = nullptr;
     umf_memory_provider_handle_t hProvider;
     auto ret = umfMemoryProviderCreate(&provider_ops, nullptr, &hProvider);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
@@ -117,7 +112,7 @@ TEST_F(test, memoryProviderOpsNullPurgeLazyField) {
 
 TEST_F(test, memoryProviderOpsNullPurgeForceField) {
     umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
-    provider_ops.ext.purge_force = nullptr;
+    provider_ops.ext_purge_force = nullptr;
     umf_memory_provider_handle_t hProvider;
     auto ret = umfMemoryProviderCreate(&provider_ops, nullptr, &hProvider);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
@@ -130,8 +125,8 @@ TEST_F(test, memoryProviderOpsNullPurgeForceField) {
 
 TEST_F(test, memoryProviderOpsNullAllocationSplitAllocationMergeFields) {
     umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
-    provider_ops.ext.allocation_split = nullptr;
-    provider_ops.ext.allocation_merge = nullptr;
+    provider_ops.ext_allocation_split = nullptr;
+    provider_ops.ext_allocation_merge = nullptr;
     umf_memory_provider_handle_t hProvider;
     auto ret = umfMemoryProviderCreate(&provider_ops, nullptr, &hProvider);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
@@ -151,11 +146,11 @@ TEST_F(test, memoryProviderOpsNullAllocationSplitAllocationMergeFields) {
 
 TEST_F(test, memoryProviderOpsNullAllIPCFields) {
     umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
-    provider_ops.ipc.get_ipc_handle_size = nullptr;
-    provider_ops.ipc.get_ipc_handle = nullptr;
-    provider_ops.ipc.put_ipc_handle = nullptr;
-    provider_ops.ipc.open_ipc_handle = nullptr;
-    provider_ops.ipc.close_ipc_handle = nullptr;
+    provider_ops.ext_get_ipc_handle_size = nullptr;
+    provider_ops.ext_get_ipc_handle = nullptr;
+    provider_ops.ext_put_ipc_handle = nullptr;
+    provider_ops.ext_open_ipc_handle = nullptr;
+    provider_ops.ext_close_ipc_handle = nullptr;
 
     umf_memory_provider_handle_t hProvider;
     auto ret = umfMemoryProviderCreate(&provider_ops, nullptr, &hProvider);
@@ -182,6 +177,11 @@ TEST_F(test, memoryProviderOpsNullAllIPCFields) {
     umfMemoryProviderDestroy(hProvider);
 }
 
+TEST_F(test, memoryProviderNullDelete) {
+    auto ret = umfMemoryProviderDestroy(nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+}
+
 ////////////////// Negative test cases /////////////////
 
 TEST_F(test, memoryProviderCreateNullOps) {
@@ -204,6 +204,14 @@ TEST_F(test, memoryProviderOpsNullAllocField) {
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
 
+TEST_F(test, memoryProviderOpsNullFreeField) {
+    umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
+    provider_ops.free = nullptr;
+    umf_memory_provider_handle_t hProvider;
+    auto ret = umfMemoryProviderCreate(&provider_ops, nullptr, &hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
 TEST_F(test, memoryProviderOpsNullGetLastNativeErrorField) {
     umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
     provider_ops.get_last_native_error = nullptr;
@@ -238,7 +246,7 @@ TEST_F(test, memoryProviderOpsNullGetNameField) {
 
 TEST_F(test, memoryProviderOpsNullAllocationSplitField) {
     umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
-    provider_ops.ext.allocation_split = nullptr;
+    provider_ops.ext_allocation_split = nullptr;
     umf_memory_provider_handle_t hProvider;
     auto ret = umfMemoryProviderCreate(&provider_ops, nullptr, &hProvider);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
@@ -246,7 +254,7 @@ TEST_F(test, memoryProviderOpsNullAllocationSplitField) {
 
 TEST_F(test, memoryProviderOpsNullAllocationMergeField) {
     umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
-    provider_ops.ext.allocation_merge = nullptr;
+    provider_ops.ext_allocation_merge = nullptr;
     umf_memory_provider_handle_t hProvider;
     auto ret = umfMemoryProviderCreate(&provider_ops, nullptr, &hProvider);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
@@ -254,7 +262,7 @@ TEST_F(test, memoryProviderOpsNullAllocationMergeField) {
 
 TEST_F(test, memoryProviderOpsNullGetIpcHandleSize) {
     umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
-    provider_ops.ipc.get_ipc_handle_size = nullptr;
+    provider_ops.ext_get_ipc_handle_size = nullptr;
     umf_memory_provider_handle_t hProvider;
     auto ret = umfMemoryProviderCreate(&provider_ops, nullptr, &hProvider);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
@@ -262,7 +270,7 @@ TEST_F(test, memoryProviderOpsNullGetIpcHandleSize) {
 
 TEST_F(test, memoryProviderOpsNullGetIpcHandle) {
     umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
-    provider_ops.ipc.get_ipc_handle = nullptr;
+    provider_ops.ext_get_ipc_handle = nullptr;
     umf_memory_provider_handle_t hProvider;
     auto ret = umfMemoryProviderCreate(&provider_ops, nullptr, &hProvider);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
@@ -270,7 +278,7 @@ TEST_F(test, memoryProviderOpsNullGetIpcHandle) {
 
 TEST_F(test, memoryProviderOpsNullPutIpcHandle) {
     umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
-    provider_ops.ipc.put_ipc_handle = nullptr;
+    provider_ops.ext_put_ipc_handle = nullptr;
     umf_memory_provider_handle_t hProvider;
     auto ret = umfMemoryProviderCreate(&provider_ops, nullptr, &hProvider);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
@@ -278,7 +286,7 @@ TEST_F(test, memoryProviderOpsNullPutIpcHandle) {
 
 TEST_F(test, memoryProviderOpsNullOpenIpcHandle) {
     umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
-    provider_ops.ipc.open_ipc_handle = nullptr;
+    provider_ops.ext_open_ipc_handle = nullptr;
     umf_memory_provider_handle_t hProvider;
     auto ret = umfMemoryProviderCreate(&provider_ops, nullptr, &hProvider);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
@@ -286,7 +294,7 @@ TEST_F(test, memoryProviderOpsNullOpenIpcHandle) {
 
 TEST_F(test, memoryProviderOpsNullCloseIpcHandle) {
     umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
-    provider_ops.ipc.close_ipc_handle = nullptr;
+    provider_ops.ext_close_ipc_handle = nullptr;
     umf_memory_provider_handle_t hProvider;
     auto ret = umfMemoryProviderCreate(&provider_ops, nullptr, &hProvider);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
@@ -331,16 +339,23 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::Values(UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY,
                       UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC,
                       UMF_RESULT_ERROR_INVALID_ARGUMENT,
-                      UMF_RESULT_ERROR_UNKNOWN));
+                      UMF_RESULT_ERROR_UNKNOWN),
+    ([](auto const &info) -> std::string {
+        static const char *names[] = {
+            "UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY",
+            "UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC",
+            "UMF_RESULT_ERROR_INVALID_ARGUMENT", "UMF_RESULT_ERROR_UNKNOWN"};
+        return names[info.index];
+    }));
 
 TEST_P(providerInitializeTest, errorPropagation) {
     struct provider : public umf_test::provider_base_t {
-        umf_result_t initialize(umf_result_t *errorToReturn) noexcept {
+        umf_result_t initialize(const umf_result_t *errorToReturn) noexcept {
             return *errorToReturn;
         }
     };
     umf_memory_provider_ops_t provider_ops =
-        umf::providerMakeCOps<provider, umf_result_t>();
+        umf_test::providerMakeCOps<provider, umf_result_t>();
 
     umf_memory_provider_handle_t hProvider;
     auto ret = umfMemoryProviderCreate(&provider_ops, (void *)&this->GetParam(),
@@ -382,4 +397,14 @@ INSTANTIATE_TEST_SUITE_P(
         umf_test::withGeneratedArgs(umfMemoryProviderGetMinPageSize),
         umf_test::withGeneratedArgs(umfMemoryProviderPurgeLazy),
         umf_test::withGeneratedArgs(umfMemoryProviderPurgeForce),
-        umf_test::withGeneratedArgs(umfMemoryProviderGetName)));
+        umf_test::withGeneratedArgs(umfMemoryProviderGetName)),
+    ([](auto const &info) -> std::string {
+        static const char *names[] = {"umfMemoryProviderAlloc",
+                                      "umfMemoryProviderFree",
+                                      "umfMemoryProviderGetRecommendedPageSize",
+                                      "umfMemoryProviderGetMinPageSize",
+                                      "umfMemoryProviderPurgeLazy",
+                                      "umfMemoryProviderPurgeForce",
+                                      "umfMemoryProviderGetName"};
+        return names[info.index];
+    }));
diff --git a/test/memspaces/mempolicy.cpp b/test/memspaces/mempolicy.cpp
index 97948bfbb7..2cde749be2 100644
--- a/test/memspaces/mempolicy.cpp
+++ b/test/memspaces/mempolicy.cpp
@@ -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
 
@@ -7,11 +7,7 @@
 #include "provider_os_memory_internal.h"
 
 os_memory_provider_t *providerGetPriv(umf_memory_provider_handle_t hProvider) {
-    // hack to have access to fields in structure defined in memory_provider.c
-    struct umf_memory_provider_t {
-        umf_memory_provider_ops_t ops;
-        void *provider_priv;
-    } *provider = (struct umf_memory_provider_t *)hProvider;
+    umf_memory_provider_t *provider = (umf_memory_provider_t *)hProvider;
     return (os_memory_provider_t *)provider->provider_priv;
 }
 
@@ -85,7 +81,8 @@ TEST_F(test, mempolicyDefaultInterleave) {
     EXPECT_EQ(ProviderInternal->numa_flags, HWLOC_MEMBIND_BYNODESET);
     EXPECT_EQ(ProviderInternal->part_size, 0);
     EXPECT_EQ(ProviderInternal->mode, UMF_NUMA_MODE_INTERLEAVE);
-    umfMemoryProviderDestroy(hProvider);
+    ret = umfMemoryProviderDestroy(hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 TEST_F(test, mempolicyInterleavePartSize) {
@@ -113,7 +110,8 @@ TEST_F(test, mempolicyInterleavePartSize) {
               HWLOC_MEMBIND_BYNODESET | HWLOC_MEMBIND_STRICT);
     EXPECT_EQ(ProviderInternal->part_size, part_size);
     EXPECT_EQ(ProviderInternal->mode, UMF_NUMA_MODE_INTERLEAVE);
-    umfMemoryProviderDestroy(hProvider);
+    ret = umfMemoryProviderDestroy(hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 TEST_F(test, mempolicyDefaultSplit) {
@@ -138,7 +136,8 @@ TEST_F(test, mempolicyDefaultSplit) {
               HWLOC_MEMBIND_BYNODESET | HWLOC_MEMBIND_STRICT);
     EXPECT_EQ(ProviderInternal->partitions_len, ProviderInternal->nodeset_len);
     EXPECT_EQ(ProviderInternal->mode, UMF_NUMA_MODE_SPLIT);
-    umfMemoryProviderDestroy(hProvider);
+    ret = umfMemoryProviderDestroy(hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 TEST_F(test, mempolicyCustomSplit) {
@@ -170,7 +169,8 @@ TEST_F(test, mempolicyCustomSplit) {
     EXPECT_EQ(ProviderInternal->partitions_weight_sum, 2);
     EXPECT_EQ(ProviderInternal->partitions[0].target,
               ProviderInternal->partitions[1].target);
-    umfMemoryProviderDestroy(hProvider);
+    ret = umfMemoryProviderDestroy(hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 TEST_F(test, mempolicySplitNegative) {
diff --git a/test/memspaces/memspace.cpp b/test/memspaces/memspace.cpp
index 412c5beb70..c66447c351 100644
--- a/test/memspaces/memspace.cpp
+++ b/test/memspaces/memspace.cpp
@@ -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
 
@@ -35,9 +35,33 @@ TEST_F(emptyMemspace, create_pool) {
     ASSERT_EQ(pool, nullptr);
 }
 
-TEST_F(emptyMemspace, create_provider) {
+TEST_F(emptyMemspace, invalid_create_from_memspace) {
     umf_memory_provider_handle_t provider = nullptr;
-    auto ret = umfMemoryProviderCreateFromMemspace(memspace, NULL, &provider);
-    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-    ASSERT_EQ(provider, nullptr);
+    umf_mempolicy_handle_t policy = nullptr;
+
+    // invalid memspace
+    umf_result_t ret =
+        umfMemoryProviderCreateFromMemspace(NULL, policy, &provider);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(provider, nullptr);
+
+    // invalid provider
+    ret = umfMemoryProviderCreateFromMemspace(memspace, policy, nullptr);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // Valid params, but memspace is empty
+    ret = umfMemoryProviderCreateFromMemspace(memspace, policy, &provider);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(provider, nullptr);
+}
+
+TEST_F(emptyMemspace, invalid_clone) {
+    umf_const_memspace_handle_t memspace = nullptr;
+    umf_memspace_handle_t out_memspace = nullptr;
+
+    umf_result_t ret = umfMemspaceClone(memspace, nullptr);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfMemspaceClone(nullptr, &out_memspace);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
diff --git a/test/memspaces/memspace_fixtures.hpp b/test/memspaces/memspace_fixtures.hpp
index da174c4f1a..4bbb5d65a3 100644
--- a/test/memspaces/memspace_fixtures.hpp
+++ b/test/memspaces/memspace_fixtures.hpp
@@ -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
 
@@ -10,7 +10,7 @@
 #include <numaif.h>
 #include <thread>
 
-#include <umf/memspace.h>
+#include <umf/experimental/memspace.h>
 
 #include "base.hpp"
 #include "memspace_helpers.hpp"
diff --git a/test/memspaces/memspace_highest_bandwidth.cpp b/test/memspaces/memspace_highest_bandwidth.cpp
index 5c30696a8a..5ad19baedb 100644
--- a/test/memspaces/memspace_highest_bandwidth.cpp
+++ b/test/memspaces/memspace_highest_bandwidth.cpp
@@ -1,12 +1,13 @@
-// 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
 
-#include <umf/memspace.h>
+#include <umf/experimental/memspace.h>
 
 #include "memspace_fixtures.hpp"
 #include "memspace_helpers.hpp"
 #include "memspace_internal.h"
+#include "numa_helpers.hpp"
 #include "test_helpers.h"
 
 static void canQueryBandwidth(size_t nodeId) {
@@ -39,13 +40,99 @@ static void canQueryBandwidth(size_t nodeId) {
     }
 }
 
-INSTANTIATE_TEST_SUITE_P(memspaceLowestLatencyTest, memspaceGetTest,
-                         ::testing::Values(memspaceGetParams{
-                             canQueryBandwidth,
-                             umfMemspaceHighestBandwidthGet}));
+INSTANTIATE_TEST_SUITE_P(
+    memspaceLowestLatencyTest, memspaceGetTest,
+    ::testing::Values(memspaceGetParams{canQueryBandwidth,
+                                        umfMemspaceHighestBandwidthGet}),
+    ([](auto const &info) -> std::string {
+        static const char *names[] = {"canQueryBandwidth",
+                                      "umfMemspaceHighestBandwidthGet"};
+        return names[info.index];
+    }));
 
-INSTANTIATE_TEST_SUITE_P(memspaceLowestLatencyProviderTest,
-                         memspaceProviderTest,
-                         ::testing::Values(memspaceGetParams{
-                             canQueryBandwidth,
-                             umfMemspaceHighestBandwidthGet}));
+INSTANTIATE_TEST_SUITE_P(
+    memspaceLowestLatencyProviderTest, memspaceProviderTest,
+    ::testing::Values(memspaceGetParams{canQueryBandwidth,
+                                        umfMemspaceHighestBandwidthGet}),
+    ([](auto const &info) -> std::string {
+        static const char *names[] = {"canQueryBandwidth",
+                                      "umfMemspaceHighestBandwidthGet"};
+        return names[info.index];
+    }));
+
+TEST_F(numaNodesTest, PerCoreBandwidthPlacement) {
+    const size_t allocSize = 4096;
+    unsigned int numCores = std::thread::hardware_concurrency();
+    if (numCores == 0) {
+        numCores = 1;
+    }
+
+    canQueryBandwidth(0);
+    if (IS_SKIPPED_OR_FAILED()) {
+        GTEST_SKIP() << "Error: hwloc_memattr_get_value returned 0";
+    }
+
+    std::vector<std::thread> workers;
+    workers.reserve(numCores);
+
+    for (unsigned int i = 0; i < numCores; ++i) {
+        workers.emplace_back([cpuIndex = i]() {
+            hwloc_topology_t topo = nullptr;
+            ASSERT_EQ(hwloc_topology_init(&topo), 0);
+            ASSERT_EQ(hwloc_topology_load(topo), 0);
+
+            hwloc_bitmap_t target = hwloc_bitmap_alloc();
+            hwloc_bitmap_only(target, cpuIndex);
+            ASSERT_EQ(
+                hwloc_set_cpubind(topo, target,
+                                  HWLOC_CPUBIND_THREAD | HWLOC_CPUBIND_STRICT),
+                0);
+            hwloc_bitmap_free(target);
+
+            hwloc_location initiator;
+            hwloc_bitmap_t here = hwloc_bitmap_alloc();
+            ASSERT_EQ(
+                hwloc_get_cpubind(topo, here,
+                                  HWLOC_CPUBIND_THREAD | HWLOC_CPUBIND_STRICT),
+                0);
+            initiator.location.cpuset = here;
+            initiator.type = HWLOC_LOCATION_TYPE_CPUSET;
+
+            hwloc_obj_t bestnode;
+            hwloc_memattr_get_best_target(topo, HWLOC_MEMATTR_ID_BANDWIDTH,
+                                          &initiator, 0, &bestnode, nullptr);
+
+            void *ptr_hwloc = hwloc_alloc_membind(
+                topo, allocSize, bestnode->nodeset, HWLOC_MEMBIND_BIND,
+                HWLOC_MEMBIND_BYNODESET);
+            ASSERT_NE(ptr_hwloc, nullptr);
+            memset(ptr_hwloc, 0, allocSize);
+
+            auto memspace = umfMemspaceHighestBandwidthGet();
+            ASSERT_NE(memspace, nullptr);
+
+            umf_memory_provider_handle_t provider;
+            ASSERT_EQ(umfMemoryProviderCreateFromMemspace(memspace, nullptr,
+                                                          &provider),
+                      UMF_RESULT_SUCCESS);
+
+            void *ptr_umf = nullptr;
+            ASSERT_EQ(umfMemoryProviderAlloc(provider, allocSize, 0, &ptr_umf),
+                      UMF_RESULT_SUCCESS);
+            ASSERT_NE(ptr_umf, nullptr);
+            memset(ptr_umf, 0, allocSize);
+
+            ASSERT_NODE_EQ(ptr_umf, ptr_hwloc);
+
+            umfMemoryProviderFree(provider, ptr_umf, allocSize);
+            umfMemoryProviderDestroy(provider);
+            hwloc_free(topo, ptr_hwloc, allocSize);
+            hwloc_bitmap_free(here);
+            hwloc_topology_destroy(topo);
+        });
+    }
+
+    for (auto &t : workers) {
+        t.join();
+    }
+}
diff --git a/test/memspaces/memspace_highest_capacity.cpp b/test/memspaces/memspace_highest_capacity.cpp
index 8452e74a79..5da14fe4a5 100644
--- a/test/memspaces/memspace_highest_capacity.cpp
+++ b/test/memspaces/memspace_highest_capacity.cpp
@@ -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
 
@@ -11,7 +11,7 @@
 
 #include <numa.h>
 #include <numaif.h>
-#include <umf/memspace.h>
+#include <umf/experimental/memspace.h>
 #include <unordered_set>
 
 using umf_test::test;
diff --git a/test/memspaces/memspace_host_all.cpp b/test/memspaces/memspace_host_all.cpp
index 3462b87dc0..4fd0f5bff5 100644
--- a/test/memspaces/memspace_host_all.cpp
+++ b/test/memspaces/memspace_host_all.cpp
@@ -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
 
@@ -7,7 +7,7 @@
 #include <sys/mman.h>
 #include <unordered_set>
 
-#include <umf/memspace.h>
+#include <umf/experimental/memspace.h>
 
 #include "memspace_fixtures.hpp"
 #include "memspace_helpers.hpp"
diff --git a/test/memspaces/memspace_lowest_latency.cpp b/test/memspaces/memspace_lowest_latency.cpp
index fc35f465a0..78e8412de1 100644
--- a/test/memspaces/memspace_lowest_latency.cpp
+++ b/test/memspaces/memspace_lowest_latency.cpp
@@ -1,8 +1,8 @@
-// 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
 
-#include <umf/memspace.h>
+#include <umf/experimental/memspace.h>
 
 #include "memspace_fixtures.hpp"
 #include "memspace_helpers.hpp"
@@ -41,9 +41,21 @@ static void canQueryLatency(size_t nodeId) {
 
 INSTANTIATE_TEST_SUITE_P(memspaceLowestLatencyTest, memspaceGetTest,
                          ::testing::Values(memspaceGetParams{
-                             canQueryLatency, umfMemspaceLowestLatencyGet}));
+                             canQueryLatency, umfMemspaceLowestLatencyGet}),
+                         ([](auto const &info) -> std::string {
+                             static const char *names[] = {
+                                 "canQueryLatency",
+                                 "umfMemspaceLowestLatencyGet"};
+                             return names[info.index];
+                         }));
 
 INSTANTIATE_TEST_SUITE_P(memspaceLowestLatencyProviderTest,
                          memspaceProviderTest,
                          ::testing::Values(memspaceGetParams{
-                             canQueryLatency, umfMemspaceLowestLatencyGet}));
+                             canQueryLatency, umfMemspaceLowestLatencyGet}),
+                         ([](auto const &info) -> std::string {
+                             static const char *names[] = {
+                                 "canQueryLatency",
+                                 "umfMemspaceLowestLatencyGet"};
+                             return names[info.index];
+                         }));
diff --git a/test/memspaces/memspace_numa.cpp b/test/memspaces/memspace_numa.cpp
index 068df68869..c2cc0e4d9b 100644
--- a/test/memspaces/memspace_numa.cpp
+++ b/test/memspaces/memspace_numa.cpp
@@ -1,4 +1,4 @@
-// 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
 
@@ -8,7 +8,7 @@
 #include "memspace_internal.h"
 #include "numa_helpers.hpp"
 
-#include <umf/memspace.h>
+#include <umf/experimental/memspace.h>
 #include <umf/providers/provider_os_memory.h>
 
 struct memspaceNumaTest : ::numaNodesTest {
@@ -71,7 +71,8 @@ TEST_F(numaNodesTest, createDestroy) {
         EXPECT_NE(umfMemspaceMemtargetGet(hMemspace, i), nullptr);
     }
 
-    umfMemspaceDestroy(hMemspace);
+    ret = umfMemspaceDestroy(hMemspace);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 TEST_F(numaNodesTest, createInvalidNullArray) {
@@ -102,7 +103,8 @@ TEST_F(memspaceNumaTest, providerFromNumaMemspace) {
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_NE(hProvider, nullptr);
 
-    umfMemoryProviderDestroy(hProvider);
+    ret = umfMemoryProviderDestroy(hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 TEST_F(memspaceNumaTest, memtargetsInvalid) {
@@ -157,9 +159,12 @@ TEST_F(memspaceNumaTest, memspaceCopyTarget) {
     ret = umfMemoryProviderFree(hProvider2, ptr2, SIZE_4K);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    umfMemoryProviderDestroy(hProvider1);
-    umfMemoryProviderDestroy(hProvider2);
-    umfMemspaceDestroy(hMemspaceCopy);
+    ret = umfMemoryProviderDestroy(hProvider1);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ret = umfMemoryProviderDestroy(hProvider2);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ret = umfMemspaceDestroy(hMemspaceCopy);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 TEST_F(memspaceNumaTest, memspaceDeleteTarget) {
@@ -216,9 +221,12 @@ TEST_F(memspaceNumaTest, memspaceDeleteTarget) {
     ret = umfMemoryProviderFree(hProvider2, ptr2, SIZE_4K);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    umfMemoryProviderDestroy(hProvider1);
-    umfMemoryProviderDestroy(hProvider2);
-    umfMemspaceDestroy(hMemspaceCopy);
+    ret = umfMemoryProviderDestroy(hProvider1);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ret = umfMemoryProviderDestroy(hProvider2);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ret = umfMemspaceDestroy(hMemspaceCopy);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 TEST_F(memspaceNumaProviderTest, allocFree) {
@@ -252,8 +260,8 @@ TEST_F(numaNodesCapacityTest, CapacityFilter) {
     ret = umfMemspaceFilterByCapacity(hMemspace, filter_size);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    ASSERT_EQ(umfMemspaceMemtargetNum(hMemspace), (capacities.size() + 1) / 2);
-    for (size_t i = 0; i < umfMemspaceMemtargetNum(hMemspace); i++) {
+    size_t num_filtered = umfMemspaceMemtargetNum(hMemspace);
+    for (size_t i = 0; i < num_filtered; i++) {
         auto hTarget = umfMemspaceMemtargetGet(hMemspace, i);
         ASSERT_NE(hTarget, nullptr);
         size_t capacity;
@@ -266,7 +274,19 @@ TEST_F(numaNodesCapacityTest, CapacityFilter) {
             capacities.erase(it);
         }
     }
-    umfMemspaceDestroy(hMemspace);
+
+    // Number of filtered targets and remaining targets should match the total
+    // number of targets in the memspace
+    size_t num_all = umfMemspaceMemtargetNum(umfMemspaceHostAllGet());
+    ASSERT_EQ(num_filtered + capacities.size(), num_all);
+
+    // check that remaining capacities are less than filter_size
+    for (const auto &capacity : capacities) {
+        ASSERT_LT(capacity, filter_size);
+    }
+
+    ret = umfMemspaceDestroy(hMemspace);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 TEST_F(numaNodesTest, idfilter) {
@@ -297,7 +317,8 @@ TEST_F(numaNodesTest, idfilter) {
             ids.erase(it);
         }
     }
-    umfMemspaceDestroy(hMemspace);
+    ret = umfMemspaceDestroy(hMemspace);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 int customfilter(umf_const_memspace_handle_t memspace,
@@ -345,7 +366,8 @@ TEST_F(numaNodesTest, customfilter) {
         }
     }
     ASSERT_EQ(vec.size(), 0);
-    umfMemspaceDestroy(hMemspace);
+    ret = umfMemspaceDestroy(hMemspace);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 int invalidFilter(umf_const_memspace_handle_t memspace,
@@ -382,5 +404,6 @@ TEST_F(numaNodesTest, invalidFilters) {
 
     ret = umfMemspaceUserFilter(hMemspace, invalidFilter, nullptr);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_USER_SPECIFIC);
-    umfMemspaceDestroy(hMemspace);
+    ret = umfMemspaceDestroy(hMemspace);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
diff --git a/test/memspaces/memtarget.cpp b/test/memspaces/memtarget.cpp
index 325fa9d1d2..9b029c9d25 100644
--- a/test/memspaces/memtarget.cpp
+++ b/test/memspaces/memtarget.cpp
@@ -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
 
@@ -6,8 +6,8 @@
 #include "memspace_helpers.hpp"
 
 #include <umf/base.h>
-#include <umf/memspace.h>
-#include <umf/memtarget.h>
+#include <umf/experimental/memspace.h>
+#include <umf/experimental/memtarget.h>
 
 using umf_test::test;
 
@@ -103,3 +103,72 @@ TEST_F(numaNodesTest, getIdInvalid) {
     ret = umfMemtargetGetId(hTarget, NULL);
     EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
+
+TEST_F(test, memTargetInvalidAdd) {
+    umf_const_memspace_handle_t const_memspace = umfMemspaceHostAllGet();
+    umf_memspace_handle_t memspace = nullptr;
+    umf_result_t ret = umfMemspaceClone(const_memspace, &memspace);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(memspace, nullptr);
+    umf_const_memtarget_handle_t memtarget =
+        umfMemspaceMemtargetGet(memspace, 0);
+
+    ret = umfMemspaceMemtargetAdd(memspace, nullptr);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfMemspaceMemtargetAdd(nullptr, memtarget);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // Try to add the same memtarget again
+    ret = umfMemspaceMemtargetAdd(memspace, memtarget);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfMemspaceDestroy(memspace);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+}
+
+TEST_F(test, memTargetInvalidRemove) {
+    umf_const_memspace_handle_t const_memspace = umfMemspaceHostAllGet();
+    umf_memspace_handle_t memspace = nullptr;
+    umf_result_t ret = umfMemspaceClone(const_memspace, &memspace);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(memspace, nullptr);
+    umf_const_memtarget_handle_t memtarget =
+        umfMemspaceMemtargetGet(memspace, 0);
+
+    ret = umfMemspaceMemtargetRemove(memspace, nullptr);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfMemspaceMemtargetRemove(nullptr, memtarget);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfMemspaceDestroy(memspace);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+}
+
+TEST_F(test, memTargetRemoveAll) {
+    umf_const_memspace_handle_t const_memspace = umfMemspaceHostAllGet();
+    umf_memspace_handle_t memspace = nullptr;
+    umf_result_t ret = umfMemspaceClone(const_memspace, &memspace);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(memspace, nullptr);
+    umf_const_memtarget_handle_t memtarget = nullptr;
+
+    // Remove all memtargets
+    size_t len = umfMemspaceMemtargetNum(memspace);
+    ASSERT_GT(len, 0);
+    size_t i = len - 1;
+    do {
+        memtarget = umfMemspaceMemtargetGet(memspace, i);
+        EXPECT_NE(memtarget, nullptr);
+        ret = umfMemspaceMemtargetRemove(memspace, memtarget);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    } while (i-- > 0);
+
+    // Try to remove the last one for the second time
+    ret = umfMemspaceMemtargetRemove(memspace, memtarget);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfMemspaceDestroy(memspace);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+}
diff --git a/test/poolFixtures.hpp b/test/poolFixtures.hpp
index e5ec85012c..2b42750239 100644
--- a/test/poolFixtures.hpp
+++ b/test/poolFixtures.hpp
@@ -1,67 +1,78 @@
-// Copyright (C) 2023 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
 
 #ifndef UMF_TEST_POOL_FIXTURES_HPP
 #define UMF_TEST_POOL_FIXTURES_HPP 1
 
-#include "pool.hpp"
-#include "provider.hpp"
-#include "umf/providers/provider_coarse.h"
-#include "umf/providers/provider_devdax_memory.h"
-#include "utils/utils_sanitizers.h"
-
 #include <array>
 #include <cstring>
 #include <functional>
+#include <list>
 #include <random>
 #include <string>
 #include <thread>
 
-#include "../malloc_compliance_tests.hpp"
+#include <umf/experimental/ctl.h>
+#include <umf/pools/pool_proxy.h>
+#include <umf/providers/provider_devdax_memory.h>
+#include <umf/providers/provider_fixed_memory.h>
 
-using poolCreateExtParams =
-    std::tuple<umf_memory_pool_ops_t *, void *, umf_memory_provider_ops_t *,
-               void *, void *>;
+#include "../malloc_compliance_tests.hpp"
+#include "pool.hpp"
+#include "provider.hpp"
+#include "utils/utils_sanitizers.h"
 
-umf::pool_unique_handle_t poolCreateExtUnique(poolCreateExtParams params) {
-    auto [pool_ops, pool_params, provider_ops, provider_params, coarse_params] =
-        params;
+umf_test::pool_unique_handle_t poolCreateExtUnique(poolCreateExtParams params) {
+    auto [pool_ops, poolParamsCreate, poolParamsDestroy, provider_ops,
+          providerParamsCreate, providerParamsDestroy] = params;
 
     umf_memory_provider_handle_t upstream_provider = nullptr;
     umf_memory_provider_handle_t provider = nullptr;
     umf_memory_pool_handle_t hPool = nullptr;
     umf_result_t ret;
 
+    void *provider_params = NULL;
+    if (providerParamsCreate) {
+        provider_params = providerParamsCreate();
+    }
     ret = umfMemoryProviderCreate(provider_ops, provider_params,
                                   &upstream_provider);
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
     EXPECT_NE(upstream_provider, nullptr);
+    if (ret != UMF_RESULT_SUCCESS || upstream_provider == nullptr) {
+        assert(false && "Failed to create a memory provider");
+        return umf_test::pool_unique_handle_t(nullptr, nullptr);
+    }
 
     provider = upstream_provider;
 
-    if (coarse_params) {
-        coarse_memory_provider_params_t *coarse_memory_provider_params =
-            (coarse_memory_provider_params_t *)coarse_params;
-        coarse_memory_provider_params->upstream_memory_provider =
-            upstream_provider;
-        coarse_memory_provider_params->destroy_upstream_memory_provider = true;
-
-        umf_memory_provider_handle_t coarse_provider = nullptr;
-        ret = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(),
-                                      coarse_params, &coarse_provider);
-        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
-        EXPECT_NE(coarse_provider, nullptr);
-
-        provider = coarse_provider;
+    void *pool_params = NULL;
+    if (poolParamsCreate) {
+        pool_params = poolParamsCreate();
     }
 
+    // NOTE: we set the UMF_POOL_CREATE_FLAG_OWN_PROVIDER flag here so the pool
+    // will destroy the provider when it is destroyed
     ret = umfPoolCreate(pool_ops, provider, pool_params,
                         UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &hPool);
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
     EXPECT_NE(hPool, nullptr);
+    if (ret != UMF_RESULT_SUCCESS || hPool == nullptr) {
+        assert(false && "Failed to create a memory pool");
+        return umf_test::pool_unique_handle_t(nullptr, nullptr);
+    }
 
-    return umf::pool_unique_handle_t(hPool, &umfPoolDestroy);
+    // we do not need params anymore
+    if (poolParamsDestroy) {
+        poolParamsDestroy(pool_params);
+    }
+
+    if (providerParamsDestroy) {
+        providerParamsDestroy(provider_params);
+    }
+
+    return umf_test::pool_unique_handle_t(hPool, &umfPoolDestroy);
 }
 
 struct umfPoolTest : umf_test::test,
@@ -74,7 +85,7 @@ struct umfPoolTest : umf_test::test,
 
     void TearDown() override { test::TearDown(); }
 
-    umf::pool_unique_handle_t pool;
+    umf_test::pool_unique_handle_t pool;
 
     static constexpr int NTHREADS = 5;
     static constexpr std::array<int, 7> nonAlignedAllocSizes = {5,  7,   23, 55,
@@ -94,7 +105,7 @@ struct umfMultiPoolTest : umf_test::test,
 
     void TearDown() override { test::TearDown(); }
 
-    std::vector<umf::pool_unique_handle_t> pools;
+    std::vector<umf_test::pool_unique_handle_t> pools;
 };
 
 struct umfMemTest
@@ -111,7 +122,7 @@ struct umfMemTest
 
     void TearDown() override { test::TearDown(); }
 
-    umf::pool_unique_handle_t pool;
+    umf_test::pool_unique_handle_t pool;
     int expectedRecycledPoolAllocs;
 };
 
@@ -119,12 +130,18 @@ GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfMemTest);
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfPoolTest);
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfMultiPoolTest);
 
+TEST_P(umfPoolTest, destroyNullptr) {
+    auto ret = umfPoolDestroy(nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
 TEST_P(umfPoolTest, allocFree) {
     static constexpr size_t allocSize = 64;
     auto *ptr = umfPoolMalloc(pool.get(), allocSize);
     ASSERT_NE(ptr, nullptr);
     std::memset(ptr, 0, allocSize);
-    umfPoolFree(pool.get(), ptr);
+    umf_result_t umf_result = umfPoolFree(pool.get(), ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 }
 
 TEST_P(umfPoolTest, allocFreeNonAlignedSizes) {
@@ -132,10 +149,33 @@ TEST_P(umfPoolTest, allocFreeNonAlignedSizes) {
         auto *ptr = umfPoolMalloc(pool.get(), allocSize);
         ASSERT_NE(ptr, nullptr);
         std::memset(ptr, 0, allocSize);
-        umfPoolFree(pool.get(), ptr);
+        umf_result_t umf_result = umfPoolFree(pool.get(), ptr);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     }
 }
 
+TEST_P(umfPoolTest, allocFreeAligned) {
+// ::aligned_alloc(alignment=4096, size=1) does not work under sanitizers for unknown reason
+#if defined(_WIN32) || defined(__SANITIZE_ADDRESS__) ||                        \
+    defined(__SANITIZE_THREAD__)
+    // TODO: implement support for windows
+    GTEST_SKIP();
+#else
+    if (!umf_test::isAlignedAllocSupported(pool.get())) {
+        GTEST_SKIP();
+    }
+
+    size_t alignment = 4 * 1024; // 4kB
+    void *ptr = umfPoolAlignedMalloc(pool.get(), 1, alignment);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_TRUE(reinterpret_cast<uintptr_t>(ptr) % alignment == 0);
+    *(reinterpret_cast<unsigned char *>(ptr)) = (unsigned char)0xFF;
+
+    umf_result_t umf_result = umfPoolFree(pool.get(), ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+#endif
+}
+
 TEST_P(umfPoolTest, reallocFree) {
     if (!umf_test::isReallocSupported(pool.get())) {
         GTEST_SKIP();
@@ -148,7 +188,8 @@ TEST_P(umfPoolTest, reallocFree) {
     auto *new_ptr = umfPoolRealloc(pool.get(), ptr, allocSize * multiplier);
     ASSERT_NE(new_ptr, nullptr);
     std::memset(new_ptr, 0, allocSize * multiplier);
-    umfPoolFree(pool.get(), new_ptr);
+    umf_result_t umf_result = umfPoolFree(pool.get(), new_ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 }
 
 TEST_P(umfPoolTest, callocFree) {
@@ -162,7 +203,8 @@ TEST_P(umfPoolTest, callocFree) {
     for (size_t i = 0; i < num; ++i) {
         ASSERT_EQ(((int *)ptr)[i], 0);
     }
-    umfPoolFree(pool.get(), ptr);
+    umf_result_t umf_result = umfPoolFree(pool.get(), ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 }
 
 void pow2AlignedAllocHelper(umf_memory_pool_handle_t pool) {
@@ -183,9 +225,31 @@ void pow2AlignedAllocHelper(umf_memory_pool_handle_t pool) {
         }
 
         for (auto &ptr : allocs) {
-            umfPoolFree(pool, ptr);
+            umf_result_t umf_result = umfPoolFree(pool, ptr);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
         }
     }
+
+// ::aligned_alloc(alignment=4096, size=1) does not work under sanitizers for unknown reason
+#if !defined(__SANITIZE_ADDRESS__) && !defined(__SANITIZE_THREAD__)
+    // the same for size = 1
+    for (size_t alignment = 1; alignment <= maxAlignment; alignment <<= 1) {
+        std::vector<void *> allocs;
+
+        for (size_t alloc = 0; alloc < numAllocs; alloc++) {
+            auto *ptr = umfPoolAlignedMalloc(pool, 1, alignment);
+            ASSERT_NE(ptr, nullptr);
+            ASSERT_TRUE(reinterpret_cast<uintptr_t>(ptr) % alignment == 0);
+            *(reinterpret_cast<unsigned char *>(ptr)) = (unsigned char)0xFF;
+            allocs.push_back(ptr);
+        }
+
+        for (auto &ptr : allocs) {
+            umf_result_t umf_result = umfPoolFree(pool, ptr);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+    }
+#endif
 }
 
 TEST_P(umfPoolTest, pow2AlignedAlloc) {
@@ -215,7 +279,8 @@ TEST_P(umfPoolTest, multiThreadedMallocFree) {
         }
 
         for (auto allocation : allocations) {
-            umfPoolFree(inPool, allocation);
+            umf_result_t umf_result = umfPoolFree(inPool, allocation);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
         }
     };
 
@@ -268,7 +333,8 @@ TEST_P(umfPoolTest, multiThreadedReallocFree) {
         for (auto allocation : allocations) {
             auto *ptr =
                 umfPoolRealloc(inPool, allocation, allocSize * multiplier);
-            umfPoolFree(inPool, ptr);
+            umf_result_t umf_result = umfPoolFree(inPool, ptr);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
         }
     };
 
@@ -298,7 +364,8 @@ TEST_P(umfPoolTest, multiThreadedCallocFree) {
         }
 
         for (auto allocation : allocations) {
-            umfPoolFree(inPool, allocation);
+            umf_result_t umf_result = umfPoolFree(inPool, allocation);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
         }
     };
 
@@ -323,7 +390,8 @@ TEST_P(umfPoolTest, multiThreadedMallocFreeRandomSizes) {
         }
 
         for (auto allocation : allocations) {
-            umfPoolFree(inPool, allocation);
+            umf_result_t umf_result = umfPoolFree(inPool, allocation);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
         }
     };
 
@@ -337,6 +405,32 @@ TEST_P(umfPoolTest, multiThreadedMallocFreeRandomSizes) {
     }
 }
 
+TEST_P(umfPoolTest, trimMemory) {
+    constexpr size_t size = 1024;
+
+    umf_memory_pool_handle_t hPool = pool.get();
+    void *ptr = umfPoolMalloc(hPool, size);
+    ASSERT_NE(ptr, nullptr);
+
+    umf_result_t ret = umfPoolFree(hPool, ptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    size_t reserved_memory1 = 0;
+    ret = umfCtlGet("umf.pool.by_handle.{}.stats.reserved_memory",
+                    &reserved_memory1, sizeof(size_t), hPool);
+    ASSERT_GE(reserved_memory1, 0ull);
+
+    // if supported, call to umfPoolTrimMemory should purge the whole memory
+    // pool
+    ret = umfPoolTrimMemory(hPool, 0);
+    if (ret == UMF_RESULT_SUCCESS) {
+        size_t reserved_memory2 = 0;
+        ret = umfCtlGet("umf.pool.by_handle.{}.stats.reserved_memory",
+                        &reserved_memory2, sizeof(size_t), hPool);
+        ASSERT_EQ(reserved_memory2, 0ull);
+    }
+}
+
 TEST_P(umfMemTest, outOfMem) {
     static constexpr size_t allocSize = 4096;
     auto hPool = pool.get();
@@ -363,7 +457,8 @@ TEST_P(umfMemTest, outOfMem) {
     ASSERT_NE(allocations.back(), nullptr);
 
     for (int i = 0; i < expectedRecycledPoolAllocs; i++) {
-        umfPoolFree(hPool, allocations.back());
+        umf_result_t umf_result = umfPoolFree(hPool, allocations.back());
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
         allocations.pop_back();
     }
 
@@ -373,7 +468,8 @@ TEST_P(umfMemTest, outOfMem) {
     }
 
     for (auto allocation : allocations) {
-        umfPoolFree(hPool, allocation);
+        umf_result_t umf_result = umfPoolFree(hPool, allocation);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     }
 }
 
@@ -401,11 +497,15 @@ TEST_P(umfMultiPoolTest, memoryTracking) {
     }
 
     for (auto [ptr, size, expectedPool] : ptrs) {
-        auto pool = umfPoolByPtr(ptr);
+        umf_memory_pool_handle_t pool = nullptr;
+        auto ret = umfPoolByPtr(ptr, &pool);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
         ASSERT_EQ(pool, expectedPool);
 
-        pool = umfPoolByPtr(reinterpret_cast<void *>(
-            reinterpret_cast<intptr_t>(ptr) + size - 1));
+        ret = umfPoolByPtr(reinterpret_cast<void *>(
+                               reinterpret_cast<intptr_t>(ptr) + size - 1),
+                           &pool);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
         ASSERT_EQ(pool, expectedPool);
     }
 
@@ -442,26 +542,315 @@ TEST_P(umfPoolTest, allocMaxSize) {
 }
 
 TEST_P(umfPoolTest, mallocUsableSize) {
+    [[maybe_unused]] auto pool_ops = std::get<0>(this->GetParam());
+#ifdef _WIN32
+    if (pool_ops == &umf_test::MALLOC_POOL_OPS) {
+        GTEST_SKIP()
+            << "Windows Malloc Pool does not support umfPoolAlignedMalloc";
+    }
+#endif
+    if (!umf_test::isAlignedAllocSupported(pool.get())) {
+        GTEST_SKIP();
+    }
 #ifdef __SANITIZE_ADDRESS__
-    // Sanitizer replaces malloc_usable_size implementation with its own
-    GTEST_SKIP()
-        << "This test is invalid with AddressSanitizer instrumentation";
-#else
+    if (pool_ops == &umf_test::MALLOC_POOL_OPS) {
+        // Sanitizer replaces malloc_usable_size implementation with its own
+        GTEST_SKIP()
+            << "This test is invalid with AddressSanitizer instrumentation";
+    }
+#endif
+    if (pool_ops == umfProxyPoolOps()) {
+        GTEST_SKIP() << "Proxy pool does not support umfPoolMallocUsableSize";
+    }
+    for (size_t allocSize :
+         {32, 64, 1 << 6, 1 << 10, 1 << 13, 1 << 16, 1 << 19}) {
+        for (size_t alignment : {0, 1 << 6, 1 << 8, 1 << 12}) {
+            if (alignment >= allocSize) {
+                continue;
+            }
+            void *ptr = nullptr;
+            if (alignment == 0) {
+                ptr = umfPoolMalloc(pool.get(), allocSize);
+            } else {
+                ptr = umfPoolAlignedMalloc(pool.get(), allocSize, alignment);
+            }
+            ASSERT_NE(ptr, nullptr);
+            size_t result = 0;
+            umf_result_t ret =
+                umfPoolMallocUsableSize(pool.get(), ptr, &result);
 
-    for (size_t allocSize : {32, 48, 1024, 8192}) {
-        char *ptr = static_cast<char *>(umfPoolMalloc(pool.get(), allocSize));
-        ASSERT_NE(ptr, nullptr);
-        size_t result = umfPoolMallocUsableSize(pool.get(), ptr);
-        ASSERT_TRUE(result == 0 || result >= allocSize);
+            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+            ASSERT_TRUE(result == 0 || result >= allocSize);
 
-        // Make sure we can write to this memory
-        for (size_t i = 0; i < result; i++) {
-            ptr[i] = 123;
+            // Make sure we can write to this memory
+            memset(ptr, 123, result);
+
+            umf_result_t umf_result = umfPoolFree(pool.get(), ptr);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
         }
+    }
+}
 
-        umfPoolFree(pool.get(), ptr);
+TEST_P(umfPoolTest, umfPoolAlignedMalloc) {
+#ifdef _WIN32
+    // TODO: implement support for windows
+    GTEST_SKIP() << "umfPoolAlignedMalloc() is not supported on Windows";
+#else  /* !_WIN32 */
+    umf_result_t umf_result;
+    void *ptr = nullptr;
+    const size_t size = 2 * 1024 * 1024; // 2MB
+
+    umf_memory_pool_handle_t pool_get = pool.get();
+
+    if (!umf_test::isAlignedAllocSupported(pool_get)) {
+        GTEST_SKIP();
     }
-#endif
+
+    ptr = umfPoolAlignedMalloc(pool_get, size, utils_get_page_size());
+    ASSERT_NE(ptr, nullptr);
+
+    umf_result = umfPoolFree(pool_get, ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+#endif /* !_WIN32 */
+}
+
+TEST_P(umfPoolTest, umfPoolGetName) {
+    umf_memory_pool_handle_t pool_get = pool.get();
+    const char *name = nullptr;
+    umf_result_t ret = umfPoolGetName(pool_get, &name);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(name, nullptr);
+    ASSERT_GT(strlen(name), (size_t)0);
+}
+
+TEST_P(umfPoolTest, pool_from_ptr_whole_size_success) {
+#ifdef _WIN32
+    // TODO: implement support for windows
+    GTEST_SKIP() << "umfPoolAlignedMalloc() is not supported on Windows";
+#else  /* !_WIN32 */
+    umf_result_t umf_result;
+    size_t size_of_pool_from_ptr;
+    void *ptr_for_pool = nullptr;
+    void *ptr = nullptr;
+
+    umf_memory_pool_handle_t pool_get = pool.get();
+    const size_t size_of_first_alloc = 2 * 1024 * 1024; // 2MB
+
+    if (!umf_test::isAlignedAllocSupported(pool_get)) {
+        GTEST_SKIP();
+    }
+
+    ptr_for_pool = umfPoolAlignedMalloc(pool_get, size_of_first_alloc,
+                                        utils_get_page_size());
+    ASSERT_NE(ptr_for_pool, nullptr);
+
+    // Create provider parameters
+    size_of_pool_from_ptr = size_of_first_alloc; // whole size
+    umf_fixed_memory_provider_params_handle_t params = nullptr;
+    umf_result = umfFixedMemoryProviderParamsCreate(
+        ptr_for_pool, size_of_pool_from_ptr, &params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(params, nullptr);
+
+    umf_memory_provider_handle_t providerFromPtr = nullptr;
+    umf_result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
+                                         &providerFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(providerFromPtr, nullptr);
+
+    umf_memory_pool_handle_t poolFromPtr = nullptr;
+    umf_result = umfPoolCreate(umfProxyPoolOps(), providerFromPtr, nullptr, 0,
+                               &poolFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ptr = umfPoolMalloc(poolFromPtr, size_of_pool_from_ptr);
+    ASSERT_NE(ptr, nullptr);
+
+    memset(ptr, 0xFF, size_of_pool_from_ptr);
+
+    umf_result = umfPoolFree(poolFromPtr, ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfPoolDestroy(poolFromPtr);
+    umfMemoryProviderDestroy(providerFromPtr);
+    umfFixedMemoryProviderParamsDestroy(params);
+
+    umf_result = umfPoolFree(pool_get, ptr_for_pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+#endif /* !_WIN32 */
+}
+
+TEST_P(umfPoolTest, pool_from_ptr_half_size_success) {
+#ifdef _WIN32
+    // TODO: implement support for windows
+    GTEST_SKIP() << "umfPoolAlignedMalloc() is not supported on Windows";
+#else  /* !_WIN32 */
+    umf_result_t umf_result;
+    size_t size_of_pool_from_ptr;
+    void *ptr_for_pool = nullptr;
+    void *ptr = nullptr;
+
+    umf_memory_pool_handle_t pool_get = pool.get();
+    const size_t size_of_first_alloc = 2 * 1024 * 1024; // 2MB
+
+    if (!umf_test::isAlignedAllocSupported(pool_get)) {
+        GTEST_SKIP();
+    }
+
+    ptr_for_pool = umfPoolAlignedMalloc(pool_get, size_of_first_alloc,
+                                        utils_get_page_size());
+    ASSERT_NE(ptr_for_pool, nullptr);
+
+    // Create provider parameters
+    size_of_pool_from_ptr = size_of_first_alloc / 2; // half size
+    umf_fixed_memory_provider_params_handle_t params = nullptr;
+    umf_result = umfFixedMemoryProviderParamsCreate(
+        ptr_for_pool, size_of_pool_from_ptr, &params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(params, nullptr);
+
+    umf_memory_provider_handle_t providerFromPtr = nullptr;
+    umf_result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
+                                         &providerFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(providerFromPtr, nullptr);
+
+    umf_memory_pool_handle_t poolFromPtr = nullptr;
+    umf_result = umfPoolCreate(umfProxyPoolOps(), providerFromPtr, nullptr, 0,
+                               &poolFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ptr = umfPoolMalloc(poolFromPtr, size_of_pool_from_ptr);
+    ASSERT_NE(ptr, nullptr);
+
+    memset(ptr, 0xFF, size_of_pool_from_ptr);
+
+    umf_result = umfPoolFree(poolFromPtr, ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfPoolDestroy(poolFromPtr);
+    umfMemoryProviderDestroy(providerFromPtr);
+    umfFixedMemoryProviderParamsDestroy(params);
+
+    umf_result = umfPoolFree(pool_get, ptr_for_pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+#endif /* !_WIN32 */
 }
 
+TEST_P(umfPoolTest, ctl_stat_alloc_count) {
+    umf_memory_pool_handle_t pool_get = pool.get();
+    const size_t size = 4096;
+    const size_t max_allocs = 10;
+    std::list<void *> ptrs;
+    size_t alloc_count = 0;
+    auto ret = umfCtlGet("umf.pool.by_handle.{}.stats.alloc_count",
+                         &alloc_count, sizeof(alloc_count), pool_get);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(alloc_count, 0ull);
+    for (size_t i = 1; i <= max_allocs; i++) {
+        void *ptr = umfPoolMalloc(pool_get, size);
+        ASSERT_NE(ptr, nullptr);
+        ret = umfCtlGet("umf.pool.by_handle.{}.stats.alloc_count", &alloc_count,
+                        sizeof(alloc_count), pool_get);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_EQ(alloc_count, i);
+        ptrs.push_back(ptr);
+    }
+
+    for (auto &ptr : ptrs) {
+        umf_result_t umf_result = umfPoolFree(pool_get, ptr);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+
+    ptrs.clear();
+    ret = umfCtlGet("umf.pool.by_handle.{}.stats.alloc_count", &alloc_count,
+                    sizeof(alloc_count), pool_get);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(alloc_count, 0ull);
+
+    if (umf_test::isReallocSupported(pool_get)) {
+        for (size_t i = 1; i <= max_allocs; i++) {
+            void *ptr;
+            if (i % 2 == 0) {
+                ptr = umfPoolMalloc(pool_get, size);
+            } else {
+                ptr = umfPoolRealloc(pool_get, nullptr, size);
+            }
+            ASSERT_NE(ptr, nullptr);
+            ret = umfCtlGet("umf.pool.by_handle.{}.stats.alloc_count",
+                            &alloc_count, sizeof(alloc_count), pool_get);
+            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+            ASSERT_EQ(alloc_count, i);
+            ptrs.push_back(ptr);
+        }
+        for (auto &ptr : ptrs) {
+            ptr = umfPoolRealloc(pool_get, ptr, size * 2);
+            ASSERT_NE(ptr, nullptr);
+        }
+        ret = umfCtlGet("umf.pool.by_handle.{}.stats.alloc_count", &alloc_count,
+                        sizeof(alloc_count), pool_get);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_EQ(alloc_count, max_allocs);
+        size_t allocs = ptrs.size();
+        for (auto &ptr : ptrs) {
+            if (allocs-- % 2 == 0) {
+                ptr = umfPoolRealloc(pool_get, ptr, 0);
+                ASSERT_EQ(ptr, nullptr);
+            } else {
+                ret = umfPoolFree(pool_get, ptr);
+                ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+            }
+        }
+        ptrs.clear();
+        ret = umfCtlGet("umf.pool.by_handle.{}.stats.alloc_count", &alloc_count,
+                        sizeof(alloc_count), pool_get);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_EQ(alloc_count, 0ull);
+    }
+
+    if (umf_test::isCallocSupported(pool_get)) {
+        for (size_t i = 1; i <= max_allocs; i++) {
+            void *ptr = umfPoolCalloc(pool_get, 1, size);
+            ASSERT_NE(ptr, nullptr);
+            ret = umfCtlGet("umf.pool.by_handle.{}.stats.alloc_count",
+                            &alloc_count, sizeof(alloc_count), pool_get);
+            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+            ASSERT_EQ(alloc_count, i);
+            ptrs.push_back(ptr);
+        }
+
+        for (auto &ptr : ptrs) {
+            umf_result_t umf_result = umfPoolFree(pool_get, ptr);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+        ptrs.clear();
+        ret = umfCtlGet("umf.pool.by_handle.{}.stats.alloc_count", &alloc_count,
+                        sizeof(alloc_count), pool_get);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_EQ(alloc_count, 0ull);
+    }
+
+    if (umf_test::isAlignedAllocSupported(pool_get)) {
+        for (size_t i = 1; i <= max_allocs; i++) {
+            void *ptr = umfPoolAlignedMalloc(pool_get, size, 4096);
+            ASSERT_NE(ptr, nullptr);
+            ret = umfCtlGet("umf.pool.by_handle.{}.stats.alloc_count",
+                            &alloc_count, sizeof(alloc_count), pool_get);
+            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+            ASSERT_EQ(alloc_count, i);
+            ptrs.push_back(ptr);
+        }
+
+        for (auto &ptr : ptrs) {
+            umf_result_t umf_result = umfPoolFree(pool_get, ptr);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+
+        ptrs.clear();
+        ret = umfCtlGet("umf.pool.by_handle.{}.stats.alloc_count", &alloc_count,
+                        sizeof(alloc_count), pool_get);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_EQ(alloc_count, 0ull);
+    }
+}
 #endif /* UMF_TEST_POOL_FIXTURES_HPP */
diff --git a/test/pools/disjoint_pool.cpp b/test/pools/disjoint_pool.cpp
index 319997c823..065b457de0 100644
--- a/test/pools/disjoint_pool.cpp
+++ b/test/pools/disjoint_pool.cpp
@@ -1,76 +1,169 @@
-// 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 <memory>
 
+#include <cstdarg>
+#include <umf/base.h>
+#include <umf/memory_pool.h>
+#include <umf/pools/pool_disjoint.h>
+
 #include "pool.hpp"
+#include "pool/pool_disjoint_internal.h"
 #include "poolFixtures.hpp"
-#include "pool_disjoint.h"
 #include "provider.hpp"
 #include "provider_null.h"
 #include "provider_trace.h"
+#include "umf/memory_provider.h"
 
-using disjoint_params_unique_handle_t =
-    std::unique_ptr<umf_disjoint_pool_params_t,
-                    decltype(&umfDisjointPoolParamsDestroy)>;
+using umf_test::test;
+using namespace umf_test;
 
-static constexpr size_t DEFAULT_DISJOINT_SLAB_MIN_SIZE = 4096;
-static constexpr size_t DEFAULT_DISJOINT_MAX_POOLABLE_SIZE = 4096;
-static constexpr size_t DEFAULT_DISJOINT_CAPACITY = 4;
-static constexpr size_t DEFAULT_DISJOINT_MIN_BUCKET_SIZE = 64;
+static void get_test_va_list(va_list *a, ...) { va_start(*a, a); }
 
-disjoint_params_unique_handle_t poolConfig() {
-    umf_disjoint_pool_params_handle_t config = nullptr;
-    umf_result_t res = umfDisjointPoolParamsCreate(&config);
-    if (res != UMF_RESULT_SUCCESS) {
-        throw std::runtime_error("Failed to create pool params");
-    }
-    res = umfDisjointPoolParamsSetSlabMinSize(config,
-                                              DEFAULT_DISJOINT_SLAB_MIN_SIZE);
-    if (res != UMF_RESULT_SUCCESS) {
-        throw std::runtime_error("Failed to set slab min size");
-    }
-    res = umfDisjointPoolParamsSetMaxPoolableSize(
-        config, DEFAULT_DISJOINT_MAX_POOLABLE_SIZE);
-    if (res != UMF_RESULT_SUCCESS) {
-        throw std::runtime_error("Failed to set max poolable size");
-    }
-    res = umfDisjointPoolParamsSetCapacity(config, DEFAULT_DISJOINT_CAPACITY);
-    if (res != UMF_RESULT_SUCCESS) {
-        throw std::runtime_error("Failed to set capacity");
-    }
-    res = umfDisjointPoolParamsSetMinBucketSize(
-        config, DEFAULT_DISJOINT_MIN_BUCKET_SIZE);
-    if (res != UMF_RESULT_SUCCESS) {
-        throw std::runtime_error("Failed to set min bucket size");
+TEST_F(test, internals) {
+    static umf_result_t expectedResult = UMF_RESULT_SUCCESS;
+    struct memory_provider : public umf_test::provider_base_t {
+        umf_result_t alloc(size_t size, size_t alignment, void **ptr) noexcept {
+            *ptr = umf_ba_global_aligned_alloc(size, alignment);
+            return UMF_RESULT_SUCCESS;
+        }
+
+        umf_result_t free(void *ptr, [[maybe_unused]] size_t size) noexcept {
+            // do the actual free only when we expect the success
+            if (expectedResult == UMF_RESULT_SUCCESS) {
+                umf_ba_global_free(ptr);
+            }
+            return expectedResult;
+        }
+
+        umf_result_t
+        get_min_page_size([[maybe_unused]] const void *ptr,
+                          [[maybe_unused]] size_t *pageSize) noexcept {
+            *pageSize = 1024;
+            return UMF_RESULT_SUCCESS;
+        }
+    };
+    umf_memory_provider_ops_t provider_ops =
+        umf_test::providerMakeCOps<memory_provider, void>();
+
+    auto providerUnique =
+        wrapProviderUnique(createProviderChecked(&provider_ops, nullptr));
+
+    umf_memory_provider_handle_t provider_handle;
+    provider_handle = providerUnique.get();
+
+    umf_disjoint_pool_params_handle_t params =
+        (umf_disjoint_pool_params_handle_t)defaultDisjointPoolConfig();
+    // set to maximum tracing
+    params->pool_trace = 3;
+    params->max_poolable_size = 1024 * 1024;
+
+    // in "internals" test we use ops interface to directly manipulate the pool
+    // structure
+    const umf_memory_pool_ops_t *ops = umfDisjointPoolOps();
+    EXPECT_NE(ops, nullptr);
+
+    disjoint_pool_t *pool;
+    umf_result_t res = ops->initialize(provider_handle, params, (void **)&pool);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+    va_list empty_args;
+    get_test_va_list(&empty_args);
+    res = ops->ext_ctl((void *)pool, CTL_QUERY_PROGRAMMATIC, "post_initialize",
+                       nullptr, 0, CTL_QUERY_RUNNABLE, empty_args);
+    va_end(empty_args);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+    EXPECT_NE(pool, nullptr);
+    EXPECT_EQ(pool->provider_min_page_size, (size_t)1024);
+
+    // check buckets sizes
+    size_t expected_size = DEFAULT_DISJOINT_MIN_BUCKET_SIZE;
+    EXPECT_EQ(pool->buckets[0]->size, expected_size);
+    EXPECT_EQ(pool->buckets[pool->buckets_num - 1]->size,
+              (size_t)1 << 31); // 2GB
+    for (size_t i = 0; i < pool->buckets_num; i++) {
+        bucket_t *bucket = pool->buckets[i];
+        EXPECT_NE(bucket, nullptr);
+        EXPECT_EQ(bucket->size, expected_size);
+
+        // assuming DEFAULT_DISJOINT_MIN_BUCKET_SIZE = 64, expected bucket
+        // sizes are: 64, 96, 128, 192, 256, ..., 2GB
+        if (i % 2 == 0) {
+            expected_size += expected_size / 2;
+        } else {
+            expected_size = DEFAULT_DISJOINT_MIN_BUCKET_SIZE << ((i + 1) / 2);
+        }
     }
 
-    return disjoint_params_unique_handle_t(config,
-                                           &umfDisjointPoolParamsDestroy);
+    // test small allocations
+    size_t size = 8;
+    void *ptr = ops->malloc(pool, size);
+    EXPECT_NE(ptr, nullptr);
+
+    // get bucket - because of small size this should be the first bucket in
+    // the pool
+    bucket_t *bucket = pool->buckets[0];
+    EXPECT_NE(bucket, nullptr);
+
+    // check bucket stats
+    EXPECT_EQ(bucket->alloc_count, (size_t)1);
+
+    // first allocation will always use external memory (newly added to the
+    // pool) and this is counted as allocation from the outside of the pool
+    EXPECT_EQ(bucket->alloc_pool_count, (size_t)0);
+    EXPECT_EQ(bucket->curr_slabs_in_use, (size_t)1);
+
+    // check slab - there should be only single slab allocated
+    EXPECT_NE(bucket->available_slabs, nullptr);
+    EXPECT_EQ(bucket->available_slabs_num, (size_t)1);
+    EXPECT_EQ(bucket->available_slabs->next, nullptr);
+    slab_t *slab = bucket->available_slabs->val;
+
+    // check slab stats
+    EXPECT_GE(slab->slab_size, params->slab_min_size);
+    EXPECT_GE(slab->num_chunks_total, slab->slab_size / bucket->size);
+
+    // check allocation in slab
+    EXPECT_EQ(slab_read_chunk_bit(slab, 0), false);
+    EXPECT_EQ(slab_read_chunk_bit(slab, 1), true);
+
+    // TODO:
+    // * multiple alloc + free from single bucket
+    // * alignments
+    // * full slab alloc
+    // * slab overflow
+    // * chunked slabs
+    // * multiple alloc + free from different buckets
+    // * alloc something outside pool (> MaxPoolableSize)
+    // * test capacity
+    // * check minBucketSize
+    // * test large objects
+    // * check available_slabs_num
+
+    // cleanup
+    ops->finalize(pool);
+    umfDisjointPoolParamsDestroy(params);
 }
 
-using umf_test::test;
-using namespace umf_test;
-
 TEST_F(test, freeErrorPropagation) {
     static umf_result_t expectedResult = UMF_RESULT_SUCCESS;
     struct memory_provider : public umf_test::provider_base_t {
-        umf_result_t alloc(size_t size, size_t, void **ptr) noexcept {
-            *ptr = malloc(size);
+        umf_result_t alloc(size_t size, size_t alignment, void **ptr) noexcept {
+            *ptr = umf_ba_global_aligned_alloc(size, alignment);
             return UMF_RESULT_SUCCESS;
         }
 
         umf_result_t free(void *ptr, [[maybe_unused]] size_t size) noexcept {
             // do the actual free only when we expect the success
             if (expectedResult == UMF_RESULT_SUCCESS) {
-                ::free(ptr);
+                umf_ba_global_free(ptr);
             }
             return expectedResult;
         }
     };
     umf_memory_provider_ops_t provider_ops =
-        umf::providerMakeCOps<memory_provider, void>();
+        umf_test::providerMakeCOps<memory_provider, void>();
 
     auto providerUnique =
         wrapProviderUnique(createProviderChecked(&provider_ops, nullptr));
@@ -79,17 +172,21 @@ TEST_F(test, freeErrorPropagation) {
     provider_handle = providerUnique.get();
 
     // force all allocations to go to memory provider
-    disjoint_params_unique_handle_t params = poolConfig();
-    umf_result_t retp =
-        umfDisjointPoolParamsSetMaxPoolableSize(params.get(), 0);
+    umf_disjoint_pool_params_handle_t params;
+    umf_result_t retp = umfDisjointPoolParamsCreate(&params);
+    EXPECT_EQ(retp, UMF_RESULT_SUCCESS);
+    retp = umfDisjointPoolParamsSetMaxPoolableSize(params, 0);
     EXPECT_EQ(retp, UMF_RESULT_SUCCESS);
 
     umf_memory_pool_handle_t pool = NULL;
-    retp = umfPoolCreate(umfDisjointPoolOps(), provider_handle, params.get(), 0,
-                         &pool);
+    retp =
+        umfPoolCreate(umfDisjointPoolOps(), provider_handle, params, 0, &pool);
     EXPECT_EQ(retp, UMF_RESULT_SUCCESS);
     auto poolHandle = umf_test::wrapPoolUnique(pool);
 
+    retp = umfDisjointPoolParamsDestroy(params);
+    EXPECT_EQ(retp, UMF_RESULT_SUCCESS);
+
     static constexpr size_t size = 1024;
     void *ptr = umfPoolMalloc(pool, size);
 
@@ -109,35 +206,38 @@ TEST_F(test, sharedLimits) {
     static size_t numFrees = 0;
 
     struct memory_provider : public umf_test::provider_base_t {
-        umf_result_t alloc(size_t size, size_t, void **ptr) noexcept {
-            *ptr = malloc(size);
+        umf_result_t alloc(size_t size, size_t alignment, void **ptr) noexcept {
+            *ptr = umf_ba_global_aligned_alloc(size, alignment);
             numAllocs++;
             return UMF_RESULT_SUCCESS;
         }
         umf_result_t free(void *ptr, [[maybe_unused]] size_t size) noexcept {
-            ::free(ptr);
+            umf_ba_global_free(ptr);
             numFrees++;
             return UMF_RESULT_SUCCESS;
         }
     };
     umf_memory_provider_ops_t provider_ops =
-        umf::providerMakeCOps<memory_provider, void>();
+        umf_test::providerMakeCOps<memory_provider, void>();
 
     static constexpr size_t SlabMinSize = 1024;
     static constexpr size_t MaxSize = 4 * SlabMinSize;
 
-    disjoint_params_unique_handle_t config = poolConfig();
-    umf_result_t ret =
-        umfDisjointPoolParamsSetSlabMinSize(config.get(), SlabMinSize);
+    umf_disjoint_pool_params_handle_t params =
+        (umf_disjoint_pool_params_handle_t)defaultDisjointPoolConfig();
+    umf_result_t ret = umfDisjointPoolParamsSetSlabMinSize(params, SlabMinSize);
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
+    umf_disjoint_pool_shared_limits_handle_t hLimits = nullptr;
+    ret = umfDisjointPoolSharedLimitsCreate(MaxSize, &hLimits);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    EXPECT_NE(hLimits, nullptr);
     auto limits =
         std::unique_ptr<umf_disjoint_pool_shared_limits_t,
                         decltype(&umfDisjointPoolSharedLimitsDestroy)>(
-            umfDisjointPoolSharedLimitsCreate(MaxSize),
-            &umfDisjointPoolSharedLimitsDestroy);
+            hLimits, &umfDisjointPoolSharedLimitsDestroy);
 
-    ret = umfDisjointPoolParamsSetSharedLimits(config.get(), limits.get());
+    ret = umfDisjointPoolParamsSetSharedLimits(params, limits.get());
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
     auto provider =
@@ -145,18 +245,21 @@ TEST_F(test, sharedLimits) {
 
     umf_memory_pool_handle_t pool1 = NULL;
     umf_memory_pool_handle_t pool2 = NULL;
-    ret = umfPoolCreate(umfDisjointPoolOps(), provider.get(),
-                        (void *)config.get(), 0, &pool1);
+    ret =
+        umfPoolCreate(umfDisjointPoolOps(), provider.get(), params, 0, &pool1);
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
     auto poolHandle1 = umf_test::wrapPoolUnique(pool1);
 
-    ret = umfPoolCreate(umfDisjointPoolOps(), provider.get(),
-                        (void *)config.get(), 0, &pool2);
+    ret =
+        umfPoolCreate(umfDisjointPoolOps(), provider.get(), params, 0, &pool2);
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
     auto poolHandle2 = umf_test::wrapPoolUnique(pool2);
 
-    EXPECT_EQ(0, numAllocs);
-    EXPECT_EQ(0, numFrees);
+    ret = umfDisjointPoolParamsDestroy(params);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    EXPECT_EQ((size_t)0, numAllocs);
+    EXPECT_EQ((size_t)0, numFrees);
 
     std::vector<std::unique_ptr<void, decltype(&umfFree)>> ptrs;
     for (size_t i = 0; i < MaxSize / SlabMinSize; i++) {
@@ -165,7 +268,7 @@ TEST_F(test, sharedLimits) {
     }
 
     EXPECT_EQ(MaxSize / SlabMinSize * 2, numAllocs);
-    EXPECT_EQ(0, numFrees);
+    EXPECT_EQ((size_t)0, numFrees);
 
     ptrs.clear();
 
@@ -181,6 +284,97 @@ TEST_F(test, sharedLimits) {
     EXPECT_EQ(MaxSize / SlabMinSize * 2, numFrees);
 }
 
+TEST_F(test, disjointPoolTrim) {
+    struct memory_provider : public umf_test::provider_base_t {
+        umf_result_t alloc(size_t size, size_t alignment, void **ptr) noexcept {
+            *ptr = umf_ba_global_aligned_alloc(size, alignment);
+            return UMF_RESULT_SUCCESS;
+        }
+
+        umf_result_t free(void *ptr, size_t) noexcept {
+            umf_ba_global_free(ptr);
+            return UMF_RESULT_SUCCESS;
+        }
+    };
+
+    umf_memory_provider_ops_t provider_ops =
+        umf_test::providerMakeCOps<memory_provider, void>();
+
+    auto providerUnique =
+        wrapProviderUnique(createProviderChecked(&provider_ops, nullptr));
+
+    umf_memory_provider_handle_t provider_handle;
+    provider_handle = providerUnique.get();
+
+    umf_disjoint_pool_params_handle_t params =
+        (umf_disjoint_pool_params_handle_t)defaultDisjointPoolConfig();
+    params->pool_trace = 3;
+    // Set the slab min size to 64 so allocating 64 bytes will use the whole
+    // slab.
+    params->slab_min_size = 64;
+    params->capacity = 4;
+
+    // in "internals" test we use ops interface to directly manipulate the pool
+    // structure
+    const umf_memory_pool_ops_t *ops = umfDisjointPoolOps();
+    EXPECT_NE(ops, nullptr);
+
+    disjoint_pool_t *pool;
+    umf_result_t res = ops->initialize(provider_handle, params, (void **)&pool);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+    EXPECT_NE(pool, nullptr);
+
+    va_list empty_args;
+    get_test_va_list(&empty_args);
+    res = ops->ext_ctl((void *)pool, CTL_QUERY_PROGRAMMATIC, "post_initialize",
+                       nullptr, 0, CTL_QUERY_RUNNABLE, empty_args);
+    va_end(empty_args);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+
+    // do 4 allocs, then free all of them
+    size_t size = 64;
+    void *ptrs[4] = {0};
+    ptrs[0] = ops->malloc(pool, size);
+    EXPECT_NE(ptrs[0], nullptr);
+    ptrs[1] = ops->malloc(pool, size);
+    EXPECT_NE(ptrs[1], nullptr);
+    ptrs[2] = ops->malloc(pool, size);
+    EXPECT_NE(ptrs[2], nullptr);
+    ptrs[3] = ops->malloc(pool, size);
+    EXPECT_NE(ptrs[3], nullptr);
+
+    ops->free(pool, ptrs[0]);
+    ops->free(pool, ptrs[1]);
+    ops->free(pool, ptrs[2]);
+    ops->free(pool, ptrs[3]);
+
+    // Because we set the slab min size to 64, each allocation should go to the
+    // separate slab. Additionally, because we set the capacity to 4, all slabs
+    // should still be in the pool available for new allocations.
+    EXPECT_EQ(pool->buckets[0]->available_slabs_num, (size_t)4);
+    EXPECT_EQ(pool->buckets[0]->curr_slabs_in_use, (size_t)0);
+    EXPECT_EQ(pool->buckets[0]->curr_slabs_in_pool, (size_t)4);
+
+    // Trim memory - leave 3 slabs in the pool
+    ops->ext_trim_memory(pool, 3 * pool->buckets[0]->size);
+    EXPECT_EQ(pool->buckets[0]->available_slabs_num, (size_t)3);
+    EXPECT_EQ(pool->buckets[0]->curr_slabs_in_use, (size_t)0);
+
+    // Trim memory again - leave 1 slab in the pool
+    ops->ext_trim_memory(pool, pool->buckets[0]->size);
+    EXPECT_EQ(pool->buckets[0]->available_slabs_num, (size_t)1);
+    EXPECT_EQ(pool->buckets[0]->curr_slabs_in_use, (size_t)0);
+
+    // Trim the rest of memory
+    ops->ext_trim_memory(pool, 0);
+    EXPECT_EQ(pool->buckets[0]->available_slabs_num, (size_t)0);
+    EXPECT_EQ(pool->buckets[0]->curr_slabs_in_pool, (size_t)0);
+
+    ops->finalize(pool);
+    res = umfDisjointPoolParamsDestroy(params);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+}
+
 TEST_F(test, disjointPoolNullParams) {
     umf_result_t res = umfDisjointPoolParamsCreate(nullptr);
     EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
@@ -239,24 +433,219 @@ TEST_F(test, disjointPoolInvalidBucketSize) {
     umfDisjointPoolParamsDestroy(params);
 }
 
-disjoint_params_unique_handle_t defaultPoolConfig = poolConfig();
+TEST_F(test, disjointPoolName) {
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    umf_result_t res = umfDisjointPoolParamsCreate(&params);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+    umf_memory_pool_handle_t pool = NULL;
+
+    auto nullProvider = nullProviderCreate();
+
+    res = umfPoolCreate(umfDisjointPoolOps(), nullProvider, params, 0, &pool);
+
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+    const char *name = nullptr;
+    res = umfPoolGetName(pool, &name);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, "disjoint");
+
+    umfPoolDestroy(pool);
+    umfMemoryProviderDestroy(nullProvider);
+    umfDisjointPoolParamsDestroy(params);
+}
+
+TEST_F(test, disjointPoolCustomName) {
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    umf_result_t res = umfDisjointPoolParamsCreate(&params);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfDisjointPoolParamsSetName(params, "my_disjoint");
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+
+    struct memory_provider : public umf_test::provider_base_t {};
+
+    auto nullProvider = nullProviderCreate();
+    umf_memory_pool_handle_t pool = NULL;
+
+    res = umfPoolCreate(umfDisjointPoolOps(), nullProvider, params, 0, &pool);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+
+    const char *name = nullptr;
+    res = umfPoolGetName(pool, &name);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, "my_disjoint");
+
+    umfPoolDestroy(pool);
+    umfMemoryProviderDestroy(nullProvider);
+    umfDisjointPoolParamsDestroy(params);
+}
+
+TEST(DisjointPoolOps, default_name_null_handle) {
+    const char *name = nullptr;
+    EXPECT_EQ(umfDisjointPoolOps()->get_name(nullptr, &name),
+              UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, "disjoint");
+}
+
+TEST_F(test, disjointPoolDefaultParams) {
+    // Disjoint pool defaults
+    static constexpr size_t DefaultSlabMinSize = 64 * 1024;           // 64K
+    static constexpr size_t DefaultMaxPoolableSize = 2 * 1024 * 1024; // 2MB
+
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    umf_memory_pool_handle_t pool = nullptr;
+    umf_memory_provider_handle_t provider_handle = nullptr;
+
+    // Create disjoint pool parameters with default settings
+    umf_result_t res = umfDisjointPoolParamsCreate(&params);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+
+    size_t expected_free_counter = 0;
+    static size_t free_counter = 0;
+    static size_t last_requested_size = 0;
+    struct memory_provider : public umf_test::provider_base_t {
+        umf_result_t alloc(size_t size, size_t alignment, void **ptr) noexcept {
+            *ptr = umf_ba_global_aligned_alloc(size, alignment);
+            last_requested_size = size;
+            return UMF_RESULT_SUCCESS;
+        }
+
+        umf_result_t free(void *ptr, [[maybe_unused]] size_t size) noexcept {
+            // do the actual free only when we expect the success
+            umf_ba_global_free(ptr);
+            free_counter++;
+            return UMF_RESULT_SUCCESS;
+        }
+    };
+
+    umf_memory_provider_ops_t provider_ops =
+        umf_test::providerMakeCOps<memory_provider, void>();
+
+    auto providerUnique =
+        wrapProviderUnique(createProviderChecked(&provider_ops, nullptr));
+    provider_handle = providerUnique.get();
+
+    res = umfDisjointPoolParamsSetTrace(params, 3);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    umf_result_t ret = umfPoolCreate(umfDisjointPoolOps(), provider_handle,
+                                     params, UMF_POOL_CREATE_FLAG_NONE, &pool);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    // Test allocation and deallocation
+    // This will use the default disjoint pool parameters
+    void *ptr = umfPoolMalloc(pool, DefaultSlabMinSize - 1); // Should use pool
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(
+        last_requested_size,
+        DefaultSlabMinSize); // First allocated size should be at least the slab min size
+    ret = umfPoolFree(pool, ptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(free_counter, expected_free_counter);
+
+    // Test allocation and deallocation with a different size
+    expected_free_counter = 1;
+    ptr =
+        umfPoolMalloc(pool, DefaultMaxPoolableSize + 1); // Fallback to provider
+    ASSERT_EQ(last_requested_size, DefaultMaxPoolableSize + 1);
+    ASSERT_NE(ptr, nullptr);
+    ret = umfPoolFree(pool, ptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(free_counter, expected_free_counter);
+
+    // Cleaning up
+    umfPoolDestroy(pool);
+    umfDisjointPoolParamsDestroy(params);
+    expected_free_counter = 2;
+    ASSERT_EQ(free_counter, expected_free_counter);
+}
+
+TEST_F(test, disjointPoolDefaultCapacity) {
+    // Disjoint pool defaults
+    static constexpr size_t DefaultSlabMinSize = 64 * 1024; // 64K
+    static constexpr size_t DefaultCapacity = 4;
+
+    static size_t free_counter = 0;
+    static size_t last_requested_size = 0;
+
+    struct memory_provider : public umf_test::provider_base_t {
+        umf_result_t alloc(size_t size, size_t alignment, void **ptr) noexcept {
+            *ptr = umf_ba_global_aligned_alloc(size, alignment);
+            last_requested_size = size;
+            return UMF_RESULT_SUCCESS;
+        }
+        umf_result_t free(void *ptr, [[maybe_unused]] size_t size) noexcept {
+            // do the actual free only when we expect the success
+            umf_ba_global_free(ptr);
+            free_counter++;
+            return UMF_RESULT_SUCCESS;
+        }
+    };
+    umf_memory_provider_ops_t provider_ops =
+        umf_test::providerMakeCOps<memory_provider, void>();
+    auto providerUnique =
+        wrapProviderUnique(createProviderChecked(&provider_ops, nullptr));
+    umf_memory_provider_handle_t provider_handle = providerUnique.get();
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    umf_result_t ret = umfDisjointPoolParamsCreate(&params);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    umf_memory_pool_handle_t pool = nullptr;
+    ret = umfPoolCreate(umfDisjointPoolOps(), provider_handle, params,
+                        UMF_POOL_CREATE_FLAG_NONE, &pool);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    // Test capacity
+    void *ptrs[DefaultCapacity + 1];
+    for (size_t i = 0; i < DefaultCapacity + 1; ++i) {
+        ptrs[i] =
+            umfPoolMalloc(pool, DefaultSlabMinSize - 1); // Should use pool
+        ASSERT_NE(ptrs[i], nullptr);
+        ASSERT_EQ(last_requested_size, DefaultSlabMinSize);
+    }
+
+    size_t i;
+    for (i = 0; i < DefaultCapacity + 1; ++i) {
+        ret = umfPoolFree(pool, ptrs[i]);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    }
+    ASSERT_EQ(
+        free_counter,
+        i - DefaultCapacity); // only the last allocation exceeds the capacity
+
+    // Cleaning up
+    umfPoolDestroy(pool);
+    umfDisjointPoolParamsDestroy(params);
+    ASSERT_EQ(free_counter,
+              DefaultCapacity +
+                  1); // +1 for the last allocation that exceeded the capacity
+}
+
 INSTANTIATE_TEST_SUITE_P(disjointPoolTests, umfPoolTest,
                          ::testing::Values(poolCreateExtParams{
-                             umfDisjointPoolOps(),
-                             (void *)defaultPoolConfig.get(),
-                             &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}));
-
-INSTANTIATE_TEST_SUITE_P(disjointPoolTests, umfMemTest,
-                         ::testing::Values(std::make_tuple(
-                             poolCreateExtParams{
-                                 umfDisjointPoolOps(),
-                                 (void *)defaultPoolConfig.get(),
-                                 &MOCK_OUT_OF_MEM_PROVIDER_OPS,
-                                 (void *)&DEFAULT_DISJOINT_CAPACITY, nullptr},
-                             static_cast<int>(DEFAULT_DISJOINT_CAPACITY) / 2)));
+                             umfDisjointPoolOps(), defaultDisjointPoolConfig,
+                             defaultDisjointPoolConfigDestroy,
+                             &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}),
+                         poolCreateExtParamsNameGen);
+
+void *memProviderParams() { return (void *)&DEFAULT_DISJOINT_CAPACITY; }
+
+INSTANTIATE_TEST_SUITE_P(
+    disjointPoolTests, umfMemTest,
+    ::testing::Values(std::make_tuple(
+        poolCreateExtParams{umfDisjointPoolOps(), defaultDisjointPoolConfig,
+                            defaultDisjointPoolConfigDestroy,
+                            &MOCK_OUT_OF_MEM_PROVIDER_OPS, memProviderParams,
+                            nullptr},
+        static_cast<int>(DEFAULT_DISJOINT_CAPACITY) / 2)),
+    ([](auto) {
+        return std::string("disjoint_out_of_mem_capacity_") +
+               std::to_string(static_cast<int>(DEFAULT_DISJOINT_CAPACITY) / 2);
+    }));
 
 INSTANTIATE_TEST_SUITE_P(disjointMultiPoolTests, umfMultiPoolTest,
                          ::testing::Values(poolCreateExtParams{
-                             umfDisjointPoolOps(),
-                             (void *)defaultPoolConfig.get(),
-                             &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}));
+                             umfDisjointPoolOps(), defaultDisjointPoolConfig,
+                             defaultDisjointPoolConfigDestroy,
+                             &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}),
+                         poolCreateExtParamsNameGen);
diff --git a/test/pools/disjoint_pool_ctl.cpp b/test/pools/disjoint_pool_ctl.cpp
new file mode 100644
index 0000000000..31bc975e3d
--- /dev/null
+++ b/test/pools/disjoint_pool_ctl.cpp
@@ -0,0 +1,999 @@
+// 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-exceptiongi
+
+#include <gtest/gtest.h>
+#include <umf.h>
+#include <umf/experimental/ctl.h>
+#include <umf/memory_pool.h>
+#include <umf/memory_provider.h>
+#include <umf/memory_provider_ops.h>
+#include <umf/pools/pool_disjoint.h>
+#include <umf/providers/provider_os_memory.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base.hpp"
+#include "common/fork_helpers.hpp"
+#include "ctl/ctl_internal.h"
+#include "utils_assert.h"
+#include "utils_log.h"
+
+using umf_test::test;
+using namespace umf_test;
+
+#define ASSERT_SUCCESS(ret) ASSERT_EQ(ret, UMF_RESULT_SUCCESS)
+
+// Encapsulating class for pool creation and destruction
+class PoolWrapper {
+  public:
+    PoolWrapper(umf_memory_provider_handle_t provider,
+                const umf_memory_pool_ops_t *poolOps,
+                umf_disjoint_pool_params_handle_t params = nullptr)
+        : m_pool(nullptr), m_provider(provider), m_poolOps(poolOps),
+          m_params(params) {
+        auto res = umfPoolCreate(m_poolOps, m_provider, m_params, 0, &m_pool);
+        if (res != UMF_RESULT_SUCCESS) {
+            m_pool = nullptr;
+        }
+    }
+
+    ~PoolWrapper() {
+        if (m_pool) {
+            umfPoolDestroy(m_pool);
+        }
+    }
+
+    umf_memory_pool_handle_t get() const { return m_pool; }
+
+    // Disallow copy and move
+    PoolWrapper(const PoolWrapper &) = delete;
+    PoolWrapper &operator=(const PoolWrapper &) = delete;
+    PoolWrapper(PoolWrapper &&) = delete;
+    PoolWrapper &operator=(PoolWrapper &&) = delete;
+
+  private:
+    umf_memory_pool_handle_t m_pool;
+    umf_memory_provider_handle_t m_provider;
+    const umf_memory_pool_ops_t *m_poolOps;
+    umf_disjoint_pool_params_handle_t m_params;
+};
+
+// Encapsulating class for provider creation and destruction
+class ProviderWrapper {
+  public:
+    ProviderWrapper(const umf_memory_provider_ops_t *providerOps,
+                    void *params = nullptr)
+        : m_provider(nullptr), m_providerOps(providerOps), m_params(params) {
+        auto res =
+            umfMemoryProviderCreate(m_providerOps, m_params, &m_provider);
+        if (res != UMF_RESULT_SUCCESS) {
+            m_provider = nullptr;
+        }
+    }
+
+    ~ProviderWrapper() {
+        if (m_provider) {
+            umfMemoryProviderDestroy(m_provider);
+        }
+    }
+
+    umf_memory_provider_handle_t get() const { return m_provider; }
+
+    // Disallow copy and move
+    ProviderWrapper(const ProviderWrapper &) = delete;
+    ProviderWrapper &operator=(const ProviderWrapper &) = delete;
+    ProviderWrapper(ProviderWrapper &&) = delete;
+    ProviderWrapper &operator=(ProviderWrapper &&) = delete;
+
+  private:
+    umf_memory_provider_handle_t m_provider;
+    const umf_memory_provider_ops_t *m_providerOps;
+    void *m_params;
+};
+
+TEST_F(test, disjointCtlUsedMemory) {
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+    if (UMF_RESULT_ERROR_NOT_SUPPORTED ==
+        umfOsMemoryProviderParamsCreate(&os_memory_provider_params)) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    ProviderWrapper providerWrapper(umfOsMemoryProviderOps(),
+                                    os_memory_provider_params);
+    if (providerWrapper.get() == NULL) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    ASSERT_SUCCESS(umfDisjointPoolParamsCreate(&params));
+
+    const size_t slab_min_size = 64 * 1024;
+    umfDisjointPoolParamsSetMinBucketSize(params, slab_min_size);
+
+    PoolWrapper poolWrapper(providerWrapper.get(), umfDisjointPoolOps(),
+                            params);
+
+    // Initially, used memory should be 0
+    size_t used_memory = 0;
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.stats.used_memory",
+                             &used_memory, sizeof(used_memory),
+                             poolWrapper.get()));
+    ASSERT_EQ(used_memory, 0ull);
+
+    // Allocate some memory
+    void *ptr1 = umfPoolMalloc(poolWrapper.get(), 1024ull);
+    ASSERT_NE(ptr1, nullptr);
+
+    // Check that used memory increased
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.stats.used_memory",
+                             &used_memory, sizeof(used_memory),
+                             poolWrapper.get()));
+    ASSERT_GE(used_memory, 1024ull);
+
+    // Allocate more memory
+    void *ptr2 = umfPoolMalloc(poolWrapper.get(), 2048ull);
+    ASSERT_NE(ptr2, nullptr);
+
+    size_t used_memory2 = 0;
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.stats.used_memory",
+                             &used_memory2, sizeof(used_memory2),
+                             poolWrapper.get()));
+    ASSERT_GE(used_memory2, used_memory + 2048ull);
+
+    // Free memory
+    ASSERT_SUCCESS(umfPoolFree(poolWrapper.get(), ptr1));
+    ASSERT_SUCCESS(umfPoolFree(poolWrapper.get(), ptr2));
+
+    // Check that used memory is equal to 0
+    size_t used_memory3 = 0;
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.stats.used_memory",
+                             &used_memory3, sizeof(used_memory3),
+                             poolWrapper.get()));
+    ASSERT_EQ(used_memory3, 0ull);
+
+    // Allocate again at least slab_min_size
+    void *ptr3 = umfPoolMalloc(poolWrapper.get(), slab_min_size);
+    ASSERT_NE(ptr3, nullptr);
+
+    // Check that used memory increased
+    size_t used_memory4 = 0;
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.stats.used_memory",
+                             &used_memory4, sizeof(used_memory4),
+                             poolWrapper.get()));
+    ASSERT_EQ(used_memory4, slab_min_size);
+
+    // Clean up
+    ASSERT_SUCCESS(umfDisjointPoolParamsDestroy(params));
+    ASSERT_SUCCESS(umfOsMemoryProviderParamsDestroy(os_memory_provider_params));
+}
+
+TEST_F(test, disjointCtlReservedMemory) {
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+    const size_t slab_min_size = 64 * 1024;
+
+    if (UMF_RESULT_ERROR_NOT_SUPPORTED ==
+        umfOsMemoryProviderParamsCreate(&os_memory_provider_params)) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    ProviderWrapper providerWrapper(umfOsMemoryProviderOps(),
+                                    os_memory_provider_params);
+    if (providerWrapper.get() == NULL) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    ASSERT_SUCCESS(umfDisjointPoolParamsCreate(&params));
+
+    // Set minimum slab size
+    umfDisjointPoolParamsSetSlabMinSize(params, slab_min_size);
+
+    PoolWrapper poolWrapper(providerWrapper.get(), umfDisjointPoolOps(),
+                            params);
+
+    // Initially, reserved memory should be 0
+    size_t reserved_memory = 0;
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.stats.reserved_memory",
+                             &reserved_memory, sizeof(reserved_memory),
+                             poolWrapper.get()));
+    ASSERT_EQ(reserved_memory, 0ull);
+
+    // Allocate some memory
+    void *ptr1 = umfPoolMalloc(poolWrapper.get(), 1024ull);
+    ASSERT_NE(ptr1, nullptr);
+
+    // Check that reserved memory increased (should be at least slab_min_size)
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.stats.reserved_memory",
+                             &reserved_memory, sizeof(reserved_memory),
+                             poolWrapper.get()));
+    ASSERT_GE(reserved_memory, slab_min_size);
+
+    void *ptr2 = umfPoolMalloc(poolWrapper.get(), 1024ull);
+    ASSERT_NE(ptr2, nullptr);
+
+    size_t reserved_memory2 = 0;
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.stats.reserved_memory",
+                             &reserved_memory2, sizeof(reserved_memory2),
+                             poolWrapper.get()));
+    size_t used_memory = 0;
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.stats.used_memory",
+                             &used_memory, sizeof(used_memory),
+                             poolWrapper.get()));
+
+    ASSERT_GE(reserved_memory2, slab_min_size);
+
+    // Free memory - reserved memory should stay the same
+    ASSERT_SUCCESS(umfPoolFree(poolWrapper.get(), ptr1));
+    ASSERT_SUCCESS(umfPoolFree(poolWrapper.get(), ptr2));
+
+    size_t reserved_memory3 = 0;
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.stats.reserved_memory",
+                             &reserved_memory3, sizeof(reserved_memory3),
+                             poolWrapper.get()));
+    ASSERT_EQ(reserved_memory3, slab_min_size);
+
+    // Clean up
+    ASSERT_SUCCESS(umfDisjointPoolParamsDestroy(params));
+    ASSERT_SUCCESS(umfOsMemoryProviderParamsDestroy(os_memory_provider_params));
+}
+
+TEST_F(test, disjointCtlGetParams) {
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+    if (UMF_RESULT_ERROR_NOT_SUPPORTED ==
+        umfOsMemoryProviderParamsCreate(&os_memory_provider_params)) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    ProviderWrapper providerWrapper(umfOsMemoryProviderOps(),
+                                    os_memory_provider_params);
+    if (providerWrapper.get() == NULL) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    ASSERT_SUCCESS(umfDisjointPoolParamsCreate(&params));
+
+    const size_t slab_min_size = 32 * 1024;
+    const size_t max_poolable_size = 512 * 1024;
+    const size_t capacity = 7;
+    const size_t min_bucket_size = 16;
+    const int pool_trace = 1;
+
+    ASSERT_SUCCESS(umfDisjointPoolParamsSetSlabMinSize(params, slab_min_size));
+    ASSERT_SUCCESS(
+        umfDisjointPoolParamsSetMaxPoolableSize(params, max_poolable_size));
+    ASSERT_SUCCESS(umfDisjointPoolParamsSetCapacity(params, capacity));
+    ASSERT_SUCCESS(
+        umfDisjointPoolParamsSetMinBucketSize(params, min_bucket_size));
+    ASSERT_SUCCESS(umfDisjointPoolParamsSetTrace(params, pool_trace));
+
+    PoolWrapper poolWrapper(providerWrapper.get(), umfDisjointPoolOps(),
+                            params);
+
+    size_t got_size = 0;
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.params.slab_min_size",
+                             &got_size, sizeof(got_size), poolWrapper.get()));
+    EXPECT_EQ(got_size, slab_min_size);
+
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.params.max_poolable_size",
+                             &got_size, sizeof(got_size), poolWrapper.get()));
+    EXPECT_EQ(got_size, max_poolable_size);
+
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.params.capacity", &got_size,
+                             sizeof(got_size), poolWrapper.get()));
+    EXPECT_EQ(got_size, capacity);
+
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.params.min_bucket_size",
+                             &got_size, sizeof(got_size), poolWrapper.get()));
+    EXPECT_EQ(got_size, min_bucket_size);
+
+    int got_trace = 0;
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.params.pool_trace",
+                             &got_trace, sizeof(got_trace), poolWrapper.get()));
+    EXPECT_EQ(got_trace, pool_trace);
+
+    ASSERT_SUCCESS(umfDisjointPoolParamsDestroy(params));
+    ASSERT_SUCCESS(umfOsMemoryProviderParamsDestroy(os_memory_provider_params));
+}
+
+TEST_F(test, disjointCtlDefaultsOverride) {
+    umf_test::run_in_fork([] {
+        umf_os_memory_provider_params_handle_t raw_os_params = nullptr;
+        umf_result_t res = umfOsMemoryProviderParamsCreate(&raw_os_params);
+        if (res == UMF_RESULT_ERROR_NOT_SUPPORTED) {
+            GTEST_SKIP() << "OS memory provider is not supported!";
+        }
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+        std::unique_ptr<umf_os_memory_provider_params_t,
+                        decltype(&umfOsMemoryProviderParamsDestroy)>
+            os_params(raw_os_params, &umfOsMemoryProviderParamsDestroy);
+
+        ProviderWrapper providerWrapper(umfOsMemoryProviderOps(),
+                                        os_params.get());
+        if (providerWrapper.get() == nullptr) {
+            GTEST_SKIP() << "OS memory provider is not supported!";
+        }
+
+        size_t default_capacity = 4;
+        size_t default_min_bucket = 8;
+        ASSERT_EQ(umfCtlSet("umf.pool.default.disjoint.params.capacity",
+                            &default_capacity, sizeof(default_capacity)),
+                  UMF_RESULT_SUCCESS);
+        ASSERT_EQ(umfCtlSet("umf.pool.default.disjoint.params.min_bucket_size",
+                            &default_min_bucket, sizeof(default_min_bucket)),
+                  UMF_RESULT_SUCCESS);
+
+        size_t override_capacity = 2;
+        size_t override_min_bucket = 32;
+        ASSERT_EQ(umfCtlSet("umf.pool.default.disjoint.params.capacity",
+                            &override_capacity, sizeof(override_capacity)),
+                  UMF_RESULT_SUCCESS);
+        ASSERT_EQ(umfCtlSet("umf.pool.default.disjoint.params.min_bucket_size",
+                            &override_min_bucket, sizeof(override_min_bucket)),
+                  UMF_RESULT_SUCCESS);
+
+        umf_disjoint_pool_params_handle_t raw_params = nullptr;
+        ASSERT_EQ(umfDisjointPoolParamsCreate(&raw_params), UMF_RESULT_SUCCESS);
+        std::unique_ptr<umf_disjoint_pool_params_t,
+                        decltype(&umfDisjointPoolParamsDestroy)>
+            params(raw_params, &umfDisjointPoolParamsDestroy);
+
+        ASSERT_EQ(umfDisjointPoolParamsSetCapacity(params.get(), 1),
+                  UMF_RESULT_SUCCESS);
+        ASSERT_EQ(umfDisjointPoolParamsSetMinBucketSize(params.get(), 64),
+                  UMF_RESULT_SUCCESS);
+
+        PoolWrapper poolWrapper(providerWrapper.get(), umfDisjointPoolOps(),
+                                params.get());
+        ASSERT_NE(poolWrapper.get(), nullptr);
+
+        size_t value = 0;
+        ASSERT_EQ(umfCtlGet("umf.pool.by_handle.{}.params.capacity", &value,
+                            sizeof(value), poolWrapper.get()),
+                  UMF_RESULT_SUCCESS);
+        EXPECT_EQ(value, override_capacity);
+        ASSERT_EQ(umfCtlGet("umf.pool.by_handle.{}.params.min_bucket_size",
+                            &value, sizeof(value), poolWrapper.get()),
+                  UMF_RESULT_SUCCESS);
+        EXPECT_EQ(value, override_min_bucket);
+
+        ASSERT_EQ(umfCtlSet("umf.pool.default.disjoint.params.capacity",
+                            &default_capacity, sizeof(default_capacity)),
+                  UMF_RESULT_SUCCESS);
+        ASSERT_EQ(umfCtlSet("umf.pool.default.disjoint.params.min_bucket_size",
+                            &default_min_bucket, sizeof(default_min_bucket)),
+                  UMF_RESULT_SUCCESS);
+    });
+}
+
+TEST_F(test, disjointCtlDefaultsCustomName) {
+    umf_test::run_in_fork([] {
+        umf_os_memory_provider_params_handle_t raw_os_params = nullptr;
+        umf_result_t res = umfOsMemoryProviderParamsCreate(&raw_os_params);
+        if (res == UMF_RESULT_ERROR_NOT_SUPPORTED) {
+            GTEST_SKIP() << "OS memory provider is not supported!";
+        }
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+        std::unique_ptr<umf_os_memory_provider_params_t,
+                        decltype(&umfOsMemoryProviderParamsDestroy)>
+            os_params(raw_os_params, &umfOsMemoryProviderParamsDestroy);
+
+        ProviderWrapper providerWrapper(umfOsMemoryProviderOps(),
+                                        os_params.get());
+        if (providerWrapper.get() == nullptr) {
+            GTEST_SKIP() << "OS memory provider is not supported!";
+        }
+
+        const std::string custom_name = "custom_disjoint_pool";
+
+        size_t canonical_capacity = 9;
+        size_t canonical_min_bucket = 32;
+        ASSERT_EQ(umfCtlSet("umf.pool.default.disjoint.params.capacity",
+                            &canonical_capacity, sizeof(canonical_capacity)),
+                  UMF_RESULT_SUCCESS);
+        ASSERT_EQ(umfCtlSet("umf.pool.default.disjoint.params.min_bucket_size",
+                            &canonical_min_bucket,
+                            sizeof(canonical_min_bucket)),
+                  UMF_RESULT_SUCCESS);
+
+        size_t custom_capacity = 11;
+        size_t custom_min_bucket = 64;
+        const std::string custom_capacity_path =
+            "umf.pool.default." + custom_name + ".params.capacity";
+        const std::string custom_min_bucket_path =
+            "umf.pool.default." + custom_name + ".params.min_bucket_size";
+        ASSERT_EQ(umfCtlSet(custom_capacity_path.c_str(), &custom_capacity,
+                            sizeof(custom_capacity)),
+                  UMF_RESULT_SUCCESS);
+        ASSERT_EQ(umfCtlSet(custom_min_bucket_path.c_str(), &custom_min_bucket,
+                            sizeof(custom_min_bucket)),
+                  UMF_RESULT_SUCCESS);
+
+        umf_disjoint_pool_params_handle_t raw_custom_params = nullptr;
+        ASSERT_EQ(umfDisjointPoolParamsCreate(&raw_custom_params),
+                  UMF_RESULT_SUCCESS);
+        std::unique_ptr<umf_disjoint_pool_params_t,
+                        decltype(&umfDisjointPoolParamsDestroy)>
+            custom_params(raw_custom_params, &umfDisjointPoolParamsDestroy);
+
+        ASSERT_EQ(umfDisjointPoolParamsSetName(custom_params.get(),
+                                               custom_name.c_str()),
+                  UMF_RESULT_SUCCESS);
+
+        PoolWrapper customPool(providerWrapper.get(), umfDisjointPoolOps(),
+                               custom_params.get());
+        ASSERT_NE(customPool.get(), nullptr);
+
+        size_t value = 0;
+        ASSERT_EQ(umfCtlGet("umf.pool.by_handle.{}.params.capacity", &value,
+                            sizeof(value), customPool.get()),
+                  UMF_RESULT_SUCCESS);
+        EXPECT_EQ(value, custom_capacity);
+        ASSERT_EQ(umfCtlGet("umf.pool.by_handle.{}.params.min_bucket_size",
+                            &value, sizeof(value), customPool.get()),
+                  UMF_RESULT_SUCCESS);
+        EXPECT_EQ(value, custom_min_bucket);
+
+        umf_disjoint_pool_params_handle_t raw_default_params = nullptr;
+        ASSERT_EQ(umfDisjointPoolParamsCreate(&raw_default_params),
+                  UMF_RESULT_SUCCESS);
+        std::unique_ptr<umf_disjoint_pool_params_t,
+                        decltype(&umfDisjointPoolParamsDestroy)>
+            default_params(raw_default_params, &umfDisjointPoolParamsDestroy);
+
+        PoolWrapper defaultPool(providerWrapper.get(), umfDisjointPoolOps(),
+                                default_params.get());
+        ASSERT_NE(defaultPool.get(), nullptr);
+
+        ASSERT_EQ(umfCtlGet("umf.pool.by_handle.{}.params.capacity", &value,
+                            sizeof(value), defaultPool.get()),
+                  UMF_RESULT_SUCCESS);
+        EXPECT_EQ(value, canonical_capacity);
+        ASSERT_EQ(umfCtlGet("umf.pool.by_handle.{}.params.min_bucket_size",
+                            &value, sizeof(value), defaultPool.get()),
+                  UMF_RESULT_SUCCESS);
+        EXPECT_EQ(value, canonical_min_bucket);
+    });
+}
+
+TEST_F(test, disjointCtlMemoryMetricsConsistency) {
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+    if (UMF_RESULT_ERROR_NOT_SUPPORTED ==
+        umfOsMemoryProviderParamsCreate(&os_memory_provider_params)) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    ProviderWrapper providerWrapper(umfOsMemoryProviderOps(),
+                                    os_memory_provider_params);
+    if (providerWrapper.get() == NULL) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    ASSERT_SUCCESS(umfDisjointPoolParamsCreate(&params));
+
+    // Set minimum slab size
+    size_t slab_min_size = 64 * 1024;
+    ASSERT_SUCCESS(umfDisjointPoolParamsSetSlabMinSize(params, slab_min_size));
+    ASSERT_SUCCESS(umfDisjointPoolParamsSetCapacity(params, 4));
+
+    PoolWrapper poolWrapper(providerWrapper.get(), umfDisjointPoolOps(),
+                            params);
+
+    const size_t n_allocations = 10; // Number of allocations
+
+    // Allocate memory
+    std::vector<void *> ptrs;
+    for (size_t i = 0; i < n_allocations; i++) {
+        void *ptr = umfPoolMalloc(poolWrapper.get(), slab_min_size);
+        ASSERT_NE(ptr, nullptr);
+        ptrs.push_back(ptr);
+    }
+
+    // Get memory metrics
+    size_t used_memory = 0;
+    size_t reserved_memory = 0;
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.stats.used_memory",
+                             &used_memory, sizeof(used_memory),
+                             poolWrapper.get()));
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.stats.reserved_memory",
+                             &reserved_memory, sizeof(reserved_memory),
+                             poolWrapper.get()));
+
+    // Used memory should be at least the total allocated
+    ASSERT_GE(used_memory, n_allocations * slab_min_size);
+
+    // Reserved memory should be at least the used memory
+    ASSERT_GE(reserved_memory, 4 * slab_min_size);
+
+    // Free all memory
+    for (void *ptr : ptrs) {
+        ASSERT_SUCCESS(umfPoolFree(poolWrapper.get(), ptr));
+    }
+
+    // Check metrics after free
+    size_t used_memory_after = 0;
+    size_t reserved_memory_after = 0;
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.stats.used_memory",
+                             &used_memory_after, sizeof(used_memory_after),
+                             poolWrapper.get()));
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.stats.reserved_memory",
+                             &reserved_memory_after,
+                             sizeof(reserved_memory_after), poolWrapper.get()));
+
+    // Used memory should be 0 after freeing
+    ASSERT_EQ(used_memory_after, 0ull);
+    // Reserved memory should remain the same (pooling)
+    ASSERT_EQ(reserved_memory_after, 4 * slab_min_size);
+
+    // Clean up
+    ASSERT_SUCCESS(umfDisjointPoolParamsDestroy(params));
+    ASSERT_SUCCESS(umfOsMemoryProviderParamsDestroy(os_memory_provider_params));
+}
+
+TEST_F(test, disjointCtlMemoryMetricsInvalidArgs) {
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+    if (UMF_RESULT_ERROR_NOT_SUPPORTED ==
+        umfOsMemoryProviderParamsCreate(&os_memory_provider_params)) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    ProviderWrapper providerWrapper(umfOsMemoryProviderOps(),
+                                    os_memory_provider_params);
+    if (providerWrapper.get() == NULL) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    ASSERT_SUCCESS(umfDisjointPoolParamsCreate(&params));
+    PoolWrapper poolWrapper(providerWrapper.get(), umfDisjointPoolOps(),
+                            params);
+
+    // Test invalid arguments
+    size_t value = 0;
+
+    // NULL arg pointer
+    ASSERT_EQ(umfCtlGet("umf.pool.by_handle.{}.stats.used_memory", NULL,
+                        sizeof(value), poolWrapper.get()),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // Size too small
+    ASSERT_EQ(umfCtlGet("umf.pool.by_handle.{}.stats.used_memory", &value,
+                        sizeof(size_t) / 2, poolWrapper.get()),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // Same tests for reserved_memory
+    ASSERT_EQ(umfCtlGet("umf.pool.by_handle.{}.stats.reserved_memory", NULL,
+                        sizeof(value), poolWrapper.get()),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ASSERT_EQ(umfCtlGet("umf.pool.by_handle.{}.stats.reserved_memory", &value,
+                        sizeof(size_t) / 2, poolWrapper.get()),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // Clean up
+    ASSERT_SUCCESS(umfDisjointPoolParamsDestroy(params));
+    ASSERT_SUCCESS(umfOsMemoryProviderParamsDestroy(os_memory_provider_params));
+}
+
+TEST_F(test, disjointCtlBucketStats) {
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+    if (UMF_RESULT_ERROR_NOT_SUPPORTED ==
+        umfOsMemoryProviderParamsCreate(&os_memory_provider_params)) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    ProviderWrapper providerWrapper(umfOsMemoryProviderOps(),
+                                    os_memory_provider_params);
+    if (providerWrapper.get() == NULL) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    ASSERT_SUCCESS(umfDisjointPoolParamsCreate(&params));
+
+    // Set minimum slab size
+    size_t slab_min_size = 64 * 1024;
+    ASSERT_SUCCESS(umfDisjointPoolParamsSetSlabMinSize(params, slab_min_size));
+    ASSERT_SUCCESS(umfDisjointPoolParamsSetCapacity(params, 4));
+    ASSERT_SUCCESS(umfDisjointPoolParamsSetTrace(params, 3));
+
+    PoolWrapper poolWrapper(providerWrapper.get(), umfDisjointPoolOps(),
+                            params);
+
+    size_t arg = 0;
+    size_t count = 0;
+    const size_t alloc_size = 128;
+    size_t used_bucket = SIZE_MAX;
+    ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.buckets.count", &count,
+                             sizeof(count), poolWrapper.get()));
+    EXPECT_GE(count, 0ull);
+
+    auto expected_bucket_size = [](size_t i) -> size_t {
+        // Even indexes: 8 << (i/2)  => 8,16,32,64,...
+        // Odd  indexes: 12 << (i/2) => 12,24,48,96,...
+        return (i % 2 == 0) ? (size_t(8) << (i / 2)) : (size_t(12) << (i / 2));
+    };
+
+    for (size_t i = 0; i < count; i++) {
+        ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.buckets.{}.size", &arg,
+                                 sizeof(arg), poolWrapper.get(), i));
+        EXPECT_EQ(arg, expected_bucket_size(i)) << "Failed for bucket: " << i;
+        if (arg >= alloc_size && used_bucket == SIZE_MAX) {
+            used_bucket = i; // Find the bucket that matches alloc_size
+        }
+    }
+
+    std::unordered_map<std::string, size_t> stats = {
+        {"alloc_num", 0ull},          {"alloc_pool_num", 0ull},
+        {"free_num", 0ull},           {"curr_slabs_in_use", 0ull},
+        {"curr_slabs_in_pool", 0ull}, {"max_slabs_in_use", 0ull},
+        {"max_slabs_in_pool", 0ull},
+    };
+
+    for (const auto &s : stats) {
+        ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.stats.{}", &arg,
+                                 sizeof(arg), poolWrapper.get(),
+                                 s.first.c_str()));
+        EXPECT_EQ(arg, s.second) << "Failed for stat: " << s.first;
+    }
+
+    for (size_t i = 0; i < count; i++) {
+        for (const auto &s : stats) {
+            ASSERT_SUCCESS(
+                umfCtlGet("umf.pool.by_handle.{}.buckets.{}.stats.{}", &arg,
+                          sizeof(arg), poolWrapper.get(), i, s.first.c_str()));
+            EXPECT_EQ(arg, i == used_bucket ? s.second : 0)
+                << "Failed for stat: " << s.first << " bucket: " << i;
+        }
+    }
+
+    const size_t n_allocations = 10; // Number of allocations
+
+    // Allocate memory
+    std::vector<void *> ptrs;
+    for (size_t i = 0; i < n_allocations; i++) {
+        void *ptr = umfPoolMalloc(poolWrapper.get(), alloc_size);
+        ASSERT_NE(ptr, nullptr);
+        ptrs.push_back(ptr);
+    }
+
+    stats = {
+        {"alloc_num", 10ull},         {"alloc_pool_num", 9ull},
+        {"free_num", 0ull},           {"curr_slabs_in_use", 1ull},
+        {"curr_slabs_in_pool", 0ull}, {"max_slabs_in_use", 1ull},
+        {"max_slabs_in_pool", 0ull},
+    };
+
+    for (const auto &s : stats) {
+        ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.stats.{}", &arg,
+                                 sizeof(arg), poolWrapper.get(),
+                                 s.first.c_str()));
+        EXPECT_EQ(arg, s.second) << "Failed for stat: " << s.first;
+    }
+    for (size_t i = 0; i < count; i++) {
+        for (const auto &s : stats) {
+            ASSERT_SUCCESS(
+                umfCtlGet("umf.pool.by_handle.{}.buckets.{}.stats.{}", &arg,
+                          sizeof(arg), poolWrapper.get(), i, s.first.c_str()));
+            EXPECT_EQ(arg, i == used_bucket ? s.second : 0)
+                << "Failed for stat: " << s.first << " bucket: " << i;
+        }
+    }
+
+    // Free all memory
+    for (void *ptr : ptrs) {
+        ASSERT_SUCCESS(umfPoolFree(poolWrapper.get(), ptr));
+    }
+
+    stats = {
+        {"alloc_num", 10ull},         {"alloc_pool_num", 9ull},
+        {"free_num", 10ull},          {"curr_slabs_in_use", 0ull},
+        {"curr_slabs_in_pool", 1ull}, {"max_slabs_in_use", 1ull},
+        {"max_slabs_in_pool", 1ull},
+    };
+
+    for (const auto &s : stats) {
+        ASSERT_SUCCESS(umfCtlGet("umf.pool.by_handle.{}.stats.{}", &arg,
+                                 sizeof(arg), poolWrapper.get(),
+                                 s.first.c_str()));
+        EXPECT_EQ(arg, s.second) << "Failed for stat: " << s.first;
+    }
+
+    for (size_t i = 0; i < count; i++) {
+        for (const auto &s : stats) {
+            ASSERT_SUCCESS(
+                umfCtlGet("umf.pool.by_handle.{}.buckets.{}.stats.{}", &arg,
+                          sizeof(arg), poolWrapper.get(), i, s.first.c_str()));
+            EXPECT_EQ(arg, i == used_bucket ? s.second : 0)
+                << "Failed for stat: " << s.first << " bucket: " << i;
+        }
+    }
+
+    // Clean up
+    ASSERT_SUCCESS(umfDisjointPoolParamsDestroy(params));
+    ASSERT_SUCCESS(umfOsMemoryProviderParamsDestroy(os_memory_provider_params));
+}
+
+TEST_F(test, disjointCtlBucketStatsTraceDisabled) {
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+    if (UMF_RESULT_ERROR_NOT_SUPPORTED ==
+        umfOsMemoryProviderParamsCreate(&os_memory_provider_params)) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    ProviderWrapper providerWrapper(umfOsMemoryProviderOps(),
+                                    os_memory_provider_params);
+    if (providerWrapper.get() == NULL) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    ASSERT_SUCCESS(umfDisjointPoolParamsCreate(&params));
+
+    // Set minimum slab size
+    size_t slab_min_size = 64 * 1024;
+    ASSERT_SUCCESS(umfDisjointPoolParamsSetSlabMinSize(params, slab_min_size));
+    ASSERT_SUCCESS(umfDisjointPoolParamsSetCapacity(params, 4));
+
+    PoolWrapper poolWrapper(providerWrapper.get(), umfDisjointPoolOps(),
+                            params);
+
+    size_t arg = 0;
+    // trace disabled
+    umf_result_t ret = umfCtlGet("umf.pool.by_handle.{}.stats.alloc_num", &arg,
+                                 sizeof(arg), poolWrapper.get());
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    // Clean up
+    ASSERT_SUCCESS(umfDisjointPoolParamsDestroy(params));
+    ASSERT_SUCCESS(umfOsMemoryProviderParamsDestroy(os_memory_provider_params));
+}
+
+TEST_F(test, disjointCtlBucketStatsInvalid) {
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+    if (UMF_RESULT_ERROR_NOT_SUPPORTED ==
+        umfOsMemoryProviderParamsCreate(&os_memory_provider_params)) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    ProviderWrapper providerWrapper(umfOsMemoryProviderOps(),
+                                    os_memory_provider_params);
+    if (providerWrapper.get() == NULL) {
+        GTEST_SKIP() << "OS memory provider is not supported!";
+    }
+
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    ASSERT_SUCCESS(umfDisjointPoolParamsCreate(&params));
+
+    // Set minimum slab size
+    size_t slab_min_size = 64 * 1024;
+    ASSERT_SUCCESS(umfDisjointPoolParamsSetSlabMinSize(params, slab_min_size));
+    ASSERT_SUCCESS(umfDisjointPoolParamsSetCapacity(params, 4));
+    ASSERT_SUCCESS(umfDisjointPoolParamsSetTrace(params, 3));
+    PoolWrapper poolWrapper(providerWrapper.get(), umfDisjointPoolOps(),
+                            params);
+
+    size_t arg = 0;
+
+    // invalid bucket index
+    umf_result_t ret =
+        umfCtlGet("umf.pool.by_handle.{}.buckets.1000000.stats.alloc_num", &arg,
+                  sizeof(arg), poolWrapper.get());
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // invalid arg
+    ret = umfCtlGet("umf.pool.by_handle.{}.stats.alloc_num", NULL, sizeof(arg),
+                    poolWrapper.get());
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfCtlGet("umf.pool.by_handle.{}.stats.alloc_num", &arg, 1,
+                    poolWrapper.get());
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfCtlGet("umf.pool.by_handle.{}.stats.buckets.count", NULL,
+                    sizeof(arg), poolWrapper.get());
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfCtlGet("umf.pool.by_handle.{}.stats.buckets.count", &arg, 1,
+                    poolWrapper.get());
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_CTL_PATH);
+
+    ret = umfCtlGet("umf.pool.by_handle.{}.stats.buckets.1.alloc_num", NULL,
+                    sizeof(arg), poolWrapper.get());
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfCtlGet("umf.pool.by_handle.{}.stats.1.alloc_num", &arg, 1,
+                    poolWrapper.get());
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_CTL_PATH);
+
+    // no bucket id
+    ret = umfCtlGet("umf.pool.by_handle.{}.stats.buckets.alloc_num", &arg,
+                    sizeof(arg), poolWrapper.get());
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_CTL_PATH);
+
+    // bucked id + count
+    ret = umfCtlGet("umf.pool.by_handle.{}.stats.buckets.1.count", &arg,
+                    sizeof(arg), poolWrapper.get());
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_CTL_PATH);
+
+    // Clean up
+    ASSERT_SUCCESS(umfDisjointPoolParamsDestroy(params));
+    ASSERT_SUCCESS(umfOsMemoryProviderParamsDestroy(os_memory_provider_params));
+}
+
+TEST_F(test, disjointCtlParams) {
+    umf_test::run_in_fork([] {
+        umf_os_memory_provider_params_handle_t raw_os_params = nullptr;
+        umf_result_t res = umfOsMemoryProviderParamsCreate(&raw_os_params);
+        if (res == UMF_RESULT_ERROR_NOT_SUPPORTED) {
+            GTEST_SKIP() << "OS memory provider is not supported!";
+        }
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+        std::unique_ptr<umf_os_memory_provider_params_t,
+                        decltype(&umfOsMemoryProviderParamsDestroy)>
+            os_params(raw_os_params, &umfOsMemoryProviderParamsDestroy);
+
+        ProviderWrapper providerWrapper(umfOsMemoryProviderOps(),
+                                        os_params.get());
+        if (providerWrapper.get() == nullptr) {
+            GTEST_SKIP() << "OS memory provider is not supported!";
+        }
+
+        // slab_min_size
+        {
+            size_t new_slab_min_size = 128 * 1024;
+            ASSERT_EQ(
+                umfCtlSet("umf.pool.default.disjoint.params.slab_min_size",
+                          &new_slab_min_size, sizeof(new_slab_min_size)),
+                UMF_RESULT_SUCCESS);
+
+            umf_disjoint_pool_params_handle_t params = nullptr;
+            ASSERT_EQ(umfDisjointPoolParamsCreate(&params), UMF_RESULT_SUCCESS);
+            std::unique_ptr<umf_disjoint_pool_params_t,
+                            decltype(&umfDisjointPoolParamsDestroy)>
+                params_guard(params, &umfDisjointPoolParamsDestroy);
+
+            PoolWrapper poolWrapper(providerWrapper.get(), umfDisjointPoolOps(),
+                                    params);
+            ASSERT_NE(poolWrapper.get(), nullptr);
+
+            size_t value = 0;
+            ASSERT_EQ(umfCtlGet("umf.pool.by_handle.{}.params.slab_min_size",
+                                &value, sizeof(value), poolWrapper.get()),
+                      UMF_RESULT_SUCCESS);
+            EXPECT_EQ(value, new_slab_min_size);
+
+            size_t other = new_slab_min_size + 1024;
+            EXPECT_EQ(umfCtlSet("umf.pool.by_handle.{}.params.slab_min_size",
+                                &other, sizeof(other), poolWrapper.get()),
+                      UMF_RESULT_ERROR_NOT_SUPPORTED);
+        }
+
+        // max_poolable_size
+        {
+            size_t new_max_poolable = 1 * MB;
+            ASSERT_EQ(
+                umfCtlSet("umf.pool.default.disjoint.params.max_poolable_size",
+                          &new_max_poolable, sizeof(new_max_poolable)),
+                UMF_RESULT_SUCCESS);
+
+            umf_disjoint_pool_params_handle_t params = nullptr;
+            ASSERT_EQ(umfDisjointPoolParamsCreate(&params), UMF_RESULT_SUCCESS);
+            std::unique_ptr<umf_disjoint_pool_params_t,
+                            decltype(&umfDisjointPoolParamsDestroy)>
+                params_guard(params, &umfDisjointPoolParamsDestroy);
+
+            PoolWrapper poolWrapper(providerWrapper.get(), umfDisjointPoolOps(),
+                                    params);
+            ASSERT_NE(poolWrapper.get(), nullptr);
+
+            size_t value = 0;
+            ASSERT_EQ(
+                umfCtlGet("umf.pool.by_handle.{}.params.max_poolable_size",
+                          &value, sizeof(value), poolWrapper.get()),
+                UMF_RESULT_SUCCESS);
+            EXPECT_EQ(value, new_max_poolable);
+
+            size_t other = new_max_poolable * 2;
+            EXPECT_EQ(
+                umfCtlSet("umf.pool.by_handle.{}.params.max_poolable_size",
+                          &other, sizeof(other), poolWrapper.get()),
+                UMF_RESULT_ERROR_NOT_SUPPORTED);
+        }
+
+        // capacity
+        {
+            size_t new_capacity = 8;
+            ASSERT_EQ(umfCtlSet("umf.pool.default.disjoint.params.capacity",
+                                &new_capacity, sizeof(new_capacity)),
+                      UMF_RESULT_SUCCESS);
+
+            umf_disjoint_pool_params_handle_t params = nullptr;
+            ASSERT_EQ(umfDisjointPoolParamsCreate(&params), UMF_RESULT_SUCCESS);
+            std::unique_ptr<umf_disjoint_pool_params_t,
+                            decltype(&umfDisjointPoolParamsDestroy)>
+                params_guard(params, &umfDisjointPoolParamsDestroy);
+
+            PoolWrapper poolWrapper(providerWrapper.get(), umfDisjointPoolOps(),
+                                    params);
+            ASSERT_NE(poolWrapper.get(), nullptr);
+
+            size_t value = 0;
+            ASSERT_EQ(umfCtlGet("umf.pool.by_handle.{}.params.capacity", &value,
+                                sizeof(value), poolWrapper.get()),
+                      UMF_RESULT_SUCCESS);
+            EXPECT_EQ(value, new_capacity);
+
+            size_t other = 16;
+            EXPECT_EQ(umfCtlSet("umf.pool.by_handle.{}.params.capacity", &other,
+                                sizeof(other), poolWrapper.get()),
+                      UMF_RESULT_ERROR_NOT_SUPPORTED);
+        }
+
+        // min_bucket_size
+        {
+            size_t new_min_bucket = 16;
+            ASSERT_EQ(
+                umfCtlSet("umf.pool.default.disjoint.params.min_bucket_size",
+                          &new_min_bucket, sizeof(new_min_bucket)),
+                UMF_RESULT_SUCCESS);
+
+            umf_disjoint_pool_params_handle_t params = nullptr;
+            ASSERT_EQ(umfDisjointPoolParamsCreate(&params), UMF_RESULT_SUCCESS);
+            std::unique_ptr<umf_disjoint_pool_params_t,
+                            decltype(&umfDisjointPoolParamsDestroy)>
+                params_guard(params, &umfDisjointPoolParamsDestroy);
+
+            PoolWrapper poolWrapper(providerWrapper.get(), umfDisjointPoolOps(),
+                                    params);
+            ASSERT_NE(poolWrapper.get(), nullptr);
+
+            size_t value = 0;
+            ASSERT_EQ(umfCtlGet("umf.pool.by_handle.{}.params.min_bucket_size",
+                                &value, sizeof(value), poolWrapper.get()),
+                      UMF_RESULT_SUCCESS);
+            EXPECT_EQ(value, new_min_bucket);
+
+            size_t other = 32;
+            EXPECT_EQ(umfCtlSet("umf.pool.by_handle.{}.params.min_bucket_size",
+                                &other, sizeof(other), poolWrapper.get()),
+                      UMF_RESULT_ERROR_NOT_SUPPORTED);
+        }
+
+        // pool_trace
+        {
+            int new_trace = 3;
+            ASSERT_EQ(umfCtlSet("umf.pool.default.disjoint.params.pool_trace",
+                                &new_trace, sizeof(new_trace)),
+                      UMF_RESULT_SUCCESS);
+
+            umf_disjoint_pool_params_handle_t params = nullptr;
+            ASSERT_EQ(umfDisjointPoolParamsCreate(&params), UMF_RESULT_SUCCESS);
+            std::unique_ptr<umf_disjoint_pool_params_t,
+                            decltype(&umfDisjointPoolParamsDestroy)>
+                params_guard(params, &umfDisjointPoolParamsDestroy);
+
+            PoolWrapper poolWrapper(providerWrapper.get(), umfDisjointPoolOps(),
+                                    params);
+            ASSERT_NE(poolWrapper.get(), nullptr);
+
+            int value = 0;
+            ASSERT_EQ(umfCtlGet("umf.pool.by_handle.{}.params.pool_trace",
+                                &value, sizeof(value), poolWrapper.get()),
+                      UMF_RESULT_SUCCESS);
+            EXPECT_EQ(value, new_trace);
+
+            int other = 1;
+            EXPECT_EQ(umfCtlSet("umf.pool.by_handle.{}.params.pool_trace",
+                                &other, sizeof(other), poolWrapper.get()),
+                      UMF_RESULT_ERROR_NOT_SUPPORTED);
+        }
+    });
+}
diff --git a/test/pools/jemalloc_coarse_devdax.cpp b/test/pools/jemalloc_coarse_devdax.cpp
index 350e053ab7..8af7809970 100644
--- a/test/pools/jemalloc_coarse_devdax.cpp
+++ b/test/pools/jemalloc_coarse_devdax.cpp
@@ -1,45 +1,50 @@
-// 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
 
-#include "umf/pools/pool_jemalloc.h"
-#include "umf/providers/provider_devdax_memory.h"
+#include <umf/pools/pool_jemalloc.h>
+#include <umf/providers/provider_devdax_memory.h>
 
 #include "pool_coarse.hpp"
 
-using devdax_params_unique_handle_t =
-    std::unique_ptr<umf_devdax_memory_provider_params_t,
-                    decltype(&umfDevDaxMemoryProviderParamsDestroy)>;
+bool devDaxEnvSet() {
+    char *path = getenv("UMF_TESTS_DEVDAX_PATH");
+    char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
+    if (path == nullptr || path[0] == '\0' || size == nullptr ||
+        size[0] == '\0') {
+        return false;
+    }
 
-devdax_params_unique_handle_t create_devdax_params() {
+    return true;
+}
+
+void *createDevDaxParams() {
     char *path = getenv("UMF_TESTS_DEVDAX_PATH");
     char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
-    if (path == nullptr || path[0] == 0 || size == nullptr || size[0] == 0) {
-        return devdax_params_unique_handle_t(
-            nullptr, &umfDevDaxMemoryProviderParamsDestroy);
+    if (path == nullptr || path[0] == '\0' || size == nullptr ||
+        size[0] == '\0') {
+        return nullptr;
     }
 
     umf_devdax_memory_provider_params_handle_t params = NULL;
     umf_result_t res =
-        umfDevDaxMemoryProviderParamsCreate(&params, path, atol(size));
+        umfDevDaxMemoryProviderParamsCreate(path, atol(size), &params);
     if (res != UMF_RESULT_SUCCESS) {
         throw std::runtime_error(
             "Failed to create DevDax Memory Provider params");
     }
 
-    return devdax_params_unique_handle_t(params,
-                                         &umfDevDaxMemoryProviderParamsDestroy);
+    return params;
 }
 
-auto coarseParams = umfCoarseMemoryProviderParamsDefault();
-auto devdaxParams = create_devdax_params();
-
 static std::vector<poolCreateExtParams> poolParamsList =
-    devdaxParams.get()
+    devDaxEnvSet()
         ? std::vector<poolCreateExtParams>{poolCreateExtParams{
-              umfJemallocPoolOps(), nullptr, umfDevDaxMemoryProviderOps(),
-              devdaxParams.get(), &coarseParams}}
+              umfJemallocPoolOps(), nullptr, nullptr,
+              umfDevDaxMemoryProviderOps(), createDevDaxParams,
+              (pfnProviderParamsDestroy)umfDevDaxMemoryProviderParamsDestroy}}
         : std::vector<poolCreateExtParams>{};
 
 INSTANTIATE_TEST_SUITE_P(jemallocCoarseDevDaxTest, umfPoolTest,
-                         ::testing::ValuesIn(poolParamsList));
+                         ::testing::ValuesIn(poolParamsList),
+                         poolCreateExtParamsNameGen);
diff --git a/test/pools/jemalloc_coarse_file.cpp b/test/pools/jemalloc_coarse_file.cpp
index 74ad36d56e..b6f84804fe 100644
--- a/test/pools/jemalloc_coarse_file.cpp
+++ b/test/pools/jemalloc_coarse_file.cpp
@@ -1,33 +1,32 @@
-// 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
 
-#include "umf/pools/pool_jemalloc.h"
-#include "umf/providers/provider_file_memory.h"
+#include <umf/pools/pool_jemalloc.h>
+#include <umf/providers/provider_file_memory.h>
 
 #include "pool_coarse.hpp"
 
-using file_params_unique_handle_t =
-    std::unique_ptr<umf_file_memory_provider_params_t,
-                    decltype(&umfFileMemoryProviderParamsDestroy)>;
-
-file_params_unique_handle_t get_file_params_default(char *path) {
+void *getFileParamsDefault() {
     umf_file_memory_provider_params_handle_t file_params = NULL;
-    umf_result_t res = umfFileMemoryProviderParamsCreate(&file_params, path);
+    umf_result_t res =
+        umfFileMemoryProviderParamsCreate(FILE_PATH, &file_params);
     if (res != UMF_RESULT_SUCCESS) {
         throw std::runtime_error(
             "Failed to create File Memory Provider params");
     }
 
-    return file_params_unique_handle_t(file_params,
-                                       &umfFileMemoryProviderParamsDestroy);
+    return file_params;
 }
 
-auto coarseParams = umfCoarseMemoryProviderParamsDefault();
-file_params_unique_handle_t fileParams = get_file_params_default(FILE_PATH);
+umf_result_t destroyFileParams(void *params) {
+    return umfFileMemoryProviderParamsDestroy(
+        (umf_file_memory_provider_params_handle_t)params);
+}
 
 INSTANTIATE_TEST_SUITE_P(jemallocCoarseFileTest, umfPoolTest,
                          ::testing::Values(poolCreateExtParams{
-                             umfJemallocPoolOps(), nullptr,
-                             umfFileMemoryProviderOps(), fileParams.get(),
-                             &coarseParams}));
+                             umfJemallocPoolOps(), nullptr, nullptr,
+                             umfFileMemoryProviderOps(), getFileParamsDefault,
+                             destroyFileParams}),
+                         poolCreateExtParamsNameGen);
diff --git a/test/pools/jemalloc_pool.cpp b/test/pools/jemalloc_pool.cpp
index 4dddbcd32b..c87b049c1a 100644
--- a/test/pools/jemalloc_pool.cpp
+++ b/test/pools/jemalloc_pool.cpp
@@ -1,9 +1,9 @@
-// Copyright (C) 2023 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/pools/pool_jemalloc.h"
-#include "umf/providers/provider_os_memory.h"
+#include <umf/pools/pool_jemalloc.h>
+#include <umf/providers/provider_os_memory.h>
 
 #include "pool.hpp"
 #include "poolFixtures.hpp"
@@ -11,26 +11,84 @@
 using umf_test::test;
 using namespace umf_test;
 
-using os_params_unique_handle_t =
-    std::unique_ptr<umf_os_memory_provider_params_t,
-                    decltype(&umfOsMemoryProviderParamsDestroy)>;
+using void_unique_ptr = std::unique_ptr<void, decltype(&free)>;
 
-os_params_unique_handle_t createOsMemoryProviderParams() {
+void *createOsMemoryProviderParams() {
     umf_os_memory_provider_params_handle_t params = nullptr;
     umf_result_t res = umfOsMemoryProviderParamsCreate(&params);
     if (res != UMF_RESULT_SUCCESS) {
         throw std::runtime_error("Failed to create os memory provider params");
     }
 
-    return os_params_unique_handle_t(params, &umfOsMemoryProviderParamsDestroy);
+    return params;
 }
-auto defaultParams = createOsMemoryProviderParams();
 
-INSTANTIATE_TEST_SUITE_P(jemallocPoolTest, umfPoolTest,
-                         ::testing::Values(poolCreateExtParams{
-                             umfJemallocPoolOps(), nullptr,
-                             umfOsMemoryProviderOps(), defaultParams.get(),
-                             nullptr}));
+umf_result_t destroyOsMemoryProviderParams(void *params) {
+    return umfOsMemoryProviderParamsDestroy(
+        (umf_os_memory_provider_params_handle_t)params);
+}
+
+void *createFixedMemoryProviderParams() {
+    // Allocate a memory buffer to use with the fixed memory provider.
+    // The umfPoolTest.malloc_compliance test requires a lot of memory.
+    size_t memory_size = (1UL << 31);
+    static void_unique_ptr memory_buffer =
+        void_unique_ptr(malloc(memory_size), free);
+    if (memory_buffer.get() == NULL) {
+        throw std::runtime_error(
+            "Failed to allocate memory for Fixed memory provider");
+    }
+
+    umf_fixed_memory_provider_params_handle_t params = nullptr;
+    umf_result_t res = umfFixedMemoryProviderParamsCreate(memory_buffer.get(),
+                                                          memory_size, &params);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error(
+            "Failed to create Fixed memory provider params");
+    }
+
+    return params;
+}
+
+umf_result_t destroyFixedMemoryProviderParams(void *params) {
+    return umfFixedMemoryProviderParamsDestroy(
+        (umf_fixed_memory_provider_params_handle_t)params);
+}
+
+template <unsigned arenas = 0> void *createJemallocParams() {
+    umf_jemalloc_pool_params_handle_t params = nullptr;
+    auto ret = umfJemallocPoolParamsCreate(&params);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    if constexpr (arenas != 0) {
+        ret = umfJemallocPoolParamsSetNumArenas(params, arenas);
+        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    }
+    return params;
+}
+
+umf_result_t destroyJemallocParams(void *params) {
+    return umfJemallocPoolParamsDestroy(
+        (umf_jemalloc_pool_params_handle_t)params);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    jemallocPoolTest, umfPoolTest,
+    ::testing::Values(
+        poolCreateExtParams{
+            umfJemallocPoolOps(), nullptr, nullptr, umfOsMemoryProviderOps(),
+            createOsMemoryProviderParams, destroyOsMemoryProviderParams},
+        poolCreateExtParams{
+            umfJemallocPoolOps(), nullptr, nullptr, umfFixedMemoryProviderOps(),
+            createFixedMemoryProviderParams, destroyFixedMemoryProviderParams},
+        poolCreateExtParams{umfJemallocPoolOps(), createJemallocParams,
+                            destroyJemallocParams, umfOsMemoryProviderOps(),
+                            createOsMemoryProviderParams,
+                            destroyOsMemoryProviderParams},
+        poolCreateExtParams{umfJemallocPoolOps(), createJemallocParams<1>,
+                            destroyJemallocParams, umfOsMemoryProviderOps(),
+                            createOsMemoryProviderParams,
+                            destroyOsMemoryProviderParams}),
+    poolCreateExtParamsNameGen);
 
 // this test makes sure that jemalloc does not use
 // memory provider to allocate metadata (and hence
@@ -42,18 +100,41 @@ TEST_F(test, metadataNotAllocatedUsingProvider) {
 
     // set coarse grain allocations to PROT_NONE so that we can be sure
     // jemalloc does not touch any of the allocated memory
-    umf_os_memory_provider_params_handle_t params = nullptr;
-    umf_result_t res = umfOsMemoryProviderParamsCreate(&params);
-    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
-    res = umfOsMemoryProviderParamsSetProtection(params, UMF_PROTECTION_NONE);
-    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
 
-    auto pool =
-        poolCreateExtUnique({umfJemallocPoolOps(), nullptr,
-                             umfOsMemoryProviderOps(), params, nullptr});
+    auto providerParamsCreate = []() {
+        umf_os_memory_provider_params_handle_t params = nullptr;
+        umf_result_t res = umfOsMemoryProviderParamsCreate(&params);
+        if (res != UMF_RESULT_SUCCESS) {
+            throw std::runtime_error(
+                "Failed to create OS Memory Provider params");
+        }
+        res =
+            umfOsMemoryProviderParamsSetProtection(params, UMF_PROTECTION_NONE);
+        if (res != UMF_RESULT_SUCCESS) {
+            throw std::runtime_error(
+                "Failed to set OS Memory Provider params protection");
+        }
+        return (void *)params;
+    };
+
+    auto providerParamsDestroy = [](void *params) {
+        umf_result_t res = umfOsMemoryProviderParamsDestroy(
+            (umf_os_memory_provider_params_handle_t)params);
+        if (res != UMF_RESULT_SUCCESS) {
+            throw std::runtime_error(
+                "Failed to destroy OS Memory Provider params");
+        }
+        return res;
+    };
 
-    res = umfOsMemoryProviderParamsDestroy(params);
-    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    auto pool = poolCreateExtUnique({
+        umfJemallocPoolOps(),
+        nullptr,
+        nullptr,
+        umfOsMemoryProviderOps(),
+        (pfnProviderParamsCreate)providerParamsCreate,
+        (pfnProviderParamsDestroy)providerParamsDestroy,
+    });
 
     std::vector<std::shared_ptr<void>> allocs;
     for (size_t i = 0; i < numAllocs; i++) {
@@ -63,121 +144,115 @@ TEST_F(test, metadataNotAllocatedUsingProvider) {
     }
 }
 
-using jemallocPoolParams = bool;
-struct umfJemallocPoolParamsTest
-    : umf_test::test,
-      ::testing::WithParamInterface<jemallocPoolParams> {
+TEST_F(test, jemallocPoolNullParams) {
+    auto ret = umfJemallocPoolParamsSetNumArenas(NULL, 1);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
 
-    struct validation_params_t {
-        bool keep_all_memory;
-    };
+TEST_F(test, jemallocPoolParams) {
+    umf_jemalloc_pool_params_handle_t params = nullptr;
+    auto ret = umfJemallocPoolParamsCreate(&params);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    struct provider_validator : public umf_test::provider_ba_global {
-        using base_provider = umf_test::provider_ba_global;
+    ret = umfJemallocPoolParamsSetNumArenas(params, 1);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
-        umf_result_t initialize(validation_params_t *params) {
-            EXPECT_NE(params, nullptr);
-            expected_params = params;
-            return UMF_RESULT_SUCCESS;
-        }
-        umf_result_t free(void *ptr, size_t size) {
-            EXPECT_EQ(expected_params->keep_all_memory, false);
-            return base_provider::free(ptr, size);
-        }
+    ret = umfJemallocPoolParamsDestroy(params);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+}
 
-        validation_params_t *expected_params;
-    };
+TEST_F(test, jemallocPoolParamsInvalid) {
+    umf_jemalloc_pool_params_handle_t params = nullptr;
+    auto ret = umfJemallocPoolParamsCreate(&params);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    static constexpr umf_memory_provider_ops_t VALIDATOR_PROVIDER_OPS =
-        umf::providerMakeCOps<provider_validator, validation_params_t>();
-
-    umfJemallocPoolParamsTest() : expected_params{false}, params(nullptr) {}
-    void SetUp() override {
-        test::SetUp();
-        expected_params.keep_all_memory = this->GetParam();
-        umf_result_t ret = umfJemallocPoolParamsCreate(&params);
-        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-        ret = umfJemallocPoolParamsSetKeepAllMemory(
-            params, expected_params.keep_all_memory);
-        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-    }
+    ret = umfJemallocPoolParamsSetNumArenas(params, SIZE_MAX);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    void TearDown() override {
-        umfJemallocPoolParamsDestroy(params);
-        test::TearDown();
-    }
+    umf_os_memory_provider_params_handle_t provider_params = nullptr;
+    ret = umfOsMemoryProviderParamsCreate(&provider_params);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    umf_memory_provider_handle_t provider;
+    ret = umfMemoryProviderCreate(umfOsMemoryProviderOps(), provider_params,
+                                  &provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    umf::pool_unique_handle_t makePool() {
-        umf_memory_provider_handle_t hProvider = nullptr;
-        umf_memory_pool_handle_t hPool = nullptr;
+    umf_memory_pool_handle_t pool;
+    ret = umfPoolCreate(umfJemallocPoolOps(), provider, params, 0, &pool);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
-        auto ret = umfMemoryProviderCreate(&VALIDATOR_PROVIDER_OPS,
-                                           &expected_params, &hProvider);
-        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    umfMemoryProviderDestroy(provider);
 
-        ret = umfPoolCreate(umfJemallocPoolOps(), hProvider, params,
-                            UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &hPool);
-        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    ret = umfJemallocPoolParamsDestroy(params);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    ret = umfOsMemoryProviderParamsDestroy(provider_params);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+}
 
-        return umf::pool_unique_handle_t(hPool, &umfPoolDestroy);
-    }
+TEST_F(test, jemallocPoolName) {
+    umf_jemalloc_pool_params_handle_t params = nullptr;
+    umf_result_t res = umfJemallocPoolParamsCreate(&params);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+    umf_memory_pool_handle_t pool = NULL;
+
+    auto nullProvider = nullProviderCreate();
+    res = umfPoolCreate(umfJemallocPoolOps(), nullProvider, params, 0, &pool);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+    const char *name = nullptr;
+    res = umfPoolGetName(pool, &name);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, "jemalloc");
+
+    umfPoolDestroy(pool);
+    umfMemoryProviderDestroy(nullProvider);
+    umfJemallocPoolParamsDestroy(params);
+}
 
-    void allocFreeFlow() {
-        static const size_t ALLOC_SIZE = 128;
-        static const size_t NUM_ALLOCATIONS = 100;
-        std::vector<void *> ptrs;
+TEST_F(test, jemallocProviderDoesNotSupportSplit) {
+    umf_jemalloc_pool_params_handle_t params = nullptr;
+    umf_result_t res = umfJemallocPoolParamsCreate(&params);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
 
-        auto pool = makePool();
-        ASSERT_NE(pool, nullptr);
+    umf_memory_provider_handle_t ba_provider;
+    umf_result_t ret =
+        umfMemoryProviderCreate(&BA_GLOBAL_PROVIDER_OPS, nullptr, &ba_provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
-        for (size_t i = 0; i < NUM_ALLOCATIONS; ++i) {
-            auto *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);
-            ASSERT_NE(ptr, nullptr);
-            ptrs.push_back(ptr);
-        }
+    umf_memory_pool_handle_t pool = nullptr;
+    res = umfPoolCreate(umfJemallocPoolOps(), ba_provider, params, 0, &pool);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    EXPECT_EQ(pool, nullptr);
 
-        for (size_t i = 0; i < NUM_ALLOCATIONS; ++i) {
-            auto ret = umfPoolFree(pool.get(), ptrs[i]);
-            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-        }
+    umfMemoryProviderDestroy(ba_provider);
+    umfJemallocPoolParamsDestroy(params);
+}
 
-        // Now pool can call free during pool destruction
-        expected_params.keep_all_memory = false;
-    }
+TEST_F(test, jemallocPoolCustomName) {
+    umf_jemalloc_pool_params_handle_t params = nullptr;
+    umf_result_t res = umfJemallocPoolParamsCreate(&params);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
 
-    validation_params_t expected_params;
-    umf_jemalloc_pool_params_handle_t params;
-};
+    res = umfJemallocPoolParamsSetName(params, "my_jemalloc");
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
 
-TEST_P(umfJemallocPoolParamsTest, allocFree) { allocFreeFlow(); }
+    auto nullProvider = nullProviderCreate();
 
-TEST_P(umfJemallocPoolParamsTest, updateParams) {
-    expected_params.keep_all_memory = !expected_params.keep_all_memory;
-    umf_result_t ret = umfJemallocPoolParamsSetKeepAllMemory(
-        params, expected_params.keep_all_memory);
-    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    umf_memory_pool_handle_t pool = NULL;
+    res = umfPoolCreate(umfJemallocPoolOps(), nullProvider, params, 0, &pool);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+    const char *name = nullptr;
+    res = umfPoolGetName(pool, &name);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, "my_jemalloc");
 
-    allocFreeFlow();
+    umfPoolDestroy(pool);
+    umfMemoryProviderDestroy(nullProvider);
+    umfJemallocPoolParamsDestroy(params);
 }
 
-TEST_P(umfJemallocPoolParamsTest, invalidParams) {
-    umf_result_t ret = umfJemallocPoolParamsCreate(nullptr);
-    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    ret = umfJemallocPoolParamsSetKeepAllMemory(nullptr, true);
-    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    ret = umfJemallocPoolParamsSetKeepAllMemory(nullptr, false);
-    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    ret = umfJemallocPoolParamsDestroy(nullptr);
-    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+TEST(JemallocPoolOps, default_name_null_handle) {
+    const char *name = nullptr;
+    EXPECT_EQ(umfJemallocPoolOps()->get_name(nullptr, &name),
+              UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, "jemalloc");
 }
-
-GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfJemallocPoolParamsTest);
-
-/* TODO: enable this test after the issue #903 is fixed.
-(https://github.com/oneapi-src/unified-memory-framework/issues/903)
-INSTANTIATE_TEST_SUITE_P(jemallocPoolTest, umfJemallocPoolParamsTest,
-                         testing::Values(false, true));
-*/
diff --git a/test/pools/pool_base_alloc.cpp b/test/pools/pool_base_alloc.cpp
index 7c9a3701a7..583b417cf6 100644
--- a/test/pools/pool_base_alloc.cpp
+++ b/test/pools/pool_base_alloc.cpp
@@ -1,51 +1,64 @@
-// Copyright (C) 2023 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 <unordered_map>
 
-#include "umf/pools/pool_scalable.h"
-#include "umf/providers/provider_os_memory.h"
+#include <umf/pools/pool_scalable.h>
+#include <umf/providers/provider_os_memory.h>
 
+#include "base_alloc_global.h"
 #include "pool.hpp"
 #include "poolFixtures.hpp"
 #include "provider.hpp"
 
-#include "base_alloc_global.h"
-
 struct base_alloc_pool : public umf_test::pool_base_t {
 
     void *malloc(size_t size) noexcept { return umf_ba_global_alloc(size); }
     void *calloc(size_t, size_t) noexcept {
-        umf::getPoolLastStatusRef<base_alloc_pool>() =
+        umf_test::getPoolLastStatusRef<base_alloc_pool>() =
             UMF_RESULT_ERROR_NOT_SUPPORTED;
         return NULL;
     }
     void *realloc(void *, size_t) noexcept {
-        umf::getPoolLastStatusRef<base_alloc_pool>() =
+        umf_test::getPoolLastStatusRef<base_alloc_pool>() =
             UMF_RESULT_ERROR_NOT_SUPPORTED;
         return NULL;
     }
     void *aligned_malloc(size_t, size_t) noexcept {
-        umf::getPoolLastStatusRef<base_alloc_pool>() =
+        umf_test::getPoolLastStatusRef<base_alloc_pool>() =
             UMF_RESULT_ERROR_NOT_SUPPORTED;
         return NULL;
     }
-    size_t malloc_usable_size(void *ptr) noexcept {
-        return umf_ba_global_malloc_usable_size(ptr);
+    umf_result_t malloc_usable_size(const void *ptr, size_t *size) noexcept {
+        if (size) {
+            *size = umf_ba_global_malloc_usable_size(ptr);
+        }
+        return UMF_RESULT_SUCCESS;
     }
     umf_result_t free(void *ptr) noexcept {
         umf_ba_global_free(ptr);
         return UMF_RESULT_SUCCESS;
     }
     umf_result_t get_last_allocation_error() {
-        return umf::getPoolLastStatusRef<base_alloc_pool>();
+        return umf_test::getPoolLastStatusRef<base_alloc_pool>();
+    }
+    umf_result_t get_name(const char **name) noexcept {
+        if (name) {
+            *name = "base_alloc_pool";
+        }
+        return UMF_RESULT_SUCCESS;
+    }
+    umf_result_t ext_trim_memory(size_t) noexcept {
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
 };
 
-umf_memory_pool_ops_t BA_POOL_OPS = umf::poolMakeCOps<base_alloc_pool, void>();
+umf_memory_pool_ops_t BA_POOL_OPS =
+    umf_test::poolMakeCOps<base_alloc_pool, void>();
 
 INSTANTIATE_TEST_SUITE_P(baPool, umfPoolTest,
                          ::testing::Values(poolCreateExtParams{
-                             &BA_POOL_OPS, nullptr,
-                             &umf_test::BASE_PROVIDER_OPS, nullptr, nullptr}));
+                             &BA_POOL_OPS, nullptr, nullptr,
+                             &umf_test::BASE_PROVIDER_OPS, nullptr, nullptr}),
+                         poolCreateExtParamsNameGen);
diff --git a/test/pools/pool_coarse.hpp b/test/pools/pool_coarse.hpp
index 7baa612f1e..b1efb4fee9 100644
--- a/test/pools/pool_coarse.hpp
+++ b/test/pools/pool_coarse.hpp
@@ -5,8 +5,6 @@
 #ifndef UMF_TEST_POOL_COARSE_HPP
 #define UMF_TEST_POOL_COARSE_HPP 1
 
-#include "umf/providers/provider_coarse.h"
-
 #include "pool.hpp"
 #include "poolFixtures.hpp"
 
diff --git a/test/pools/pool_residency.cpp b/test/pools/pool_residency.cpp
new file mode 100644
index 0000000000..26ed99e37d
--- /dev/null
+++ b/test/pools/pool_residency.cpp
@@ -0,0 +1,195 @@
+// 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/pools/pool_disjoint.h>
+#include <umf/providers/provider_level_zero.h>
+
+#include "../common/level_zero_mocks.h"
+#include "pool.hpp"
+#include "gtest/gtest.h"
+
+// On MSVC disable C6285 warning produced by gtest:
+// (<non-zero constant> || <non-zero constant>) is always a non-zero constant.
+// Did you intend to use the bitwise-and operator?
+#ifdef _MSC_VER
+#pragma warning(disable : 6285)
+#endif
+
+using namespace testing;
+
+class PoolResidencyTestFixture : public Test {
+  protected:
+    umf_memory_pool_handle_t pool = nullptr;
+    const ze_device_handle_t OUR_DEVICE;
+    StrictMock<LevelZeroMock> l0mock;
+
+    PoolResidencyTestFixture()
+        : OUR_DEVICE(TestCreatePointer<ze_device_handle_t>(777)) {
+        *MockedLevelZeroTestEnvironment::l0interface = &l0mock;
+    }
+
+    void initializeMemoryPool(umf_memory_provider_handle_t provider) {
+
+        auto *params = static_cast<umf_disjoint_pool_params_handle_t>(
+            umf_test::defaultDisjointPoolConfig());
+
+        EXPECT_EQ(umfPoolCreate(umfDisjointPoolOps(), provider, params,
+                                UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &pool),
+                  UMF_RESULT_SUCCESS);
+
+        umf_test::defaultDisjointPoolConfigDestroy(params);
+    }
+
+    void SetUp() override {}
+    void TearDown() override {
+        if (pool != nullptr) {
+            EXPECT_CALL(l0mock, zeMemFree(CONTEXT, _))
+                .WillRepeatedly(Return(ZE_RESULT_SUCCESS));
+            umfPoolDestroy(pool);
+        }
+        Mock::VerifyAndClearExpectations(&l0mock);
+    }
+};
+
+TEST_F(PoolResidencyTestFixture,
+       initialResidentDevicesShouldBeUsedDuringAllocation) {
+    initializeMemoryPool(l0mock.initializeMemoryProviderWithResidentDevices(
+        OUR_DEVICE, {DEVICE_0, DEVICE_1}));
+
+    EXPECT_CALL(l0mock, zeMemAllocDevice(CONTEXT, _, _, _, OUR_DEVICE, _))
+        .WillOnce(
+            DoAll(SetArgPointee<5>(POINTER_0), Return(ZE_RESULT_SUCCESS)));
+
+    EXPECT_CALL(l0mock, zeContextMakeMemoryResident(CONTEXT, DEVICE_0, _, _))
+        .WillOnce(Return(ZE_RESULT_SUCCESS));
+    EXPECT_CALL(l0mock, zeContextMakeMemoryResident(CONTEXT, DEVICE_1, _, _))
+        .WillOnce(Return(ZE_RESULT_SUCCESS));
+
+    void *ptr = umfPoolMalloc(pool, 123);
+    EXPECT_EQ(ptr, POINTER_0);
+
+    umfPoolFree(pool, ptr);
+}
+
+TEST_F(PoolResidencyTestFixture,
+       addedResidentDevicesShouldBeUsedDuringAllocation) {
+    initializeMemoryPool(l0mock.initializeMemoryProviderWithResidentDevices(
+        OUR_DEVICE, {DEVICE_0}));
+
+    umf_memory_provider_handle_t provider = nullptr;
+    EXPECT_EQ(umfPoolGetMemoryProvider(pool, &provider), UMF_RESULT_SUCCESS);
+    umfLevelZeroMemoryProviderResidentDeviceChange(provider, DEVICE_4, true);
+
+    EXPECT_CALL(l0mock, zeMemAllocDevice(CONTEXT, _, _, _, OUR_DEVICE, _))
+        .WillOnce(
+            DoAll(SetArgPointee<5>(POINTER_0), Return(ZE_RESULT_SUCCESS)));
+    EXPECT_CALL(l0mock, zeContextMakeMemoryResident(CONTEXT, DEVICE_0, _, _))
+        .WillOnce(Return(ZE_RESULT_SUCCESS));
+    EXPECT_CALL(l0mock, zeContextMakeMemoryResident(CONTEXT, DEVICE_4, _, _))
+        .WillOnce(Return(ZE_RESULT_SUCCESS));
+
+    void *ptr = umfPoolMalloc(pool, 123);
+    EXPECT_EQ(ptr, POINTER_0);
+
+    umfPoolFree(pool, ptr);
+}
+
+TEST_F(PoolResidencyTestFixture,
+       existingAllocationsShouldBeMadeResidentOnAddedDevice) {
+    initializeMemoryPool(
+        l0mock.initializeMemoryProviderWithResidentDevices(OUR_DEVICE, {}));
+
+    EXPECT_CALL(l0mock, zeMemAllocDevice(CONTEXT, _, _, _, OUR_DEVICE, _))
+        .WillOnce(
+            DoAll(SetArgPointee<5>(POINTER_0), Return(ZE_RESULT_SUCCESS)));
+
+    void *ptr = umfPoolMalloc(pool, 123);
+    EXPECT_EQ(ptr, POINTER_0);
+
+    EXPECT_CALL(l0mock, zeContextMakeMemoryResident(CONTEXT, DEVICE_4, _, _))
+        .WillOnce(Return(ZE_RESULT_SUCCESS));
+
+    umf_memory_provider_handle_t provider = nullptr;
+    EXPECT_EQ(umfPoolGetMemoryProvider(pool, &provider), UMF_RESULT_SUCCESS);
+    umfLevelZeroMemoryProviderResidentDeviceChange(provider, DEVICE_4, true);
+
+    umfPoolFree(pool, ptr);
+}
+
+TEST_F(PoolResidencyTestFixture,
+       existingAllocationsShouldBeEvictedFromRemovedDevice) {
+    initializeMemoryPool(l0mock.initializeMemoryProviderWithResidentDevices(
+        OUR_DEVICE, {DEVICE_2, DEVICE_3}));
+
+    EXPECT_CALL(l0mock, zeMemAllocDevice(CONTEXT, _, _, _, OUR_DEVICE, _))
+        .WillOnce(
+            DoAll(SetArgPointee<5>(POINTER_0), Return(ZE_RESULT_SUCCESS)));
+    EXPECT_CALL(l0mock, zeContextMakeMemoryResident(CONTEXT, DEVICE_2, _, _))
+        .WillOnce(Return(ZE_RESULT_SUCCESS));
+    EXPECT_CALL(l0mock, zeContextMakeMemoryResident(CONTEXT, DEVICE_3, _, _))
+        .WillOnce(Return(ZE_RESULT_SUCCESS));
+
+    void *ptr = umfPoolMalloc(pool, 123);
+    EXPECT_EQ(ptr, POINTER_0);
+
+    EXPECT_CALL(l0mock, zeContextEvictMemory(CONTEXT, DEVICE_2, _, _))
+        .WillOnce(Return(ZE_RESULT_SUCCESS));
+
+    umf_memory_provider_handle_t provider = nullptr;
+    EXPECT_EQ(umfPoolGetMemoryProvider(pool, &provider), UMF_RESULT_SUCCESS);
+    umfLevelZeroMemoryProviderResidentDeviceChange(provider, DEVICE_2, false);
+
+    umfPoolFree(pool, ptr);
+}
+
+TEST_F(PoolResidencyTestFixture,
+       allocationShouldNotBeMadeResidentOnRemovedDevice) {
+    initializeMemoryPool(l0mock.initializeMemoryProviderWithResidentDevices(
+        OUR_DEVICE, {DEVICE_2}));
+
+    umf_memory_provider_handle_t provider = nullptr;
+    EXPECT_EQ(umfPoolGetMemoryProvider(pool, &provider), UMF_RESULT_SUCCESS);
+    umfLevelZeroMemoryProviderResidentDeviceChange(provider, DEVICE_2, false);
+
+    EXPECT_CALL(l0mock, zeMemAllocDevice(CONTEXT, _, _, _, OUR_DEVICE, _))
+        .WillOnce(
+            DoAll(SetArgPointee<5>(POINTER_0), Return(ZE_RESULT_SUCCESS)));
+    EXPECT_CALL(l0mock, zeContextMakeMemoryResident(CONTEXT, DEVICE_2, _, _))
+        .Times(0); // not called
+
+    void *ptr = umfPoolMalloc(pool, 123);
+    EXPECT_EQ(ptr, POINTER_0);
+
+    umfPoolFree(pool, ptr);
+}
+
+TEST_F(PoolResidencyTestFixture,
+       allocationThatFailedToBeMadeResidedShouldBeFreed) {
+    initializeMemoryPool(l0mock.initializeMemoryProviderWithResidentDevices(
+        OUR_DEVICE, {DEVICE_2}));
+
+    EXPECT_CALL(l0mock, zeMemAllocDevice(CONTEXT, _, _, _, OUR_DEVICE, _))
+        .WillOnce(
+            DoAll(SetArgPointee<5>(POINTER_0), Return(ZE_RESULT_SUCCESS)));
+    EXPECT_CALL(l0mock, zeContextMakeMemoryResident(CONTEXT, DEVICE_2, _, _))
+        .WillOnce(Return(ZE_RESULT_ERROR_DEVICE_LOST));
+    EXPECT_CALL(l0mock, zeMemFree(CONTEXT, _))
+        .WillOnce(Return(ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE));
+
+    void *ptr = umfPoolMalloc(pool, 16 * 1024 * 1024);
+    EXPECT_EQ(ptr, nullptr);
+
+    umfPoolFree(pool, ptr);
+}
+
+int main(int argc, char **argv) {
+    try {
+        InitGoogleTest(&argc, argv);
+        AddGlobalTestEnvironment(new MockedLevelZeroTestEnvironment);
+        return RUN_ALL_TESTS();
+    } catch (...) {
+        std::cerr << "Exception occurred." << std::endl;
+        return 1;
+    }
+}
diff --git a/test/pools/scalable_coarse_devdax.cpp b/test/pools/scalable_coarse_devdax.cpp
index 1bf77c61ce..83fa855279 100644
--- a/test/pools/scalable_coarse_devdax.cpp
+++ b/test/pools/scalable_coarse_devdax.cpp
@@ -1,45 +1,54 @@
-// 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
 
-#include "umf/pools/pool_scalable.h"
-#include "umf/providers/provider_devdax_memory.h"
+#include <umf/pools/pool_scalable.h>
+#include <umf/providers/provider_devdax_memory.h>
 
 #include "pool_coarse.hpp"
 
-using devdax_params_unique_handle_t =
-    std::unique_ptr<umf_devdax_memory_provider_params_t,
-                    decltype(&umfDevDaxMemoryProviderParamsDestroy)>;
+bool devDaxEnvSet() {
+    char *path = getenv("UMF_TESTS_DEVDAX_PATH");
+    char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
+    if (path == nullptr || path[0] == '\0' || size == nullptr ||
+        size[0] == '\0') {
+        return false;
+    }
 
-devdax_params_unique_handle_t create_devdax_params() {
+    return true;
+}
+
+void *createDevDaxParams() {
     char *path = getenv("UMF_TESTS_DEVDAX_PATH");
     char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
-    if (path == nullptr || path[0] == 0 || size == nullptr || size[0] == 0) {
-        return devdax_params_unique_handle_t(
-            nullptr, &umfDevDaxMemoryProviderParamsDestroy);
+    if (path == nullptr || path[0] == '\0' || size == nullptr ||
+        size[0] == '\0') {
+        return nullptr;
     }
 
     umf_devdax_memory_provider_params_handle_t params = NULL;
     umf_result_t res =
-        umfDevDaxMemoryProviderParamsCreate(&params, path, atol(size));
+        umfDevDaxMemoryProviderParamsCreate(path, atol(size), &params);
     if (res != UMF_RESULT_SUCCESS) {
         throw std::runtime_error(
             "Failed to create DevDax Memory Provider params");
     }
 
-    return devdax_params_unique_handle_t(params,
-                                         &umfDevDaxMemoryProviderParamsDestroy);
+    return params;
 }
 
-auto coarseParams = umfCoarseMemoryProviderParamsDefault();
-auto devdaxParams = create_devdax_params();
+umf_result_t destroyDevDaxParams(void *params) {
+    return umfDevDaxMemoryProviderParamsDestroy(
+        (umf_devdax_memory_provider_params_handle_t)params);
+}
 
 static std::vector<poolCreateExtParams> poolParamsList =
-    devdaxParams.get()
-        ? std::vector<poolCreateExtParams>{poolCreateExtParams{
-              umfScalablePoolOps(), nullptr, umfDevDaxMemoryProviderOps(),
-              devdaxParams.get(), &coarseParams}}
-        : std::vector<poolCreateExtParams>{};
+    devDaxEnvSet() ? std::vector<poolCreateExtParams>{poolCreateExtParams{
+                         umfScalablePoolOps(), nullptr, nullptr,
+                         umfDevDaxMemoryProviderOps(), createDevDaxParams,
+                         destroyDevDaxParams}}
+                   : std::vector<poolCreateExtParams>{};
 
 INSTANTIATE_TEST_SUITE_P(scalableCoarseDevDaxTest, umfPoolTest,
-                         ::testing::ValuesIn(poolParamsList));
+                         ::testing::ValuesIn(poolParamsList),
+                         poolCreateExtParamsNameGen);
diff --git a/test/pools/scalable_coarse_file.cpp b/test/pools/scalable_coarse_file.cpp
index b45c112be2..778a47202c 100644
--- a/test/pools/scalable_coarse_file.cpp
+++ b/test/pools/scalable_coarse_file.cpp
@@ -1,33 +1,32 @@
-// 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
 
-#include "umf/pools/pool_scalable.h"
-#include "umf/providers/provider_file_memory.h"
+#include <umf/pools/pool_scalable.h>
+#include <umf/providers/provider_file_memory.h>
 
 #include "pool_coarse.hpp"
 
-using file_params_unique_handle_t =
-    std::unique_ptr<umf_file_memory_provider_params_t,
-                    decltype(&umfFileMemoryProviderParamsDestroy)>;
-
-file_params_unique_handle_t get_file_params_default(char *path) {
+void *getFileParamsDefault() {
     umf_file_memory_provider_params_handle_t file_params = NULL;
-    umf_result_t res = umfFileMemoryProviderParamsCreate(&file_params, path);
+    umf_result_t res =
+        umfFileMemoryProviderParamsCreate(FILE_PATH, &file_params);
     if (res != UMF_RESULT_SUCCESS) {
         throw std::runtime_error(
             "Failed to create File Memory Provider params");
     }
 
-    return file_params_unique_handle_t(file_params,
-                                       &umfFileMemoryProviderParamsDestroy);
+    return file_params;
 }
 
-auto coarseParams = umfCoarseMemoryProviderParamsDefault();
-file_params_unique_handle_t fileParams = get_file_params_default(FILE_PATH);
+umf_result_t destroyFileParams(void *params) {
+    return umfFileMemoryProviderParamsDestroy(
+        (umf_file_memory_provider_params_handle_t)params);
+}
 
 INSTANTIATE_TEST_SUITE_P(scalableCoarseFileTest, umfPoolTest,
                          ::testing::Values(poolCreateExtParams{
-                             umfScalablePoolOps(), nullptr,
-                             umfFileMemoryProviderOps(), fileParams.get(),
-                             &coarseParams}));
+                             umfScalablePoolOps(), nullptr, nullptr,
+                             umfFileMemoryProviderOps(), getFileParamsDefault,
+                             destroyFileParams}),
+                         poolCreateExtParamsNameGen);
diff --git a/test/pools/scalable_pool.cpp b/test/pools/scalable_pool.cpp
index 3edacd965c..d34e16826c 100644
--- a/test/pools/scalable_pool.cpp
+++ b/test/pools/scalable_pool.cpp
@@ -1,34 +1,35 @@
-// Copyright (C) 2023 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/pools/pool_scalable.h"
-#include "umf/providers/provider_os_memory.h"
+#include <umf/pools/pool_scalable.h>
+#include <umf/providers/provider_os_memory.h>
 
 #include "pool.hpp"
 #include "poolFixtures.hpp"
 #include "provider.hpp"
 
-using os_params_unique_handle_t =
-    std::unique_ptr<umf_os_memory_provider_params_t,
-                    decltype(&umfOsMemoryProviderParamsDestroy)>;
-
-os_params_unique_handle_t createOsMemoryProviderParams() {
+void *createOsMemoryProviderParams() {
     umf_os_memory_provider_params_handle_t params = nullptr;
     umf_result_t res = umfOsMemoryProviderParamsCreate(&params);
     if (res != UMF_RESULT_SUCCESS) {
         throw std::runtime_error("Failed to create os memory provider params");
     }
 
-    return os_params_unique_handle_t(params, &umfOsMemoryProviderParamsDestroy);
+    return params;
+}
+
+umf_result_t destroyOsMemoryProviderParams(void *params) {
+    return umfOsMemoryProviderParamsDestroy(
+        (umf_os_memory_provider_params_handle_t)params);
 }
-auto defaultParams = createOsMemoryProviderParams();
 
-INSTANTIATE_TEST_SUITE_P(scalablePoolTest, umfPoolTest,
-                         ::testing::Values(poolCreateExtParams{
-                             umfScalablePoolOps(), nullptr,
-                             umfOsMemoryProviderOps(), defaultParams.get(),
-                             nullptr}));
+INSTANTIATE_TEST_SUITE_P(
+    scalablePoolTest, umfPoolTest,
+    ::testing::Values(poolCreateExtParams{
+        umfScalablePoolOps(), nullptr, nullptr, umfOsMemoryProviderOps(),
+        createOsMemoryProviderParams, destroyOsMemoryProviderParams}),
+    poolCreateExtParamsNameGen);
 
 using scalablePoolParams = std::tuple<size_t, bool>;
 struct umfScalablePoolParamsTest
@@ -43,7 +44,7 @@ struct umfScalablePoolParamsTest
     struct provider_validator : public umf_test::provider_ba_global {
         using base_provider = umf_test::provider_ba_global;
 
-        umf_result_t initialize(validation_params_t *params) {
+        umf_result_t initialize(const validation_params_t *params) {
             EXPECT_NE(params, nullptr);
             expected_params = params;
             return UMF_RESULT_SUCCESS;
@@ -57,11 +58,11 @@ struct umfScalablePoolParamsTest
             return base_provider::free(ptr, size);
         }
 
-        validation_params_t *expected_params;
+        const validation_params_t *expected_params;
     };
 
     static constexpr umf_memory_provider_ops_t VALIDATOR_PROVIDER_OPS =
-        umf::providerMakeCOps<provider_validator, validation_params_t>();
+        umf_test::providerMakeCOps<provider_validator, validation_params_t>();
 
     umfScalablePoolParamsTest() : expected_params{0, false}, params(nullptr) {}
     void SetUp() override {
@@ -82,7 +83,7 @@ struct umfScalablePoolParamsTest
         test::TearDown();
     }
 
-    umf::pool_unique_handle_t makePool() {
+    umf_test::pool_unique_handle_t makePool() {
         umf_memory_provider_handle_t hProvider = nullptr;
         umf_memory_pool_handle_t hPool = nullptr;
 
@@ -94,7 +95,7 @@ struct umfScalablePoolParamsTest
                             UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &hPool);
         EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
-        return umf::pool_unique_handle_t(hPool, &umfPoolDestroy);
+        return umf_test::pool_unique_handle_t(hPool, &umfPoolDestroy);
     }
 
     void allocFreeFlow() {
@@ -165,4 +166,69 @@ INSTANTIATE_TEST_SUITE_P(
     scalablePoolTest, umfScalablePoolParamsTest,
     testing::Combine(testing::Values(2 * 1024 * 1024, 3 * 1024 * 1024,
                                      4 * 1024 * 1024, 5 * 1024 * 1024),
-                     testing::Values(false, true)));
+                     testing::Values(false, true)),
+    ([](auto const &info) -> std::string {
+        return "scalable_granularity_" +
+               std::to_string(std::get<0>(info.param)) + "_keep_all_memory" +
+               (std::get<1>(info.param) ? "_true" : "_false");
+    }));
+
+TEST(scalablePoolTest, scalablePoolName) {
+    umf_memory_pool_handle_t pool = nullptr;
+    umf_os_memory_provider_params_handle_t provider_params = nullptr;
+    umf_memory_provider_handle_t provider = nullptr;
+
+    umf_result_t ret = umfOsMemoryProviderParamsCreate(&provider_params);
+    ret = umfMemoryProviderCreate(umfOsMemoryProviderOps(), provider_params,
+                                  &provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfPoolCreate(umfScalablePoolOps(), provider, nullptr, 0, &pool);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    const char *name = nullptr;
+    ret = umfPoolGetName(pool, &name);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, "scalable");
+
+    umfPoolDestroy(pool);
+    umfMemoryProviderDestroy(provider);
+    umfOsMemoryProviderParamsDestroy(provider_params);
+}
+
+TEST(scalablePoolTest, scalablePoolCustomName) {
+    umf_memory_pool_handle_t pool = nullptr;
+    umf_os_memory_provider_params_handle_t provider_params = nullptr;
+    umf_memory_provider_handle_t provider = nullptr;
+
+    auto ret = umfOsMemoryProviderParamsCreate(&provider_params);
+    ret = umfMemoryProviderCreate(umfOsMemoryProviderOps(), provider_params,
+                                  &provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    umf_scalable_pool_params_handle_t params = nullptr;
+    ret = umfScalablePoolParamsCreate(&params);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(umfScalablePoolParamsSetName(params, "custom_scalable"),
+              UMF_RESULT_SUCCESS);
+
+    ret = umfPoolCreate(umfScalablePoolOps(), provider, params, 0, &pool);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    const char *name = nullptr;
+    ret = umfPoolGetName(pool, &name);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, "custom_scalable");
+
+    umfPoolDestroy(pool);
+    umfScalablePoolParamsDestroy(params);
+    umfMemoryProviderDestroy(provider);
+    umfOsMemoryProviderParamsDestroy(provider_params);
+}
+
+TEST(scalablePoolTest, default_name_null_handle) {
+    const char *name = nullptr;
+    EXPECT_EQ(umfScalablePoolOps()->get_name(nullptr, &name),
+              UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, "scalable");
+}
diff --git a/test/properties/provider_properties.cpp b/test/properties/provider_properties.cpp
new file mode 100644
index 0000000000..73542b528a
--- /dev/null
+++ b/test/properties/provider_properties.cpp
@@ -0,0 +1,167 @@
+/*
+ * 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/pools/pool_proxy.h>
+
+#include "memory_properties_internal.h"
+#include "provider.hpp"
+#include "provider_properties.hpp"
+
+void createFixedProvider(umf_memory_provider_handle_t *out_provider,
+                         void *out_data) {
+    constexpr size_t buffer_size = 1024 * 1024;
+
+    void *memory_buffer = malloc(buffer_size);
+    ASSERT_NE(memory_buffer, nullptr);
+
+    umf_fixed_memory_provider_params_handle_t params = nullptr;
+    umf_result_t res =
+        umfFixedMemoryProviderParamsCreate(memory_buffer, buffer_size, &params);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    ASSERT_NE(params, nullptr);
+
+    res = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
+                                  out_provider);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    ASSERT_NE(out_provider, nullptr);
+
+    umfFixedMemoryProviderParamsDestroy(params);
+
+    *(uintptr_t *)out_data = (uintptr_t)memory_buffer;
+}
+
+void destroyFixedProvider(umf_memory_provider_handle_t provider, void *data) {
+    umfMemoryProviderDestroy(provider);
+    free(data);
+}
+
+void createOsMemoryProvider(umf_memory_provider_handle_t *out_provider,
+                            void *out_data) {
+
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+    umf_result_t res =
+        umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    ASSERT_NE(os_memory_provider_params, nullptr);
+
+    umf_memory_provider_handle_t os_memory_provider = nullptr;
+    res =
+        umfMemoryProviderCreate(umfOsMemoryProviderOps(),
+                                os_memory_provider_params, &os_memory_provider);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    ASSERT_NE(os_memory_provider, nullptr);
+
+    res = umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    *out_provider = os_memory_provider;
+    *(uintptr_t *)out_data = (uintptr_t)NULL;
+}
+
+void destroyOsMemoryProvider(umf_memory_provider_handle_t provider,
+                             void *data) {
+    (void)data; // unused
+
+    umfMemoryProviderDestroy(provider);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    providerPropsTest, ProviderPropsTest,
+    ::testing::Values(testParams{createFixedProvider, destroyFixedProvider,
+                                 "fixedProvider"},
+                      testParams{createOsMemoryProvider,
+                                 destroyOsMemoryProvider, "osMemoryProvider"}),
+    nameGen);
+
+TEST_F(test, CustomPropsTest) {
+    const uint64_t custom_property_id = UMF_MEMORY_PROPERTY_MAX_RESERVED + 1;
+
+    struct memory_provider : public umf_test::provider_base_t {
+        umf_result_t alloc(size_t size, size_t alignment, void **ptr) noexcept {
+            *ptr = umf_ba_global_aligned_alloc(size, alignment);
+            return UMF_RESULT_SUCCESS;
+        }
+
+        umf_result_t free(void *ptr, [[maybe_unused]] size_t size) noexcept {
+            umf_ba_global_free(ptr);
+            return UMF_RESULT_SUCCESS;
+        }
+
+        umf_result_t
+        get_min_page_size([[maybe_unused]] const void *ptr,
+                          [[maybe_unused]] size_t *pageSize) noexcept {
+            *pageSize = 1024;
+            return UMF_RESULT_SUCCESS;
+        }
+
+        umf_result_t ext_get_allocation_properties(
+            const void *ptr, umf_memory_property_id_t memory_property_id,
+            void *value) {
+
+            (void)ptr; // unused
+
+            if (memory_property_id == custom_property_id) {
+                *(uint64_t *)value = 42; // Custom value for the property
+                return UMF_RESULT_SUCCESS;
+            }
+
+            return umf_test::provider_base_t::ext_get_allocation_properties(
+                ptr, memory_property_id, value);
+        }
+
+        umf_result_t ext_get_allocation_properties_size(
+            umf_memory_property_id_t memory_property_id, size_t *size) {
+            if (memory_property_id == custom_property_id) {
+                *size = sizeof(uint64_t);
+                return UMF_RESULT_SUCCESS;
+            }
+            return umf_test::provider_base_t::
+                ext_get_allocation_properties_size(memory_property_id, size);
+        }
+    };
+
+    umf_memory_provider_ops_t provider_ops =
+        umf_test::providerMakeCOps<memory_provider, void>();
+
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t res =
+        umfMemoryProviderCreate(&provider_ops, nullptr, &provider);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    umf_memory_pool_handle_t pool = nullptr;
+    res = umfPoolCreate(umfProxyPoolOps(), provider, nullptr,
+                        UMF_POOL_CREATE_FLAG_NONE, &pool);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    ASSERT_NE(pool, nullptr);
+
+    void *ptr = umfPoolMalloc(pool, 1024);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    umf_memory_properties_handle_t properties = nullptr;
+    res = umfGetMemoryPropertiesHandle(ptr, &properties);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    ASSERT_NE(properties, nullptr);
+
+    // get value of the custom property from the properties handle
+    uint64_t value2 = 0;
+    res = umfGetMemoryProperty(properties,
+                               (umf_memory_property_id_t)custom_property_id,
+                               &value2, sizeof(value2));
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(value2, 42);
+
+    res = umfPoolFree(pool, ptr);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfPoolDestroy(pool);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfMemoryProviderDestroy(provider);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+}
diff --git a/test/properties/provider_properties.hpp b/test/properties/provider_properties.hpp
new file mode 100644
index 0000000000..2f51ad947f
--- /dev/null
+++ b/test/properties/provider_properties.hpp
@@ -0,0 +1,239 @@
+/*
+ * 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/experimental/memory_properties.h>
+#include <umf/pools/pool_proxy.h>
+#include <umf/providers/provider_fixed_memory.h>
+#include <umf/providers/provider_os_memory.h>
+
+#include "base.hpp"
+#include "test_helpers.h"
+
+using umf_test::test;
+
+using testParams =
+    std::tuple<std::function<void(umf_memory_provider_handle_t *, void *)>,
+               std::function<void(umf_memory_provider_handle_t, void *)>,
+               const char *>;
+
+std::string nameGen(const testing::TestParamInfo<testParams> param) {
+    return std::get<2>(param.param);
+}
+
+struct ProviderPropsTest : umf_test::test,
+                           ::testing::WithParamInterface<testParams> {
+    void SetUp() override {
+        test::SetUp();
+
+        auto [create_fun, destroy_fun, name] = this->GetParam();
+        provider_create = std::move(create_fun);
+        provider_destroy = std::move(destroy_fun);
+        (void)name; // unused
+
+        provider_create(&provider, &data);
+        ASSERT_NE(provider, nullptr);
+
+        umf_result_t umf_result =
+            umfPoolCreate(umfProxyPoolOps(), provider, nullptr, 0, &pool);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+
+    void TearDown() override {
+        umfPoolDestroy(pool);
+        provider_destroy(provider, data);
+        test::TearDown();
+    }
+
+    umf_memory_provider_handle_t provider;
+    umf_memory_pool_handle_t pool;
+
+    std::function<void(umf_memory_provider_handle_t *, void *)> provider_create;
+    std::function<void(umf_memory_provider_handle_t, void *)> provider_destroy;
+    void *data;
+};
+
+TEST_P(ProviderPropsTest, genericProps) {
+    umf_result_t umf_result;
+    const size_t alloc_size = 8;
+
+    void *ptr = umfPoolMalloc(pool, alloc_size);
+    ASSERT_NE(ptr, nullptr);
+
+    umf_memory_properties_handle_t props_handle = nullptr;
+    umf_result = umfGetMemoryPropertiesHandle(ptr, &props_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(props_handle, nullptr);
+
+    umf_memory_provider_handle_t param_provider = nullptr;
+    umf_result =
+        umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_PROVIDER_HANDLE,
+                             &param_provider, sizeof(param_provider));
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(param_provider, provider);
+
+    umf_memory_pool_handle_t param_pool = nullptr;
+    umf_result =
+        umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_POOL_HANDLE,
+                             &param_pool, sizeof(param_pool));
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(param_pool, pool);
+
+    void *base_address = nullptr;
+    umf_result =
+        umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_BASE_ADDRESS,
+                             &base_address, sizeof(base_address));
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(base_address, ptr);
+
+    size_t size = 0;
+    umf_result = umfGetMemoryProperty(
+        props_handle, UMF_MEMORY_PROPERTY_BASE_SIZE, &size, sizeof(size));
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(size, alloc_size);
+
+    uint64_t buffer_id = 0;
+    umf_result =
+        umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_BUFFER_ID,
+                             &buffer_id, sizeof(buffer_id));
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_GE(buffer_id, 0);
+
+    umf_result = umfPoolFree(pool, ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(ProviderPropsTest, baseAddressFromMiddle) {
+    umf_result_t umf_result;
+    const size_t alloc_size = 8;
+
+    void *ptr = umfPoolMalloc(pool, alloc_size);
+    ASSERT_NE(ptr, nullptr);
+
+    void *ptr_mid = (void *)((uintptr_t)ptr + (alloc_size / 2));
+    umf_memory_properties_handle_t props_handle = nullptr;
+    umf_result = umfGetMemoryPropertiesHandle(ptr_mid, &props_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(props_handle, nullptr);
+
+    uintptr_t param_base_address = 0;
+    umf_result =
+        umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_BASE_ADDRESS,
+                             &param_base_address, sizeof(param_base_address));
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(param_base_address, (uintptr_t)ptr);
+
+    umf_result = umfPoolFree(pool, ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(ProviderPropsTest, uniqueBufferId) {
+    size_t alloc_size = 8;
+    size_t num_allocs = 10;
+    umf_result_t umf_result;
+    std::set<uint64_t> buffer_ids;
+
+    for (size_t i = 0; i < num_allocs; ++i) {
+        void *ptr = umfPoolMalloc(pool, alloc_size);
+        ASSERT_NE(ptr, nullptr);
+
+        umf_memory_properties_handle_t props_handle = nullptr;
+        umf_result = umfGetMemoryPropertiesHandle(ptr, &props_handle);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ASSERT_NE(props_handle, nullptr);
+
+        uint64_t buffer_id = 0;
+        umf_result =
+            umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_BUFFER_ID,
+                                 &buffer_id, sizeof(buffer_id));
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ASSERT_GE(buffer_id, 0);
+
+        // Ensure that the buffer ID is unique by inserting it into a set and
+        // checking if it was already present
+        ASSERT_TRUE(buffer_ids.find(buffer_id) == buffer_ids.end());
+        ASSERT_TRUE(buffer_ids.insert(buffer_id).second);
+
+        umf_result = umfPoolFree(pool, ptr);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+}
+
+// Negative tests
+
+TEST_P(ProviderPropsTest, invalidPointer) {
+    umf_memory_properties_handle_t props_handle = nullptr;
+    umf_result_t umf_result =
+        umfGetMemoryPropertiesHandle(nullptr, &props_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(props_handle, nullptr);
+
+    uintptr_t invalid_ptr = 0xdeadbeef;
+    umf_result =
+        umfGetMemoryPropertiesHandle((void *)invalid_ptr, &props_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(props_handle, nullptr);
+}
+
+TEST_P(ProviderPropsTest, invalidPropertyId) {
+    void *ptr = umfPoolMalloc(pool, 8);
+    ASSERT_NE(ptr, nullptr);
+
+    umf_memory_properties_handle_t props_handle = nullptr;
+    umf_result_t res = umfGetMemoryPropertiesHandle(ptr, &props_handle);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    ASSERT_NE(props_handle, nullptr);
+
+    void *value = nullptr;
+    res = umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_INVALID,
+                               &value, sizeof(value));
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfPoolFree(pool, ptr);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(ProviderPropsTest, invalidPropertyValue) {
+    void *ptr = umfPoolMalloc(pool, 8);
+    ASSERT_NE(ptr, nullptr);
+
+    umf_memory_properties_handle_t props_handle = nullptr;
+    umf_result_t res = umfGetMemoryPropertiesHandle(ptr, &props_handle);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    ASSERT_NE(props_handle, nullptr);
+
+    res = umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_BASE_ADDRESS,
+                               NULL, sizeof(int));
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfPoolFree(pool, ptr);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(ProviderPropsTest, invalidPropertySize) {
+    void *ptr = umfPoolMalloc(pool, 8);
+    ASSERT_NE(ptr, nullptr);
+
+    umf_memory_properties_handle_t props_handle = nullptr;
+    umf_result_t res = umfGetMemoryPropertiesHandle(ptr, &props_handle);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    ASSERT_NE(props_handle, nullptr);
+
+    int value = 0;
+    res = umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_BASE_ADDRESS,
+                               &value, size_t(0));
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfPoolFree(pool, ptr);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(ProviderPropsTest, nullPropertiesHandle) {
+    int val = 0;
+    umf_result_t res = umfGetMemoryProperty(
+        NULL, UMF_MEMORY_PROPERTY_BASE_ADDRESS, &val, sizeof(val));
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
diff --git a/test/properties/provider_properties_cuda.cpp b/test/properties/provider_properties_cuda.cpp
new file mode 100644
index 0000000000..4ed5b8c02e
--- /dev/null
+++ b/test/properties/provider_properties_cuda.cpp
@@ -0,0 +1,64 @@
+/*
+ * 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 "provider_properties.hpp"
+#include "providers/cuda_helpers.h"
+
+void createCudaMemoryProvider(umf_memory_provider_handle_t *out_provider,
+                              void *out_data) {
+    CUdevice hDevice = -1;
+    CUcontext hContext = NULL;
+
+    int ret = init_cuda();
+    ASSERT_EQ(ret, 0);
+
+    ret = get_cuda_device(&hDevice);
+    ASSERT_EQ(ret, 0);
+    ASSERT_NE(hDevice, -1);
+
+    ret = create_context(hDevice, &hContext);
+    ASSERT_EQ(ret, 0);
+    ASSERT_NE(hContext, nullptr);
+
+    umf_cuda_memory_provider_params_handle_t cu_params = NULL;
+    umf_result_t umf_result = umfCUDAMemoryProviderParamsCreate(&cu_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(cu_params, nullptr);
+
+    umf_result = umfCUDAMemoryProviderParamsSetContext(cu_params, hContext);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfCUDAMemoryProviderParamsSetDevice(cu_params, hDevice);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfCUDAMemoryProviderParamsSetMemoryType(
+        cu_params, UMF_MEMORY_TYPE_DEVICE);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result = umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), cu_params,
+                                         &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    umfCUDAMemoryProviderParamsDestroy(cu_params);
+
+    *out_provider = provider;
+    *(uintptr_t *)out_data = (uintptr_t)hContext;
+}
+
+void destroyCudaMemoryProvider(umf_memory_provider_handle_t provider,
+                               void *data) {
+    destroy_context((CUcontext)data);
+    umfMemoryProviderDestroy(provider);
+}
+
+INSTANTIATE_TEST_SUITE_P(providerPropsTest, ProviderPropsTest,
+                         ::testing::Values(testParams{createCudaMemoryProvider,
+                                                      destroyCudaMemoryProvider,
+                                                      "cudaMemoryProvider"}),
+                         nameGen);
diff --git a/test/properties/provider_properties_level_zero.cpp b/test/properties/provider_properties_level_zero.cpp
new file mode 100644
index 0000000000..aa420cf500
--- /dev/null
+++ b/test/properties/provider_properties_level_zero.cpp
@@ -0,0 +1,66 @@
+/*
+ * 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 "provider_properties.hpp"
+#include "utils/utils_level_zero.h"
+
+void levelZeroMemoryProviderCreate(umf_memory_provider_handle_t *out_provider,
+                                   void *out_data) {
+
+    ze_driver_handle_t hDriver = nullptr;
+    ze_device_handle_t hDevice = nullptr;
+    ze_context_handle_t hContext = nullptr;
+    uint32_t driver_idx = 0;
+
+    int ret = utils_ze_init_level_zero();
+    ASSERT_EQ(ret, 0);
+
+    ret = utils_ze_find_driver_with_gpu(&driver_idx, &hDriver);
+    ASSERT_EQ(ret, 0);
+
+    ret = utils_ze_find_gpu_device(hDriver, &hDevice);
+    ASSERT_EQ(ret, 0);
+
+    ret = utils_ze_create_context(hDriver, &hContext);
+    ASSERT_EQ(ret, 0);
+
+    umf_level_zero_memory_provider_params_handle_t params = nullptr;
+    umf_result_t result = umfLevelZeroMemoryProviderParamsCreate(&params);
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    result = umfLevelZeroMemoryProviderParamsSetContext(params, hContext);
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    result = umfLevelZeroMemoryProviderParamsSetDevice(params, hDevice);
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    result = umfLevelZeroMemoryProviderParamsSetMemoryType(
+        params, UMF_MEMORY_TYPE_DEVICE);
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t umf_result = umfMemoryProviderCreate(
+        umfLevelZeroMemoryProviderOps(), params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    result = umfLevelZeroMemoryProviderParamsDestroy(params);
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+
+    *out_provider = provider;
+    *(uintptr_t *)out_data = (uintptr_t)hContext;
+}
+
+void levelZeroMemoryProviderDestroy(umf_memory_provider_handle_t provider,
+                                    void *data) {
+    umfMemoryProviderDestroy(provider);
+    utils_ze_destroy_context((ze_context_handle_t)data);
+}
+
+INSTANTIATE_TEST_SUITE_P(providerPropsTest, ProviderPropsTest,
+                         ::testing::Values(testParams{
+                             levelZeroMemoryProviderCreate,
+                             levelZeroMemoryProviderDestroy,
+                             "levelZeroProvider"}),
+                         nameGen);
diff --git a/test/provider_coarse.cpp b/test/provider_coarse.cpp
deleted file mode 100644
index c2de4c06a9..0000000000
--- a/test/provider_coarse.cpp
+++ /dev/null
@@ -1,668 +0,0 @@
-/*
- * Copyright (C) 2023-2024 Intel Corporation
- *
- * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-*/
-
-#include <random>
-
-#include "provider.hpp"
-
-#include <umf/providers/provider_coarse.h>
-
-using umf_test::KB;
-using umf_test::MB;
-using umf_test::test;
-
-#define GetStats umfCoarseMemoryProviderGetStats
-
-#define UPSTREAM_NAME "umf_ba_global"
-#define BASE_NAME "coarse"
-#define COARSE_NAME BASE_NAME " (" UPSTREAM_NAME ")"
-
-umf_memory_provider_ops_t UMF_MALLOC_MEMORY_PROVIDER_OPS =
-    umf::providerMakeCOps<umf_test::provider_ba_global, void>();
-
-struct CoarseWithMemoryStrategyTest
-    : umf_test::test,
-      ::testing::WithParamInterface<coarse_memory_provider_strategy_t> {
-    void SetUp() override {
-        test::SetUp();
-        allocation_strategy = this->GetParam();
-    }
-
-    coarse_memory_provider_strategy_t allocation_strategy;
-};
-
-INSTANTIATE_TEST_SUITE_P(
-    CoarseWithMemoryStrategyTest, CoarseWithMemoryStrategyTest,
-    ::testing::Values(UMF_COARSE_MEMORY_STRATEGY_FASTEST,
-                      UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE,
-                      UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE));
-
-TEST_F(test, coarseProvider_name_upstream) {
-    umf_memory_provider_handle_t malloc_memory_provider;
-    umf_result_t umf_result;
-
-    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
-                                         &malloc_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(malloc_memory_provider, nullptr);
-
-    const size_t init_buffer_size = 20 * MB;
-
-    coarse_memory_provider_params_t coarse_memory_provider_params;
-    // make sure there are no undefined members - prevent a UB
-    memset(&coarse_memory_provider_params, 0,
-           sizeof(coarse_memory_provider_params));
-    coarse_memory_provider_params.upstream_memory_provider =
-        malloc_memory_provider;
-    coarse_memory_provider_params.destroy_upstream_memory_provider = true;
-    coarse_memory_provider_params.immediate_init_from_upstream = true;
-    coarse_memory_provider_params.init_buffer = nullptr;
-    coarse_memory_provider_params.init_buffer_size = init_buffer_size;
-
-    umf_memory_provider_handle_t coarse_memory_provider;
-    umf_result = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(),
-                                         &coarse_memory_provider_params,
-                                         &coarse_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(coarse_memory_provider, nullptr);
-
-    size_t minPageSize = 0;
-    umf_result = umfMemoryProviderGetMinPageSize(coarse_memory_provider,
-                                                 nullptr, &minPageSize);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_UNKNOWN);
-    ASSERT_EQ(minPageSize, 0);
-
-    size_t pageSize = 0;
-    umf_result = umfMemoryProviderGetRecommendedPageSize(
-        coarse_memory_provider, minPageSize, &pageSize);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_UNKNOWN);
-    ASSERT_EQ(pageSize, minPageSize);
-
-    ASSERT_EQ(
-        strcmp(umfMemoryProviderGetName(coarse_memory_provider), COARSE_NAME),
-        0);
-
-    umfMemoryProviderDestroy(coarse_memory_provider);
-    // malloc_memory_provider has already been destroyed
-    // by umfMemoryProviderDestroy(coarse_memory_provider), because:
-    // coarse_memory_provider_params.destroy_upstream_memory_provider = true;
-}
-
-TEST_F(test, coarseProvider_name_no_upstream) {
-    umf_result_t umf_result;
-
-    const size_t init_buffer_size = 20 * MB;
-
-    // preallocate some memory and initialize the vector with zeros
-    std::vector<char> buffer(init_buffer_size, 0);
-    void *buf = (void *)buffer.data();
-    ASSERT_NE(buf, nullptr);
-
-    coarse_memory_provider_params_t coarse_memory_provider_params;
-    // make sure there are no undefined members - prevent a UB
-    memset(&coarse_memory_provider_params, 0,
-           sizeof(coarse_memory_provider_params));
-    coarse_memory_provider_params.upstream_memory_provider = nullptr;
-    coarse_memory_provider_params.immediate_init_from_upstream = false;
-    coarse_memory_provider_params.init_buffer = buf;
-    coarse_memory_provider_params.init_buffer_size = init_buffer_size;
-
-    umf_memory_provider_handle_t coarse_memory_provider;
-    umf_result = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(),
-                                         &coarse_memory_provider_params,
-                                         &coarse_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(coarse_memory_provider, nullptr);
-
-    size_t minPageSize = 0;
-    umf_result = umfMemoryProviderGetMinPageSize(coarse_memory_provider,
-                                                 nullptr, &minPageSize);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_GT(minPageSize, 0);
-
-    size_t pageSize = 0;
-    umf_result = umfMemoryProviderGetRecommendedPageSize(
-        coarse_memory_provider, minPageSize, &pageSize);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_GE(pageSize, minPageSize);
-
-    ASSERT_EQ(
-        strcmp(umfMemoryProviderGetName(coarse_memory_provider), BASE_NAME), 0);
-
-    umfMemoryProviderDestroy(coarse_memory_provider);
-}
-
-// negative tests
-
-TEST_P(CoarseWithMemoryStrategyTest, coarseProvider_null_stats) {
-    ASSERT_EQ(GetStats(nullptr).alloc_size, 0);
-    ASSERT_EQ(GetStats(nullptr).used_size, 0);
-    ASSERT_EQ(GetStats(nullptr).num_upstream_blocks, 0);
-    ASSERT_EQ(GetStats(nullptr).num_all_blocks, 0);
-    ASSERT_EQ(GetStats(nullptr).num_free_blocks, 0);
-}
-
-// wrong NULL parameters
-TEST_P(CoarseWithMemoryStrategyTest, coarseProvider_NULL_params) {
-    umf_result_t umf_result;
-
-    umf_memory_provider_handle_t coarse_memory_provider = nullptr;
-    umf_result = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(), nullptr,
-                                         &coarse_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-    ASSERT_EQ(coarse_memory_provider, nullptr);
-}
-
-// wrong parameters: given no upstream_memory_provider
-// nor init_buffer while exactly one of them must be set
-TEST_P(CoarseWithMemoryStrategyTest, coarseProvider_wrong_params_0) {
-    umf_result_t umf_result;
-
-    coarse_memory_provider_params_t coarse_memory_provider_params;
-    // make sure there are no undefined members - prevent a UB
-    memset(&coarse_memory_provider_params, 0,
-           sizeof(coarse_memory_provider_params));
-    coarse_memory_provider_params.allocation_strategy = allocation_strategy;
-    coarse_memory_provider_params.upstream_memory_provider = nullptr;
-    coarse_memory_provider_params.immediate_init_from_upstream = false;
-    coarse_memory_provider_params.init_buffer = nullptr;
-    coarse_memory_provider_params.init_buffer_size = 0;
-
-    umf_memory_provider_handle_t coarse_memory_provider = nullptr;
-    umf_result = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(),
-                                         &coarse_memory_provider_params,
-                                         &coarse_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-    ASSERT_EQ(coarse_memory_provider, nullptr);
-}
-
-// wrong parameters: given both an upstream_memory_provider
-// and an init_buffer while only one of them is allowed
-TEST_P(CoarseWithMemoryStrategyTest, coarseProvider_wrong_params_1) {
-    umf_memory_provider_handle_t malloc_memory_provider;
-    umf_result_t umf_result;
-
-    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
-                                         &malloc_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(malloc_memory_provider, nullptr);
-
-    const size_t init_buffer_size = 20 * MB;
-
-    // preallocate some memory and initialize the vector with zeros
-    std::vector<char> buffer(init_buffer_size, 0);
-    void *buf = (void *)buffer.data();
-    ASSERT_NE(buf, nullptr);
-
-    coarse_memory_provider_params_t coarse_memory_provider_params;
-    // make sure there are no undefined members - prevent a UB
-    memset(&coarse_memory_provider_params, 0,
-           sizeof(coarse_memory_provider_params));
-    coarse_memory_provider_params.allocation_strategy = allocation_strategy;
-    coarse_memory_provider_params.upstream_memory_provider =
-        malloc_memory_provider;
-    coarse_memory_provider_params.immediate_init_from_upstream = true;
-    coarse_memory_provider_params.init_buffer = buf;
-    coarse_memory_provider_params.init_buffer_size = init_buffer_size;
-
-    umf_memory_provider_handle_t coarse_memory_provider = nullptr;
-    umf_result = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(),
-                                         &coarse_memory_provider_params,
-                                         &coarse_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-    ASSERT_EQ(coarse_memory_provider, nullptr);
-
-    umfMemoryProviderDestroy(malloc_memory_provider);
-}
-
-// wrong parameters: init_buffer_size must not equal 0 when immediate_init_from_upstream is true
-TEST_P(CoarseWithMemoryStrategyTest, coarseProvider_wrong_params_2) {
-    umf_memory_provider_handle_t malloc_memory_provider;
-    umf_result_t umf_result;
-
-    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
-                                         &malloc_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(malloc_memory_provider, nullptr);
-
-    coarse_memory_provider_params_t coarse_memory_provider_params;
-    // make sure there are no undefined members - prevent a UB
-    memset(&coarse_memory_provider_params, 0,
-           sizeof(coarse_memory_provider_params));
-    coarse_memory_provider_params.allocation_strategy = allocation_strategy;
-    coarse_memory_provider_params.upstream_memory_provider =
-        malloc_memory_provider;
-    coarse_memory_provider_params.immediate_init_from_upstream = true;
-    coarse_memory_provider_params.init_buffer = nullptr;
-    coarse_memory_provider_params.init_buffer_size = 0;
-
-    umf_memory_provider_handle_t coarse_memory_provider = nullptr;
-    umf_result = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(),
-                                         &coarse_memory_provider_params,
-                                         &coarse_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-    ASSERT_EQ(coarse_memory_provider, nullptr);
-
-    umfMemoryProviderDestroy(malloc_memory_provider);
-}
-
-// wrong parameters: init_buffer_size must not equal 0 when init_buffer is not NULL
-TEST_P(CoarseWithMemoryStrategyTest, coarseProvider_wrong_params_3) {
-    umf_result_t umf_result;
-
-    const size_t init_buffer_size = 20 * MB;
-
-    // preallocate some memory and initialize the vector with zeros
-    std::vector<char> buffer(init_buffer_size, 0);
-    void *buf = (void *)buffer.data();
-    ASSERT_NE(buf, nullptr);
-
-    coarse_memory_provider_params_t coarse_memory_provider_params;
-    // make sure there are no undefined members - prevent a UB
-    memset(&coarse_memory_provider_params, 0,
-           sizeof(coarse_memory_provider_params));
-    coarse_memory_provider_params.allocation_strategy = allocation_strategy;
-    coarse_memory_provider_params.upstream_memory_provider = nullptr;
-    coarse_memory_provider_params.immediate_init_from_upstream = false;
-    coarse_memory_provider_params.init_buffer = buf;
-    coarse_memory_provider_params.init_buffer_size = 0;
-
-    umf_memory_provider_handle_t coarse_memory_provider = nullptr;
-    umf_result = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(),
-                                         &coarse_memory_provider_params,
-                                         &coarse_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-    ASSERT_EQ(coarse_memory_provider, nullptr);
-}
-
-// wrong parameters: init_buffer_size must equal 0 when init_buffer is NULL and immediate_init_from_upstream is false
-TEST_P(CoarseWithMemoryStrategyTest, coarseProvider_wrong_params_4) {
-    umf_memory_provider_handle_t malloc_memory_provider;
-    umf_result_t umf_result;
-
-    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
-                                         &malloc_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(malloc_memory_provider, nullptr);
-
-    coarse_memory_provider_params_t coarse_memory_provider_params;
-    // make sure there are no undefined members - prevent a UB
-    memset(&coarse_memory_provider_params, 0,
-           sizeof(coarse_memory_provider_params));
-    coarse_memory_provider_params.allocation_strategy = allocation_strategy;
-    coarse_memory_provider_params.upstream_memory_provider =
-        malloc_memory_provider;
-    coarse_memory_provider_params.immediate_init_from_upstream = false;
-    coarse_memory_provider_params.init_buffer = NULL;
-    coarse_memory_provider_params.init_buffer_size = 20 * MB;
-
-    umf_memory_provider_handle_t coarse_memory_provider = nullptr;
-    umf_result = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(),
-                                         &coarse_memory_provider_params,
-                                         &coarse_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-    ASSERT_EQ(coarse_memory_provider, nullptr);
-
-    umfMemoryProviderDestroy(malloc_memory_provider);
-}
-
-// wrong parameters: destroy_upstream_memory_provider is true, but an upstream provider is not provided
-TEST_P(CoarseWithMemoryStrategyTest, coarseProvider_wrong_params_5) {
-    umf_result_t umf_result;
-
-    const size_t init_buffer_size = 20 * MB;
-
-    // preallocate some memory and initialize the vector with zeros
-    std::vector<char> buffer(init_buffer_size, 0);
-    void *buf = (void *)buffer.data();
-    ASSERT_NE(buf, nullptr);
-
-    coarse_memory_provider_params_t coarse_memory_provider_params;
-    // make sure there are no undefined members - prevent a UB
-    memset(&coarse_memory_provider_params, 0,
-           sizeof(coarse_memory_provider_params));
-    coarse_memory_provider_params.allocation_strategy = allocation_strategy;
-    coarse_memory_provider_params.upstream_memory_provider = nullptr;
-    coarse_memory_provider_params.destroy_upstream_memory_provider = true;
-    coarse_memory_provider_params.immediate_init_from_upstream = false;
-    coarse_memory_provider_params.init_buffer = buf;
-    coarse_memory_provider_params.init_buffer_size = init_buffer_size;
-
-    umf_memory_provider_handle_t coarse_memory_provider = nullptr;
-    umf_result = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(),
-                                         &coarse_memory_provider_params,
-                                         &coarse_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-    ASSERT_EQ(coarse_memory_provider, nullptr);
-}
-
-TEST_P(CoarseWithMemoryStrategyTest, coarseProvider_split_merge) {
-    umf_memory_provider_handle_t malloc_memory_provider;
-    umf_result_t umf_result;
-
-    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
-                                         &malloc_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(malloc_memory_provider, nullptr);
-
-    const size_t init_buffer_size = 20 * MB;
-
-    coarse_memory_provider_params_t coarse_memory_provider_params;
-    // make sure there are no undefined members - prevent a UB
-    memset(&coarse_memory_provider_params, 0,
-           sizeof(coarse_memory_provider_params));
-    coarse_memory_provider_params.upstream_memory_provider =
-        malloc_memory_provider;
-    coarse_memory_provider_params.immediate_init_from_upstream = true;
-    coarse_memory_provider_params.init_buffer = NULL;
-    coarse_memory_provider_params.init_buffer_size = init_buffer_size;
-
-    umf_memory_provider_handle_t coarse_memory_provider;
-    umf_result = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(),
-                                         &coarse_memory_provider_params,
-                                         &coarse_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(coarse_memory_provider, nullptr);
-
-    umf_memory_provider_handle_t cp = coarse_memory_provider;
-    char *ptr = nullptr;
-
-    ASSERT_EQ(GetStats(cp).used_size, 0 * MB);
-    ASSERT_EQ(GetStats(cp).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(cp).num_all_blocks, 1);
-
-    /* test umfMemoryProviderAllocationSplit */
-    umf_result = umfMemoryProviderAlloc(cp, 2 * MB, 0, (void **)&ptr);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(ptr, nullptr);
-    ASSERT_EQ(GetStats(cp).used_size, 2 * MB);
-    ASSERT_EQ(GetStats(cp).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(cp).num_all_blocks, 2);
-
-    umf_result = umfMemoryProviderAllocationSplit(cp, ptr, 2 * MB, 1 * MB);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(GetStats(cp).used_size, 2 * MB);
-    ASSERT_EQ(GetStats(cp).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(cp).num_all_blocks, 3);
-
-    umf_result = umfMemoryProviderFree(cp, (ptr + 1 * MB), 1 * MB);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(GetStats(cp).used_size, 1 * MB);
-    ASSERT_EQ(GetStats(cp).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(cp).num_all_blocks, 2);
-
-    umf_result = umfMemoryProviderFree(cp, ptr, 1 * MB);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(GetStats(cp).used_size, 0);
-    ASSERT_EQ(GetStats(cp).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(cp).num_all_blocks, 1);
-
-    /* test umfMemoryProviderAllocationMerge */
-    umf_result = umfMemoryProviderAlloc(cp, 2 * MB, 0, (void **)&ptr);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(ptr, nullptr);
-    ASSERT_EQ(GetStats(cp).used_size, 2 * MB);
-    ASSERT_EQ(GetStats(cp).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(cp).num_all_blocks, 2);
-
-    umf_result = umfMemoryProviderAllocationSplit(cp, ptr, 2 * MB, 1 * MB);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(GetStats(cp).used_size, 2 * MB);
-    ASSERT_EQ(GetStats(cp).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(cp).num_all_blocks, 3);
-
-    umf_result =
-        umfMemoryProviderAllocationMerge(cp, ptr, (ptr + 1 * MB), 2 * MB);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(GetStats(cp).used_size, 2 * MB);
-    ASSERT_EQ(GetStats(cp).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(cp).num_all_blocks, 2);
-
-    umf_result = umfMemoryProviderFree(cp, ptr, 2 * MB);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(GetStats(cp).used_size, 0);
-    ASSERT_EQ(GetStats(cp).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(cp).num_all_blocks, 1);
-
-    umfMemoryProviderDestroy(coarse_memory_provider);
-    umfMemoryProviderDestroy(malloc_memory_provider);
-}
-
-TEST_P(CoarseWithMemoryStrategyTest, coarseProvider_split_merge_negative) {
-    umf_memory_provider_handle_t malloc_memory_provider;
-    umf_result_t umf_result;
-
-    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
-                                         &malloc_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(malloc_memory_provider, nullptr);
-
-    const size_t init_buffer_size = 20 * MB;
-
-    coarse_memory_provider_params_t coarse_memory_provider_params;
-    // make sure there are no undefined members - prevent a UB
-    memset(&coarse_memory_provider_params, 0,
-           sizeof(coarse_memory_provider_params));
-    coarse_memory_provider_params.upstream_memory_provider =
-        malloc_memory_provider;
-    coarse_memory_provider_params.immediate_init_from_upstream = true;
-    coarse_memory_provider_params.init_buffer = NULL;
-    coarse_memory_provider_params.init_buffer_size = init_buffer_size;
-
-    umf_memory_provider_handle_t coarse_memory_provider;
-    umf_result = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(),
-                                         &coarse_memory_provider_params,
-                                         &coarse_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(coarse_memory_provider, nullptr);
-
-    umf_memory_provider_handle_t cp = coarse_memory_provider;
-    char *ptr = nullptr;
-
-    ASSERT_EQ(GetStats(cp).used_size, 0 * MB);
-    ASSERT_EQ(GetStats(cp).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(cp).num_all_blocks, 1);
-
-    /* test umfMemoryProviderAllocationSplit */
-    umf_result = umfMemoryProviderAlloc(cp, 6 * MB, 0, (void **)&ptr);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(ptr, nullptr);
-    ASSERT_EQ(GetStats(cp).used_size, 6 * MB);
-    ASSERT_EQ(GetStats(cp).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(cp).num_all_blocks, 2);
-
-    // firstSize >= totalSize
-    umf_result = umfMemoryProviderAllocationSplit(cp, ptr, 6 * MB, 6 * MB);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    // firstSize == 0
-    umf_result = umfMemoryProviderAllocationSplit(cp, ptr, 6 * MB, 0);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    // wrong totalSize
-    umf_result = umfMemoryProviderAllocationSplit(cp, ptr, 5 * MB, 1 * KB);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    /* test umfMemoryProviderAllocationMerge */
-    // split (6 * MB) block into (1 * MB) + (5 * MB)
-    umf_result = umfMemoryProviderAllocationSplit(cp, ptr, 6 * MB, 1 * MB);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(GetStats(cp).used_size, 6 * MB);
-    ASSERT_EQ(GetStats(cp).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(cp).num_all_blocks, 3);
-
-    // split (5 * MB) block into (2 * MB) + (3 * MB)
-    umf_result =
-        umfMemoryProviderAllocationSplit(cp, (ptr + 1 * MB), 5 * MB, 2 * MB);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(GetStats(cp).used_size, 6 * MB);
-    ASSERT_EQ(GetStats(cp).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(cp).num_all_blocks, 4);
-
-    // now we have 3 blocks: (1 * MB) + (2 * MB) + (3 * MB)
-
-    // highPtr <= lowPtr
-    umf_result =
-        umfMemoryProviderAllocationMerge(cp, (ptr + 1 * MB), ptr, 2 * MB);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    // highPtr - lowPtr >= totalSize
-    umf_result =
-        umfMemoryProviderAllocationMerge(cp, ptr, (ptr + 1 * MB), 1 * MB);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    // low_block->size + high_block->size != totalSize
-    umf_result =
-        umfMemoryProviderAllocationMerge(cp, ptr, (ptr + 1 * MB), 5 * MB);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    // not adjacent blocks
-    umf_result =
-        umfMemoryProviderAllocationMerge(cp, ptr, (ptr + 3 * MB), 4 * MB);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    umf_result = umfMemoryProviderFree(cp, ptr, 1 * MB);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(GetStats(cp).used_size, 5 * MB);
-    ASSERT_EQ(GetStats(cp).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(cp).num_all_blocks, 4);
-
-    umf_result = umfMemoryProviderFree(cp, (ptr + 1 * MB), 2 * MB);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(GetStats(cp).used_size, 3 * MB);
-    ASSERT_EQ(GetStats(cp).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(cp).num_all_blocks, 3);
-
-    umf_result = umfMemoryProviderFree(cp, (ptr + 3 * MB), 3 * MB);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_EQ(GetStats(cp).used_size, 0);
-    ASSERT_EQ(GetStats(cp).alloc_size, init_buffer_size);
-    ASSERT_EQ(GetStats(cp).num_all_blocks, 1);
-
-    umfMemoryProviderDestroy(coarse_memory_provider);
-    umfMemoryProviderDestroy(malloc_memory_provider);
-}
-
-TEST_P(CoarseWithMemoryStrategyTest, coarseProvider_purge_no_upstream) {
-    umf_result_t umf_result;
-
-    const size_t init_buffer_size = 20 * MB;
-
-    // preallocate some memory and initialize the vector with zeros
-    std::vector<char> buffer(init_buffer_size, 0);
-    void *buf = (void *)buffer.data();
-    ASSERT_NE(buf, nullptr);
-
-    coarse_memory_provider_params_t coarse_memory_provider_params;
-    // make sure there are no undefined members - prevent a UB
-    memset(&coarse_memory_provider_params, 0,
-           sizeof(coarse_memory_provider_params));
-    coarse_memory_provider_params.allocation_strategy = allocation_strategy;
-    coarse_memory_provider_params.upstream_memory_provider = nullptr;
-    coarse_memory_provider_params.immediate_init_from_upstream = false;
-    coarse_memory_provider_params.init_buffer = buf;
-    coarse_memory_provider_params.init_buffer_size = init_buffer_size;
-
-    umf_memory_provider_handle_t coarse_memory_provider = nullptr;
-    umf_result = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(),
-                                         &coarse_memory_provider_params,
-                                         &coarse_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(coarse_memory_provider, nullptr);
-
-    // umfMemoryProviderPurgeLazy
-    // provider == NULL
-    umf_result = umfMemoryProviderPurgeLazy(nullptr, (void *)0x01, 1);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    // ptr == NULL
-    umf_result = umfMemoryProviderPurgeLazy(coarse_memory_provider, nullptr, 1);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    // no upstream_memory_provider
-    umf_result =
-        umfMemoryProviderPurgeLazy(coarse_memory_provider, (void *)0x01, 1);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
-
-    // umfMemoryProviderPurgeForce
-    // provider == NULL
-    umf_result = umfMemoryProviderPurgeForce(nullptr, (void *)0x01, 1);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    // ptr == NULL
-    umf_result =
-        umfMemoryProviderPurgeForce(coarse_memory_provider, nullptr, 1);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    // no upstream_memory_provider
-    umf_result =
-        umfMemoryProviderPurgeForce(coarse_memory_provider, (void *)0x01, 1);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
-
-    umfMemoryProviderDestroy(coarse_memory_provider);
-}
-
-TEST_P(CoarseWithMemoryStrategyTest, coarseProvider_purge_with_upstream) {
-    umf_memory_provider_handle_t malloc_memory_provider;
-    umf_result_t umf_result;
-
-    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
-                                         &malloc_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(malloc_memory_provider, nullptr);
-
-    const size_t init_buffer_size = 20 * MB;
-
-    coarse_memory_provider_params_t coarse_memory_provider_params;
-    // make sure there are no undefined members - prevent a UB
-    memset(&coarse_memory_provider_params, 0,
-           sizeof(coarse_memory_provider_params));
-    coarse_memory_provider_params.upstream_memory_provider =
-        malloc_memory_provider;
-    coarse_memory_provider_params.immediate_init_from_upstream = true;
-    coarse_memory_provider_params.init_buffer = NULL;
-    coarse_memory_provider_params.init_buffer_size = init_buffer_size;
-
-    umf_memory_provider_handle_t coarse_memory_provider;
-    umf_result = umfMemoryProviderCreate(umfCoarseMemoryProviderOps(),
-                                         &coarse_memory_provider_params,
-                                         &coarse_memory_provider);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(coarse_memory_provider, nullptr);
-
-    // umfMemoryProviderPurgeLazy
-    // provider == NULL
-    umf_result = umfMemoryProviderPurgeLazy(nullptr, (void *)0x01, 1);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    // ptr == NULL
-    umf_result = umfMemoryProviderPurgeLazy(coarse_memory_provider, nullptr, 1);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    // malloc_memory_provider returns UMF_RESULT_ERROR_UNKNOWN
-    umf_result =
-        umfMemoryProviderPurgeLazy(coarse_memory_provider, (void *)0x01, 1);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_UNKNOWN);
-
-    // umfMemoryProviderPurgeForce
-    // provider == NULL
-    umf_result = umfMemoryProviderPurgeForce(nullptr, (void *)0x01, 1);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    // ptr == NULL
-    umf_result =
-        umfMemoryProviderPurgeForce(coarse_memory_provider, nullptr, 1);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    // malloc_memory_provider returns UMF_RESULT_ERROR_UNKNOWN
-    umf_result =
-        umfMemoryProviderPurgeForce(coarse_memory_provider, (void *)0x01, 1);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_UNKNOWN);
-
-    umfMemoryProviderDestroy(coarse_memory_provider);
-    umfMemoryProviderDestroy(malloc_memory_provider);
-}
diff --git a/test/provider_devdax_memory.cpp b/test/provider_devdax_memory.cpp
index 0fd0705da4..b22f4fa291 100644
--- a/test/provider_devdax_memory.cpp
+++ b/test/provider_devdax_memory.cpp
@@ -1,22 +1,25 @@
-// 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
 
 #ifndef _WIN32
-#include "test_helpers_linux.h"
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #endif
 
-#include "base.hpp"
-
-#include "cpp_helpers.hpp"
-#include "test_helpers.h"
-
+#include <umf/experimental/ctl.h>
 #include <umf/memory_provider.h>
 #include <umf/providers/provider_devdax_memory.h>
 
+#include "base.hpp"
+#include "provider.hpp"
+#include "test_helpers.h"
+#include "utils/cpp_helpers.hpp"
+#ifndef _WIN32
+#include "test_helpers_linux.h"
+#endif
+
 using umf_test::test;
 
 #define INVALID_PTR ((void *)0x01)
@@ -43,22 +46,6 @@ static int compare_native_error_str(const char *message, int error) {
     return strncmp(message, error_str, len);
 }
 
-using providerCreateExtParams = std::tuple<umf_memory_provider_ops_t *, void *>;
-
-static void providerCreateExt(providerCreateExtParams params,
-                              umf::provider_unique_handle_t *handle) {
-    umf_memory_provider_handle_t hProvider = nullptr;
-    auto [provider_ops, provider_params] = params;
-
-    auto ret =
-        umfMemoryProviderCreate(provider_ops, provider_params, &hProvider);
-    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-    ASSERT_NE(hProvider, nullptr);
-
-    *handle =
-        umf::provider_unique_handle_t(hProvider, &umfMemoryProviderDestroy);
-}
-
 struct umfProviderTest
     : umf_test::test,
       ::testing::WithParamInterface<providerCreateExtParams> {
@@ -74,7 +61,7 @@ struct umfProviderTest
 
     void TearDown() override { test::TearDown(); }
 
-    umf::provider_unique_handle_t provider;
+    umf_test::provider_unique_handle_t provider;
     size_t page_size;
     size_t page_plus_64;
 };
@@ -100,14 +87,16 @@ static void test_alloc_free_success(umf_memory_provider_handle_t provider,
     }
 
     umf_result = umfMemoryProviderFree(provider, ptr, size);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 }
 
 static void verify_last_native_error(umf_memory_provider_handle_t provider,
                                      int32_t err) {
     const char *message;
     int32_t error;
-    umfMemoryProviderGetLastNativeError(provider, &message, &error);
+    umf_result_t ret =
+        umfMemoryProviderGetLastNativeError(provider, &message, &error);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_EQ(error, err);
     ASSERT_EQ(compare_native_error_str(message, error), 0);
 }
@@ -134,7 +123,7 @@ TEST_F(test, test_if_mapped_with_MAP_SYNC) {
     umf_result_t umf_result;
 
     char *path = getenv("UMF_TESTS_DEVDAX_PATH");
-    if (path == nullptr || path[0] == 0) {
+    if (path == nullptr || path[0] == '\0') {
         GTEST_SKIP() << "Test skipped, UMF_TESTS_DEVDAX_PATH is not set";
     }
 
@@ -145,7 +134,7 @@ TEST_F(test, test_if_mapped_with_MAP_SYNC) {
 
     size_t size = atol(size_str);
     umf_devdax_memory_provider_params_handle_t params = NULL;
-    umf_result = umfDevDaxMemoryProviderParamsCreate(&params, path, size);
+    umf_result = umfDevDaxMemoryProviderParamsCreate(path, size, &params);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_NE(params, nullptr);
 
@@ -162,9 +151,10 @@ TEST_F(test, test_if_mapped_with_MAP_SYNC) {
     bool flag_found = is_mapped_with_MAP_SYNC(path, buf, size);
 
     umf_result = umfMemoryProviderFree(hProvider, buf, size);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
     umfMemoryProviderDestroy(hProvider);
+    umfDevDaxMemoryProviderParamsDestroy(params);
 
     // fail test if the "sf" flag was not found
     ASSERT_EQ(flag_found, true);
@@ -179,14 +169,15 @@ using devdax_params_unique_handle_t =
 devdax_params_unique_handle_t create_devdax_params() {
     char *path = getenv("UMF_TESTS_DEVDAX_PATH");
     char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
-    if (path == nullptr || path[0] == 0 || size == nullptr || size[0] == 0) {
+    if (path == nullptr || path[0] == '\0' || size == nullptr ||
+        size[0] == '\0') {
         return devdax_params_unique_handle_t(
             nullptr, &umfDevDaxMemoryProviderParamsDestroy);
     }
 
     umf_devdax_memory_provider_params_handle_t params = NULL;
     umf_result_t res =
-        umfDevDaxMemoryProviderParamsCreate(&params, path, atol(size));
+        umfDevDaxMemoryProviderParamsCreate(path, atol(size), &params);
     if (res != UMF_RESULT_SUCCESS) {
         throw std::runtime_error(
             "Failed to create DevDax Memory Provider params");
@@ -207,7 +198,8 @@ static std::vector<providerCreateExtParams> devdaxProviderTestParamsList =
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfProviderTest);
 
 INSTANTIATE_TEST_SUITE_P(devdaxProviderTest, umfProviderTest,
-                         ::testing::ValuesIn(devdaxProviderTestParamsList));
+                         ::testing::ValuesIn(devdaxProviderTestParamsList),
+                         providerCreateExtParamsNameGen);
 
 TEST_P(umfProviderTest, create_destroy) {}
 
@@ -233,34 +225,40 @@ TEST_P(umfProviderTest, purge_force) {
     test_alloc_free_success(provider.get(), page_size, 0, PURGE_FORCE);
 }
 
+TEST_P(umfProviderTest, purge_force_unaligned_alloc) {
+    void *ptr;
+    auto ret = umfMemoryProviderAlloc(provider.get(), page_plus_64, 0, &ptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    test_alloc_free_success(provider.get(), page_size, 0, PURGE_FORCE);
+    umfMemoryProviderFree(provider.get(), ptr, page_plus_64);
+}
 // negative tests using test_alloc_failure
 
 TEST_P(umfProviderTest, alloc_page64_align_page_minus_1_WRONG_ALIGNMENT_1) {
     test_alloc_failure(provider.get(), page_plus_64, page_size - 1,
-                       UMF_RESULT_ERROR_INVALID_ARGUMENT, 0);
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
 }
 
 TEST_P(umfProviderTest, alloc_page64_align_one_half_pages_WRONG_ALIGNMENT_2) {
     test_alloc_failure(provider.get(), page_plus_64,
                        page_size + (page_size / 2),
-                       UMF_RESULT_ERROR_INVALID_ARGUMENT, 0);
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
 }
 
 TEST_P(umfProviderTest, alloc_page64_WRONG_ALIGNMENT_3_pages) {
     test_alloc_failure(provider.get(), page_plus_64, 3 * page_size,
-                       UMF_RESULT_ERROR_INVALID_ARGUMENT, 0);
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
 }
 
 TEST_P(umfProviderTest, alloc_3_pages_WRONG_ALIGNMENT_3_pages) {
     test_alloc_failure(provider.get(), 3 * page_size, 3 * page_size,
-                       UMF_RESULT_ERROR_INVALID_ARGUMENT, 0);
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
 }
 
 TEST_P(umfProviderTest, alloc_WRONG_SIZE) {
     size_t size = (size_t)(-1) & ~(page_size - 1);
     test_alloc_failure(provider.get(), size, 0,
-                       UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC,
-                       UMF_DEVDAX_RESULT_ERROR_ALLOC_FAILED);
+                       UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY, 0);
 }
 
 // other positive tests
@@ -288,19 +286,103 @@ TEST_P(umfProviderTest, get_recommended_page_size) {
 }
 
 TEST_P(umfProviderTest, get_name) {
-    const char *name = umfMemoryProviderGetName(provider.get());
+    const char *name = nullptr;
+    umf_result_t ret = umfMemoryProviderGetName(provider.get(), &name);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_STREQ(name, "DEVDAX");
 }
 
+TEST(DevDaxProviderName, custom_name) {
+    auto params_handle = create_devdax_params();
+    if (!params_handle.get()) {
+        GTEST_SKIP() << "devdax params unavailable";
+    }
+
+    const char *custom = "my_devdax";
+    auto ret =
+        umfDevDaxMemoryProviderParamsSetName(params_handle.get(), custom);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    umf_memory_provider_handle_t prov = nullptr;
+    ret = umfMemoryProviderCreate(umfDevDaxMemoryProviderOps(),
+                                  params_handle.get(), &prov);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    const char *name = nullptr;
+    ret = umfMemoryProviderGetName(prov, &name);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, custom);
+    umfMemoryProviderDestroy(prov);
+}
+
+TEST(DevDaxProviderName, default_name_null_handle) {
+    const char *name = nullptr;
+    EXPECT_EQ(umfDevDaxMemoryProviderOps()->get_name(nullptr, &name),
+              UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, "DEVDAX");
+}
+
 TEST_P(umfProviderTest, free_size_0_ptr_not_null) {
     umf_result_t umf_result =
         umfMemoryProviderFree(provider.get(), INVALID_PTR, 0);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
 
 TEST_P(umfProviderTest, free_NULL) {
     umf_result_t umf_result = umfMemoryProviderFree(provider.get(), nullptr, 0);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(umfProviderTest, ctl_stats) {
+    size_t allocated = 0, peak = 0;
+    umf_result_t ret =
+        umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                  &allocated, sizeof(allocated), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, 0u);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, 0u);
+
+    void *ptr = nullptr;
+    size_t size = page_size;
+    ret = umfMemoryProviderAlloc(provider.get(), size, 0, &ptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                    &allocated, sizeof(allocated), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, size);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, size);
+
+    ret = umfMemoryProviderFree(provider.get(), ptr, size);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                    &allocated, sizeof(allocated), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, 0u);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, size);
+
+    ret = umfCtlExec("umf.provider.by_handle.{}.stats.peak_memory.reset", NULL,
+                     0, provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, 0u);
 }
 
 // other negative tests
@@ -308,7 +390,7 @@ TEST_P(umfProviderTest, free_NULL) {
 TEST_P(umfProviderTest, free_INVALID_POINTER_SIZE_GT_0) {
     umf_result_t umf_result =
         umfMemoryProviderFree(provider.get(), INVALID_PTR, page_plus_64);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
 
 TEST_P(umfProviderTest, purge_lazy_INVALID_POINTER) {
@@ -331,7 +413,7 @@ TEST_P(umfProviderTest, purge_force_INVALID_POINTER) {
 TEST_F(test, params_protection_flag) {
     umf_devdax_memory_provider_params_handle_t params = nullptr;
     umf_result_t ret =
-        umfDevDaxMemoryProviderParamsCreate(&params, "/dev/dax0.0", 4096);
+        umfDevDaxMemoryProviderParamsCreate("/dev/dax0.0", 4096, &params);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_NE(params, nullptr);
 
@@ -350,7 +432,7 @@ TEST_F(test, params_protection_flag) {
 TEST_F(test, params_invalid_protection_flag) {
     umf_devdax_memory_provider_params_handle_t params = nullptr;
     umf_result_t ret =
-        umfDevDaxMemoryProviderParamsCreate(&params, "/dev/dax0.0", 4096);
+        umfDevDaxMemoryProviderParamsCreate("/dev/dax0.0", 4096, &params);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_NE(params, nullptr);
 
@@ -370,7 +452,7 @@ TEST_F(test, params_invalid_protection_flag) {
 
 TEST_F(test, params_null_handle) {
     auto ret =
-        umfDevDaxMemoryProviderParamsCreate(nullptr, "/dev/dax0.0", 4096);
+        umfDevDaxMemoryProviderParamsCreate("/dev/dax0.0", 4096, nullptr);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     ret = umfDevDaxMemoryProviderParamsDestroy(nullptr);
@@ -387,7 +469,7 @@ TEST_F(test, params_null_handle) {
 TEST_F(test, create_empty_path) {
     const char *path = "";
     umf_devdax_memory_provider_params_handle_t wrong_params = NULL;
-    auto ret = umfDevDaxMemoryProviderParamsCreate(&wrong_params, path, 4096);
+    auto ret = umfDevDaxMemoryProviderParamsCreate(path, 4096, &wrong_params);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
     ASSERT_EQ(wrong_params, nullptr);
 }
@@ -395,7 +477,7 @@ TEST_F(test, create_empty_path) {
 TEST_F(test, create_null_path) {
     const char *path = nullptr;
     umf_devdax_memory_provider_params_handle_t wrong_params = NULL;
-    auto ret = umfDevDaxMemoryProviderParamsCreate(&wrong_params, path, 4096);
+    auto ret = umfDevDaxMemoryProviderParamsCreate(path, 4096, &wrong_params);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
     ASSERT_EQ(wrong_params, nullptr);
 }
@@ -404,7 +486,7 @@ TEST_F(test, set_empty_path) {
     const char *path = "tmp";
     const char *empty_path = "";
     umf_devdax_memory_provider_params_handle_t params = NULL;
-    auto ret = umfDevDaxMemoryProviderParamsCreate(&params, path, 4096);
+    auto ret = umfDevDaxMemoryProviderParamsCreate(path, 4096, &params);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_NE(params, nullptr);
 
@@ -419,7 +501,7 @@ TEST_F(test, set_null_path) {
     const char *path = "tmp";
     const char *null_path = nullptr;
     umf_devdax_memory_provider_params_handle_t params = NULL;
-    auto ret = umfDevDaxMemoryProviderParamsCreate(&params, path, 4096);
+    auto ret = umfDevDaxMemoryProviderParamsCreate(path, 4096, &params);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_NE(params, nullptr);
 
@@ -435,7 +517,7 @@ TEST_F(test, create_wrong_path) {
     const char *path = "/tmp/dev/dax0.0";
     umf_devdax_memory_provider_params_handle_t wrong_params = nullptr;
 
-    auto ret = umfDevDaxMemoryProviderParamsCreate(&wrong_params, path, 4096);
+    auto ret = umfDevDaxMemoryProviderParamsCreate(path, 4096, &wrong_params);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_NE(wrong_params, nullptr);
 
@@ -453,7 +535,7 @@ TEST_F(test, create_wrong_path_not_exist) {
     const char *path = "/dev/dax1.1";
     umf_devdax_memory_provider_params_handle_t wrong_params = nullptr;
 
-    auto ret = umfDevDaxMemoryProviderParamsCreate(&wrong_params, path, 4096);
+    auto ret = umfDevDaxMemoryProviderParamsCreate(path, 4096, &wrong_params);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_NE(wrong_params, nullptr);
 
@@ -471,7 +553,7 @@ TEST_F(test, create_wrong_size_0) {
     const char *path = "/dev/dax0.0";
     umf_devdax_memory_provider_params_handle_t wrong_params = nullptr;
 
-    auto ret = umfDevDaxMemoryProviderParamsCreate(&wrong_params, path, 0);
+    auto ret = umfDevDaxMemoryProviderParamsCreate(path, 0, &wrong_params);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_NE(wrong_params, nullptr);
 
diff --git a/test/provider_devdax_memory_ipc.cpp b/test/provider_devdax_memory_ipc.cpp
index 3941f66e90..1db7011534 100644
--- a/test/provider_devdax_memory_ipc.cpp
+++ b/test/provider_devdax_memory_ipc.cpp
@@ -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,52 +15,61 @@
 
 using umf_test::test;
 
-using devdax_params_unique_handle_t =
-    std::unique_ptr<umf_devdax_memory_provider_params_t,
-                    decltype(&umfDevDaxMemoryProviderParamsDestroy)>;
+bool devDaxEnvSet() {
+    char *path = getenv("UMF_TESTS_DEVDAX_PATH");
+    char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
+    if (path == nullptr || path[0] == '\0' || size == nullptr ||
+        size[0] == '\0') {
+        return false;
+    }
 
-devdax_params_unique_handle_t create_devdax_params() {
+    return true;
+}
+
+void *defaultDevDaxParamsCreate() {
     char *path = getenv("UMF_TESTS_DEVDAX_PATH");
     char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
-    if (path == nullptr || path[0] == 0 || size == nullptr || size[0] == 0) {
-        return devdax_params_unique_handle_t(
-            nullptr, &umfDevDaxMemoryProviderParamsDestroy);
+    if (path == nullptr || path[0] == '\0' || size == nullptr ||
+        size[0] == '\0') {
+        return nullptr;
     }
 
     umf_devdax_memory_provider_params_handle_t params = NULL;
     umf_result_t res =
-        umfDevDaxMemoryProviderParamsCreate(&params, path, atol(size));
+        umfDevDaxMemoryProviderParamsCreate(path, atol(size), &params);
     if (res != UMF_RESULT_SUCCESS) {
         throw std::runtime_error(
             "Failed to create DevDax Memory Provider params");
     }
 
-    return devdax_params_unique_handle_t(params,
-                                         &umfDevDaxMemoryProviderParamsDestroy);
+    return params;
 }
 
-auto defaultDevDaxParams = create_devdax_params();
+umf_result_t defaultDevDaxParamsDestroy(void *params) {
+    return umfDevDaxMemoryProviderParamsDestroy(
+        (umf_devdax_memory_provider_params_handle_t)params);
+}
 
 HostMemoryAccessor hostAccessor;
 
 static std::vector<ipcTestParams> getIpcProxyPoolTestParamsList(void) {
     std::vector<ipcTestParams> ipcProxyPoolTestParamsList = {};
 
-    if (!defaultDevDaxParams.get()) {
+    if (!devDaxEnvSet()) {
         // return empty list to skip the test
         return ipcProxyPoolTestParamsList;
     }
 
     ipcProxyPoolTestParamsList = {
-        {umfProxyPoolOps(), nullptr, umfDevDaxMemoryProviderOps(),
-         defaultDevDaxParams.get(), &hostAccessor, true},
+        {umfProxyPoolOps(), nullptr, nullptr, umfDevDaxMemoryProviderOps(),
+         defaultDevDaxParamsCreate, defaultDevDaxParamsDestroy, &hostAccessor},
 #ifdef UMF_POOL_JEMALLOC_ENABLED
-        {umfJemallocPoolOps(), nullptr, umfDevDaxMemoryProviderOps(),
-         defaultDevDaxParams.get(), &hostAccessor, false},
+        {umfJemallocPoolOps(), nullptr, nullptr, umfDevDaxMemoryProviderOps(),
+         defaultDevDaxParamsCreate, defaultDevDaxParamsDestroy, &hostAccessor},
 #endif
 #ifdef UMF_POOL_SCALABLE_ENABLED
-        {umfScalablePoolOps(), nullptr, umfDevDaxMemoryProviderOps(),
-         defaultDevDaxParams.get(), &hostAccessor, false},
+        {umfScalablePoolOps(), nullptr, nullptr, umfDevDaxMemoryProviderOps(),
+         defaultDevDaxParamsCreate, defaultDevDaxParamsDestroy, &hostAccessor},
 #endif
     };
 
@@ -70,4 +79,5 @@ static std::vector<ipcTestParams> getIpcProxyPoolTestParamsList(void) {
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest);
 
 INSTANTIATE_TEST_SUITE_P(DevDaxProviderDifferentPoolsTest, umfIpcTest,
-                         ::testing::ValuesIn(getIpcProxyPoolTestParamsList()));
+                         ::testing::ValuesIn(getIpcProxyPoolTestParamsList()),
+                         ipcTestParamsNameGen);
diff --git a/test/provider_devdax_memory_not_impl.cpp b/test/provider_devdax_memory_not_impl.cpp
index 3b97443a08..8924efc4ed 100644
--- a/test/provider_devdax_memory_not_impl.cpp
+++ b/test/provider_devdax_memory_not_impl.cpp
@@ -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
 
@@ -11,7 +11,7 @@ using umf_test::test;
 TEST_F(test, devdax_provider_not_implemented) {
     umf_devdax_memory_provider_params_handle_t params = nullptr;
     umf_result_t umf_result =
-        umfDevDaxMemoryProviderParamsCreate(&params, "path", 4096);
+        umfDevDaxMemoryProviderParamsCreate("path", 4096, &params);
     EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
     EXPECT_EQ(params, nullptr);
 
@@ -25,6 +25,6 @@ TEST_F(test, devdax_provider_not_implemented) {
     umf_result = umfDevDaxMemoryProviderParamsSetProtection(nullptr, 0);
     EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
 
-    umf_memory_provider_ops_t *ops = umfDevDaxMemoryProviderOps();
+    const umf_memory_provider_ops_t *ops = umfDevDaxMemoryProviderOps();
     EXPECT_EQ(ops, nullptr);
 }
diff --git a/test/provider_file_memory.cpp b/test/provider_file_memory.cpp
index d3124aa11f..c59223eb5a 100644
--- a/test/provider_file_memory.cpp
+++ b/test/provider_file_memory.cpp
@@ -1,18 +1,19 @@
-// 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
 
-#include "base.hpp"
+#include <umf/experimental/ctl.h>
+#include <umf/memory_provider.h>
+#include <umf/providers/provider_file_memory.h>
 
-#include "cpp_helpers.hpp"
+#include "base.hpp"
+#include "provider.hpp"
 #include "test_helpers.h"
+#include "utils/cpp_helpers.hpp"
 #ifndef _WIN32
 #include "test_helpers_linux.h"
 #endif
 
-#include <umf/memory_provider.h>
-#include <umf/providers/provider_file_memory.h>
-
 using umf_test::test;
 
 #define FILE_PATH ((char *)"tmp_file")
@@ -39,22 +40,6 @@ static int compare_native_error_str(const char *message, int error) {
     return strncmp(message, error_str, len);
 }
 
-using providerCreateExtParams = std::tuple<umf_memory_provider_ops_t *, void *>;
-
-static void providerCreateExt(providerCreateExtParams params,
-                              umf::provider_unique_handle_t *handle) {
-    umf_memory_provider_handle_t hProvider = nullptr;
-    auto [provider_ops, provider_params] = params;
-
-    auto ret =
-        umfMemoryProviderCreate(provider_ops, provider_params, &hProvider);
-    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-    ASSERT_NE(hProvider, nullptr);
-
-    *handle =
-        umf::provider_unique_handle_t(hProvider, &umfMemoryProviderDestroy);
-}
-
 struct FileProviderParamsDefault
     : umf_test::test,
       ::testing::WithParamInterface<providerCreateExtParams> {
@@ -70,7 +55,7 @@ struct FileProviderParamsDefault
 
     void TearDown() override { test::TearDown(); }
 
-    umf::provider_unique_handle_t provider;
+    umf_test::provider_unique_handle_t provider;
     size_t page_size;
     size_t page_plus_64;
 };
@@ -98,14 +83,16 @@ static void test_alloc_free_success(umf_memory_provider_handle_t provider,
     }
 
     umf_result = umfMemoryProviderFree(provider, ptr, size);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 }
 
 static void verify_last_native_error(umf_memory_provider_handle_t provider,
                                      int32_t err) {
     const char *message;
     int32_t error;
-    umfMemoryProviderGetLastNativeError(provider, &message, &error);
+    umf_result_t ret =
+        umfMemoryProviderGetLastNativeError(provider, &message, &error);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_EQ(error, err);
     ASSERT_EQ(compare_native_error_str(message, error), 0);
 }
@@ -132,12 +119,12 @@ TEST_F(test, test_if_mapped_with_MAP_SYNC) {
     umf_result_t umf_result;
 
     char *path = getenv("UMF_TESTS_FSDAX_PATH");
-    if (path == nullptr || path[0] == 0) {
+    if (path == nullptr || path[0] == '\0') {
         GTEST_SKIP() << "Test skipped, UMF_TESTS_FSDAX_PATH is not set";
     }
 
     umf_file_memory_provider_params_handle_t params = nullptr;
-    umf_result = umfFileMemoryProviderParamsCreate(&params, path);
+    umf_result = umfFileMemoryProviderParamsCreate(path, &params);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_NE(params, nullptr);
 
@@ -159,9 +146,10 @@ TEST_F(test, test_if_mapped_with_MAP_SYNC) {
     bool flag_found = is_mapped_with_MAP_SYNC(path, buf, size);
 
     umf_result = umfMemoryProviderFree(hProvider, buf, size);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
     umfMemoryProviderDestroy(hProvider);
+    umfFileMemoryProviderParamsDestroy(params);
 
     // fail test if the "sf" flag was not found
     ASSERT_EQ(flag_found, true);
@@ -175,7 +163,7 @@ using file_params_unique_handle_t =
 
 file_params_unique_handle_t get_file_params_default(char *path) {
     umf_file_memory_provider_params_handle_t file_params = NULL;
-    umf_result_t res = umfFileMemoryProviderParamsCreate(&file_params, path);
+    umf_result_t res = umfFileMemoryProviderParamsCreate(path, &file_params);
     if (res != UMF_RESULT_SUCCESS) {
         throw std::runtime_error(
             "Failed to create File Memory Provider params");
@@ -190,7 +178,7 @@ file_params_unique_handle_t file_params_default =
 
 file_params_unique_handle_t get_file_params_shared(char *path) {
     umf_file_memory_provider_params_handle_t file_params = NULL;
-    umf_result_t res = umfFileMemoryProviderParamsCreate(&file_params, path);
+    umf_result_t res = umfFileMemoryProviderParamsCreate(path, &file_params);
     if (res != UMF_RESULT_SUCCESS) {
         throw std::runtime_error(
             "Failed to create File Memory Provider params");
@@ -214,7 +202,8 @@ file_params_unique_handle_t file_params_shared =
 INSTANTIATE_TEST_SUITE_P(fileProviderTest, FileProviderParamsDefault,
                          ::testing::Values(providerCreateExtParams{
                              umfFileMemoryProviderOps(),
-                             file_params_default.get()}));
+                             file_params_default.get()}),
+                         providerCreateExtParamsNameGen);
 
 TEST_P(FileProviderParamsDefault, create_destroy) {}
 
@@ -244,10 +233,10 @@ TEST_P(FileProviderParamsDefault, two_allocations) {
     memset(ptr2, 0x22, size);
 
     umf_result = umfMemoryProviderFree(provider.get(), ptr1, size);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
     umf_result = umfMemoryProviderFree(provider.get(), ptr2, size);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 }
 
 TEST_P(FileProviderParamsDefault, alloc_page64_align_0) {
@@ -359,26 +348,106 @@ TEST_P(FileProviderParamsDefault, get_recommended_page_size) {
 }
 
 TEST_P(FileProviderParamsDefault, get_name) {
-    const char *name = umfMemoryProviderGetName(provider.get());
+    const char *name = nullptr;
+    umf_result_t ret_get = umfMemoryProviderGetName(provider.get(), &name);
+    ASSERT_EQ(ret_get, UMF_RESULT_SUCCESS);
     ASSERT_STREQ(name, "FILE");
 }
 
+TEST(FileProviderName, custom_name) {
+    auto params = get_file_params_default(FILE_PATH);
+    ASSERT_NE(params.get(), nullptr);
+
+    const char *custom = "my_file";
+    auto ret = umfFileMemoryProviderParamsSetName(params.get(), custom);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    umf_memory_provider_handle_t prov = nullptr;
+    ret = umfMemoryProviderCreate(umfFileMemoryProviderOps(), params.get(),
+                                  &prov);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    const char *name = nullptr;
+    ret = umfMemoryProviderGetName(prov, &name);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, custom);
+    umfMemoryProviderDestroy(prov);
+}
+
+TEST(FileProviderName, default_name_null_handle) {
+    const char *name = nullptr;
+    auto ret = umfFileMemoryProviderOps()->get_name(nullptr, &name);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, "FILE");
+}
+
 TEST_P(FileProviderParamsDefault, free_size_0_ptr_not_null) {
     umf_result_t umf_result =
         umfMemoryProviderFree(provider.get(), INVALID_PTR, 0);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
 
 TEST_P(FileProviderParamsDefault, free_NULL) {
     umf_result_t umf_result = umfMemoryProviderFree(provider.get(), nullptr, 0);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(FileProviderParamsDefault, ctl_stats) {
+    size_t allocated = 0, peak = 0;
+    umf_result_t ret =
+        umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                  &allocated, sizeof(allocated), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, 0u);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, 0u);
+
+    void *ptr = nullptr;
+    size_t size = page_size;
+    ret = umfMemoryProviderAlloc(provider.get(), size, page_size, &ptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                    &allocated, sizeof(allocated), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, size);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, size);
+
+    ret = umfMemoryProviderFree(provider.get(), ptr, size);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                    &allocated, sizeof(allocated), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, 0u);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, size);
+
+    ret = umfCtlExec("umf.provider.by_handle.{}.stats.peak_memory.reset", NULL,
+                     0, provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, 0u);
 }
 
 // other negative tests
 
 TEST_F(test, params_null_handle) {
     umf_result_t umf_result =
-        umfFileMemoryProviderParamsCreate(nullptr, FILE_PATH);
+        umfFileMemoryProviderParamsCreate(FILE_PATH, nullptr);
     ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     umf_result = umfFileMemoryProviderParamsDestroy(nullptr);
@@ -401,7 +470,7 @@ TEST_F(test, create_empty_path) {
 
     umf_file_memory_provider_params_handle_t wrong_params = nullptr;
     umf_result_t umf_result =
-        umfFileMemoryProviderParamsCreate(&wrong_params, path);
+        umfFileMemoryProviderParamsCreate(path, &wrong_params);
     ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
     ASSERT_EQ(wrong_params, nullptr);
 }
@@ -411,7 +480,7 @@ TEST_F(test, create_null_path) {
 
     umf_file_memory_provider_params_handle_t wrong_params = nullptr;
     umf_result_t umf_result =
-        umfFileMemoryProviderParamsCreate(&wrong_params, path);
+        umfFileMemoryProviderParamsCreate(path, &wrong_params);
     ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
     ASSERT_EQ(wrong_params, nullptr);
 }
@@ -421,7 +490,7 @@ TEST_F(test, set_empty_path) {
 
     umf_file_memory_provider_params_handle_t params = nullptr;
     umf_result_t umf_result =
-        umfFileMemoryProviderParamsCreate(&params, FILE_PATH);
+        umfFileMemoryProviderParamsCreate(FILE_PATH, &params);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
     umf_result = umfFileMemoryProviderParamsSetPath(params, empty_path);
@@ -436,7 +505,7 @@ TEST_F(test, set_null_path) {
 
     umf_file_memory_provider_params_handle_t params = nullptr;
     umf_result_t umf_result =
-        umfFileMemoryProviderParamsCreate(&params, FILE_PATH);
+        umfFileMemoryProviderParamsCreate(FILE_PATH, &params);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
     umf_result = umfFileMemoryProviderParamsSetPath(params, null_path);
@@ -449,7 +518,7 @@ TEST_F(test, set_null_path) {
 TEST_P(FileProviderParamsDefault, free_INVALID_POINTER_SIZE_GT_0) {
     umf_result_t umf_result =
         umfMemoryProviderFree(provider.get(), INVALID_PTR, page_plus_64);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
 
 TEST_P(FileProviderParamsDefault, purge_lazy_INVALID_POINTER) {
@@ -472,7 +541,8 @@ TEST_P(FileProviderParamsDefault, purge_force_INVALID_POINTER) {
 INSTANTIATE_TEST_SUITE_P(fileProviderTest, FileProviderParamsShared,
                          ::testing::Values(providerCreateExtParams{
                              umfFileMemoryProviderOps(),
-                             file_params_shared.get()}));
+                             file_params_shared.get()}),
+                         providerCreateExtParamsNameGen);
 
 TEST_P(FileProviderParamsShared, IPC_base_success_test) {
     umf_result_t umf_result;
@@ -512,7 +582,7 @@ TEST_P(FileProviderParamsShared, IPC_base_success_test) {
     ASSERT_EQ(ret, 0);
 
     umf_result = umfMemoryProviderFree(provider.get(), ptr, size);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 }
 
 TEST_P(FileProviderParamsShared, IPC_file_not_exist) {
@@ -552,5 +622,5 @@ TEST_P(FileProviderParamsShared, IPC_file_not_exist) {
     ASSERT_EQ(new_ptr, nullptr);
 
     umf_result = umfMemoryProviderFree(provider.get(), ptr, size);
-    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 }
diff --git a/test/provider_file_memory_ipc.cpp b/test/provider_file_memory_ipc.cpp
index ee7ab6c8ff..fe50d8408f 100644
--- a/test/provider_file_memory_ipc.cpp
+++ b/test/provider_file_memory_ipc.cpp
@@ -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
 
@@ -17,13 +17,10 @@ using umf_test::test;
 
 #define FILE_PATH ((char *)"tmp_file")
 
-using file_params_unique_handle_t =
-    std::unique_ptr<umf_file_memory_provider_params_t,
-                    decltype(&umfFileMemoryProviderParamsDestroy)>;
-
-file_params_unique_handle_t get_file_params_shared(char *path) {
+void *createFileParamsShared() {
     umf_file_memory_provider_params_handle_t file_params = NULL;
-    umf_result_t res = umfFileMemoryProviderParamsCreate(&file_params, path);
+    umf_result_t res =
+        umfFileMemoryProviderParamsCreate(FILE_PATH, &file_params);
     if (res != UMF_RESULT_SUCCESS) {
         throw std::runtime_error(
             "Failed to create File Memory Provider params");
@@ -37,20 +34,21 @@ file_params_unique_handle_t get_file_params_shared(char *path) {
                                  "Memory Provider params");
     }
 
-    return file_params_unique_handle_t(file_params,
-                                       &umfFileMemoryProviderParamsDestroy);
+    return file_params;
 }
 
-file_params_unique_handle_t file_params_shared =
-    get_file_params_shared(FILE_PATH);
+umf_result_t destroyFileParamsShared(void *params) {
+    return umfFileMemoryProviderParamsDestroy(
+        (umf_file_memory_provider_params_handle_t)params);
+}
 
-file_params_unique_handle_t get_file_params_fsdax(char *path) {
+void *createFileParamsFSDAX() {
     umf_file_memory_provider_params_handle_t file_params = NULL;
-    umf_result_t res = umfFileMemoryProviderParamsCreate(&file_params, path);
+    umf_result_t res = umfFileMemoryProviderParamsCreate(
+        getenv("UMF_TESTS_FSDAX_PATH"), &file_params);
     if (res != UMF_RESULT_SUCCESS) {
         //test will be skipped.
-        return file_params_unique_handle_t(nullptr,
-                                           &umfFileMemoryProviderParamsDestroy);
+        return nullptr;
     }
 
     res = umfFileMemoryProviderParamsSetVisibility(file_params,
@@ -61,26 +59,54 @@ file_params_unique_handle_t get_file_params_fsdax(char *path) {
                                  "Memory Provider params");
     }
 
-    return file_params_unique_handle_t(file_params,
-                                       &umfFileMemoryProviderParamsDestroy);
+    return file_params;
+}
+
+umf_result_t destroyFileParamsFSDAX(void *params) {
+    return umfFileMemoryProviderParamsDestroy(
+        (umf_file_memory_provider_params_handle_t)params);
 }
 
-file_params_unique_handle_t file_params_fsdax =
-    get_file_params_fsdax(getenv("UMF_TESTS_FSDAX_PATH"));
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+void *createJemallocParams() {
+    umf_jemalloc_pool_params_handle_t jemalloc_params = NULL;
+    umf_result_t res = umfJemallocPoolParamsCreate(&jemalloc_params);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error("Failed to create Jemalloc Pool params");
+    }
+
+    // This test creates multiple pools, so we need to reduce the number of arenas
+    // to avoid hitting the maximum arena limit on systems with many cores.
+    res = umfJemallocPoolParamsSetNumArenas(jemalloc_params, 1);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfJemallocPoolParamsDestroy(jemalloc_params);
+        throw std::runtime_error("Failed to set number of arenas for Jemalloc "
+                                 "Pool params");
+    }
+    return jemalloc_params;
+}
+
+umf_result_t destroyJemallocParams(void *params) {
+    return umfJemallocPoolParamsDestroy(
+        (umf_jemalloc_pool_params_handle_t)params);
+}
+
+#endif
 
 HostMemoryAccessor hostAccessor;
 
 static std::vector<ipcTestParams> ipcManyPoolsTestParamsList = {
 // TODO: enable it when sizes of allocations in ipcFixtures.hpp are fixed
 //    {umfProxyPoolOps(), nullptr, umfFileMemoryProviderOps(),
-//     file_params_shared.get(), &hostAccessor, true},
+//     file_params_shared.get(), &hostAccessor},
 #ifdef UMF_POOL_JEMALLOC_ENABLED
-    {umfJemallocPoolOps(), nullptr, umfFileMemoryProviderOps(),
-     file_params_shared.get(), &hostAccessor, false},
+    {umfJemallocPoolOps(), createJemallocParams, destroyJemallocParams,
+     umfFileMemoryProviderOps(), createFileParamsShared,
+     destroyFileParamsShared, &hostAccessor},
 #endif
 #ifdef UMF_POOL_SCALABLE_ENABLED
-    {umfScalablePoolOps(), nullptr, umfFileMemoryProviderOps(),
-     file_params_shared.get(), &hostAccessor, false},
+    {umfScalablePoolOps(), nullptr, nullptr, umfFileMemoryProviderOps(),
+     createFileParamsShared, destroyFileParamsShared, &hostAccessor},
 #endif
 };
 
@@ -88,7 +114,7 @@ static std::vector<ipcTestParams> getIpcFsDaxTestParamsList(void) {
     std::vector<ipcTestParams> ipcFsDaxTestParamsList = {};
 
     char *path = getenv("UMF_TESTS_FSDAX_PATH");
-    if (path == nullptr || path[0] == 0) {
+    if (path == nullptr || path[0] == '\0') {
         // skipping the test, UMF_TESTS_FSDAX_PATH is not set
         return ipcFsDaxTestParamsList;
     }
@@ -96,14 +122,15 @@ static std::vector<ipcTestParams> getIpcFsDaxTestParamsList(void) {
     ipcFsDaxTestParamsList = {
 // TODO: enable it when sizes of allocations in ipcFixtures.hpp are fixed
 //        {umfProxyPoolOps(), nullptr, umfFileMemoryProviderOps(),
-//         file_params_fsdax.get(), &hostAccessor, true},
+//         file_params_fsdax.get(), &hostAccessor},
 #ifdef UMF_POOL_JEMALLOC_ENABLED
-        {umfJemallocPoolOps(), nullptr, umfFileMemoryProviderOps(),
-         file_params_fsdax.get(), &hostAccessor, false},
+        {umfJemallocPoolOps(), createJemallocParams, destroyJemallocParams,
+         umfFileMemoryProviderOps(), createFileParamsFSDAX,
+         destroyFileParamsFSDAX, &hostAccessor},
 #endif
 #ifdef UMF_POOL_SCALABLE_ENABLED
-        {umfScalablePoolOps(), nullptr, umfFileMemoryProviderOps(),
-         file_params_fsdax.get(), &hostAccessor, false},
+        {umfScalablePoolOps(), nullptr, nullptr, umfFileMemoryProviderOps(),
+         createFileParamsFSDAX, destroyFileParamsFSDAX, &hostAccessor},
 #endif
     };
 
@@ -113,7 +140,9 @@ static std::vector<ipcTestParams> getIpcFsDaxTestParamsList(void) {
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest);
 
 INSTANTIATE_TEST_SUITE_P(FileProviderDifferentPoolsTest, umfIpcTest,
-                         ::testing::ValuesIn(ipcManyPoolsTestParamsList));
+                         ::testing::ValuesIn(ipcManyPoolsTestParamsList),
+                         ipcTestParamsNameGen);
 
 INSTANTIATE_TEST_SUITE_P(FileProviderDifferentPoolsFSDAXTest, umfIpcTest,
-                         ::testing::ValuesIn(getIpcFsDaxTestParamsList()));
+                         ::testing::ValuesIn(getIpcFsDaxTestParamsList()),
+                         ipcTestParamsNameGen);
diff --git a/test/provider_file_memory_not_impl.cpp b/test/provider_file_memory_not_impl.cpp
index c82b8163cb..84ae5ffdfe 100644
--- a/test/provider_file_memory_not_impl.cpp
+++ b/test/provider_file_memory_not_impl.cpp
@@ -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
 
@@ -11,7 +11,7 @@ using umf_test::test;
 TEST_F(test, file_provider_not_implemented) {
     umf_file_memory_provider_params_handle_t params = nullptr;
     umf_result_t umf_result =
-        umfFileMemoryProviderParamsCreate(&params, "path");
+        umfFileMemoryProviderParamsCreate("path", &params);
     EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
     EXPECT_EQ(params, nullptr);
 
@@ -28,6 +28,6 @@ TEST_F(test, file_provider_not_implemented) {
         umfFileMemoryProviderParamsSetVisibility(nullptr, UMF_MEM_MAP_PRIVATE);
     EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
 
-    umf_memory_provider_ops_t *ops = umfFileMemoryProviderOps();
+    const umf_memory_provider_ops_t *ops = umfFileMemoryProviderOps();
     EXPECT_EQ(ops, nullptr);
-}
\ No newline at end of file
+}
diff --git a/test/provider_fixed_memory.cpp b/test/provider_fixed_memory.cpp
new file mode 100644
index 0000000000..a72deda63a
--- /dev/null
+++ b/test/provider_fixed_memory.cpp
@@ -0,0 +1,680 @@
+// 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
+
+#include <umf/experimental/ctl.h>
+#include <umf/memory_provider.h>
+#include <umf/pools/pool_proxy.h>
+#include <umf/providers/provider_fixed_memory.h>
+
+#include "base.hpp"
+#include "provider.hpp"
+#include "test_helpers.h"
+#include "utils/cpp_helpers.hpp"
+#ifndef _WIN32
+#include "test_helpers_linux.h"
+#endif
+
+using umf_test::test;
+
+#define FIXED_BUFFER_SIZE (10 * utils_get_page_size())
+#define INVALID_PTR ((void *)0x01)
+
+typedef enum purge_t {
+    PURGE_NONE = 0,
+    PURGE_LAZY = 1,
+    PURGE_FORCE = 2,
+} purge_t;
+
+static const char *Native_error_str[] = {
+    "success",              // UMF_FIXED_RESULT_SUCCESS
+    "force purging failed", // UMF_FIXED_RESULT_ERROR_PURGE_FORCE_FAILED
+};
+
+// Test helpers
+
+static int compare_native_error_str(const char *message, int error) {
+    const char *error_str = Native_error_str[error - UMF_FIXED_RESULT_SUCCESS];
+    size_t len = strlen(error_str);
+    return strncmp(message, error_str, len);
+}
+
+struct FixedProviderTest
+    : umf_test::test,
+      ::testing::WithParamInterface<providerCreateExtParams> {
+    void SetUp() override {
+        test::SetUp();
+
+        // Allocate a memory buffer to use with the fixed memory provider
+        memory_size = FIXED_BUFFER_SIZE; // Allocate 10 pages
+        memory_buffer = malloc(memory_size);
+        ASSERT_NE(memory_buffer, nullptr);
+
+        // Create provider parameters
+        umf_fixed_memory_provider_params_handle_t params = nullptr;
+        umf_result_t res = umfFixedMemoryProviderParamsCreate(
+            memory_buffer, memory_size, &params);
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+        ASSERT_NE(params, nullptr);
+
+        providerCreateExt(std::make_tuple(umfFixedMemoryProviderOps(), params),
+                          &provider);
+
+        umfFixedMemoryProviderParamsDestroy(params);
+        umf_result_t umf_result =
+            umfMemoryProviderGetMinPageSize(provider.get(), NULL, &page_size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+        page_plus_64 = page_size + 64;
+    }
+
+    void TearDown() override {
+        if (memory_buffer) {
+            free(memory_buffer);
+            memory_buffer = nullptr;
+        }
+        test::TearDown();
+    }
+
+    void test_alloc_free_success(size_t size, size_t alignment, purge_t purge) {
+        void *ptr = nullptr;
+        auto provider = this->provider.get();
+
+        umf_result_t umf_result =
+            umfMemoryProviderAlloc(provider, size, alignment, &ptr);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ptr, nullptr);
+
+        memset(ptr, 0xFF, size);
+
+        if (purge == PURGE_LAZY) {
+            umf_result = umfMemoryProviderPurgeLazy(provider, ptr, size);
+            ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+        } else if (purge == PURGE_FORCE) {
+            umf_result = umfMemoryProviderPurgeForce(provider, ptr, size);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+
+        umf_result = umfMemoryProviderFree(provider, ptr, size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+
+    void verify_last_native_error(int32_t err) {
+        const char *message;
+        int32_t error;
+        auto provider = this->provider.get();
+        umf_result_t ret =
+            umfMemoryProviderGetLastNativeError(provider, &message, &error);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_EQ(error, err);
+        ASSERT_EQ(compare_native_error_str(message, error), 0);
+    }
+
+    void test_alloc_failure(size_t size, size_t alignment, umf_result_t result,
+                            int32_t err) {
+        void *ptr = nullptr;
+        auto provider = this->provider.get();
+
+        umf_result_t umf_result =
+            umfMemoryProviderAlloc(provider, size, alignment, &ptr);
+        ASSERT_EQ(umf_result, result);
+        ASSERT_EQ(ptr, nullptr);
+
+        if (umf_result == UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC) {
+            verify_last_native_error(err);
+        }
+    }
+
+    umf_test::provider_unique_handle_t provider;
+    size_t page_size;
+    size_t page_plus_64;
+    void *memory_buffer = nullptr;
+    size_t memory_size = 0;
+};
+
+// TESTS
+
+// Positive tests using test_alloc_free_success
+
+INSTANTIATE_TEST_SUITE_P(fixedProviderTest, FixedProviderTest,
+                         ::testing::Values(providerCreateExtParams{
+                             umfFixedMemoryProviderOps(), nullptr}),
+                         providerCreateExtParamsNameGen);
+
+TEST_P(FixedProviderTest, create_destroy) {
+    // Creation and destruction are handled in SetUp and TearDown
+}
+
+TEST_F(test, create_no_params) {
+    umf_memory_provider_handle_t provider = nullptr;
+    auto result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), nullptr,
+                                          &provider);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(provider, nullptr);
+}
+
+TEST_P(FixedProviderTest, two_allocations) {
+    umf_result_t umf_result;
+    void *ptr1 = nullptr;
+    void *ptr2 = nullptr;
+    size_t size = page_plus_64;
+    size_t alignment = page_size;
+
+    umf_result = umfMemoryProviderAlloc(provider.get(), size, alignment, &ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr1, nullptr);
+
+    umf_result = umfMemoryProviderAlloc(provider.get(), size, alignment, &ptr2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr2, nullptr);
+
+    ASSERT_NE(ptr1, ptr2);
+    if ((uintptr_t)ptr1 > (uintptr_t)ptr2) {
+        ASSERT_GT((uintptr_t)ptr1 - (uintptr_t)ptr2, size);
+    } else {
+        ASSERT_GT((uintptr_t)ptr2 - (uintptr_t)ptr1, size);
+    }
+
+    memset(ptr1, 0x11, size);
+    memset(ptr2, 0x22, size);
+
+    umf_result = umfMemoryProviderFree(provider.get(), ptr1, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfMemoryProviderFree(provider.get(), ptr2, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(FixedProviderTest, alloc_page64_align_0) {
+    test_alloc_free_success(page_plus_64, 0, PURGE_NONE);
+}
+
+TEST_P(FixedProviderTest, alloc_page64_align_page_div_2) {
+    test_alloc_free_success(page_plus_64, page_size / 2, PURGE_NONE);
+}
+
+TEST_P(FixedProviderTest, purge_lazy) {
+    test_alloc_free_success(page_size, 0, PURGE_LAZY);
+}
+
+TEST_P(FixedProviderTest, purge_force) {
+    test_alloc_free_success(page_size, 0, PURGE_FORCE);
+}
+
+// Negative tests using test_alloc_failure
+
+TEST_P(FixedProviderTest, alloc_WRONG_SIZE) {
+    test_alloc_failure((size_t)-1, 0, UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY, 0);
+}
+
+TEST_P(FixedProviderTest, alloc_page64_WRONG_ALIGNMENT_3_pages) {
+    test_alloc_failure(page_plus_64, 3 * page_size,
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
+}
+
+TEST_P(FixedProviderTest, alloc_3pages_WRONG_ALIGNMENT_3pages) {
+    test_alloc_failure(3 * page_size, 3 * page_size,
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
+}
+
+TEST_P(FixedProviderTest, alloc_page64_align_page_plus_1_WRONG_ALIGNMENT_1) {
+    test_alloc_failure(page_plus_64, page_size + 1,
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
+}
+
+TEST_P(FixedProviderTest, alloc_page64_align_one_half_pages_WRONG_ALIGNMENT_2) {
+    test_alloc_failure(page_plus_64, page_size + (page_size / 2),
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
+}
+
+TEST_P(FixedProviderTest, alloc_size_exceeds_buffer) {
+    size_t size = memory_size + page_size;
+    test_alloc_failure(size, 0, UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY, 0);
+}
+
+// Other positive tests
+
+TEST_P(FixedProviderTest, get_min_page_size) {
+    size_t min_page_size;
+    umf_result_t umf_result = umfMemoryProviderGetMinPageSize(
+        provider.get(), nullptr, &min_page_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_LE(min_page_size, page_size);
+}
+
+TEST_P(FixedProviderTest, get_recommended_page_size) {
+    size_t min_page_size;
+    umf_result_t umf_result = umfMemoryProviderGetMinPageSize(
+        provider.get(), nullptr, &min_page_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_LE(min_page_size, page_size);
+
+    size_t recommended_page_size;
+    umf_result = umfMemoryProviderGetRecommendedPageSize(
+        provider.get(), 0, &recommended_page_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_GE(recommended_page_size, min_page_size);
+}
+
+TEST_P(FixedProviderTest, get_name) {
+    const char *name = nullptr;
+    umf_result_t ret = umfMemoryProviderGetName(provider.get(), &name);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_STREQ(name, "FIXED");
+}
+
+TEST(FixedProviderName, custom_name) {
+    size_t mem_size = utils_get_page_size();
+    void *buffer = malloc(mem_size);
+    ASSERT_NE(buffer, nullptr);
+
+    umf_fixed_memory_provider_params_handle_t params = nullptr;
+    auto ret = umfFixedMemoryProviderParamsCreate(buffer, mem_size, &params);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    const char *custom = "my_fixed";
+    ret = umfFixedMemoryProviderParamsSetName(params, custom);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    umf_memory_provider_handle_t prov = nullptr;
+    ret = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params, &prov);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    const char *name = nullptr;
+    ret = umfMemoryProviderGetName(prov, &name);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, custom);
+
+    umfMemoryProviderDestroy(prov);
+    umfFixedMemoryProviderParamsDestroy(params);
+    free(buffer);
+}
+
+TEST(FixedProviderName, default_name_null_handle) {
+    const char *name = nullptr;
+    auto ret = umfFixedMemoryProviderOps()->get_name(nullptr, &name);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, "FIXED");
+}
+
+TEST_P(FixedProviderTest, free_size_0_ptr_not_null) {
+    umf_result_t umf_result =
+        umfMemoryProviderFree(provider.get(), INVALID_PTR, 0);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(FixedProviderTest, free_NULL) {
+    umf_result_t umf_result = umfMemoryProviderFree(provider.get(), nullptr, 0);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+// Other negative tests
+
+TEST_P(FixedProviderTest, free_INVALID_POINTER_SIZE_GT_0) {
+    umf_result_t umf_result =
+        umfMemoryProviderFree(provider.get(), INVALID_PTR, page_plus_64);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(FixedProviderTest, purge_lazy_INVALID_POINTER) {
+    umf_result_t umf_result =
+        umfMemoryProviderPurgeLazy(provider.get(), INVALID_PTR, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+}
+
+TEST_P(FixedProviderTest, purge_force_INVALID_POINTER) {
+    umf_result_t umf_result =
+        umfMemoryProviderPurgeForce(provider.get(), INVALID_PTR, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC);
+
+    verify_last_native_error(UMF_FIXED_RESULT_ERROR_PURGE_FORCE_FAILED);
+}
+
+TEST_P(FixedProviderTest, ctl_stats) {
+    size_t allocated = 0, peak = 0;
+    umf_result_t ret =
+        umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                  &allocated, sizeof(allocated), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, 0u);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, 0u);
+
+    void *ptr = nullptr;
+    size_t size = page_size;
+    ret = umfMemoryProviderAlloc(provider.get(), size, page_size, &ptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                    &allocated, sizeof(allocated), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, size);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, size);
+
+    ret = umfMemoryProviderFree(provider.get(), ptr, size);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                    &allocated, sizeof(allocated), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, 0u);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, size);
+
+    ret = umfCtlExec("umf.provider.by_handle.{}.stats.peak_memory.reset", NULL,
+                     0, provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, 0u);
+}
+
+// Params tests
+
+TEST_F(test, params_null_handle) {
+    constexpr size_t memory_size = 100;
+    char memory_buffer[memory_size];
+    umf_result_t umf_result =
+        umfFixedMemoryProviderParamsCreate(memory_buffer, memory_size, nullptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result = umfFixedMemoryProviderParamsDestroy(nullptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_F(test, create_with_null_ptr) {
+    constexpr size_t memory_size = 100;
+    umf_fixed_memory_provider_params_handle_t wrong_params = nullptr;
+    umf_result_t umf_result =
+        umfFixedMemoryProviderParamsCreate(nullptr, memory_size, &wrong_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(wrong_params, nullptr);
+}
+
+TEST_F(test, create_with_zero_size) {
+    constexpr size_t memory_size = 100;
+    char memory_buffer[memory_size];
+    umf_fixed_memory_provider_params_handle_t wrong_params = nullptr;
+    umf_result_t umf_result =
+        umfFixedMemoryProviderParamsCreate(memory_buffer, 0, &wrong_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(wrong_params, nullptr);
+}
+
+TEST_F(test, params_several_set_memory) {
+    umf_memory_provider_handle_t provider1 = nullptr, provider2 = nullptr;
+    size_t memory_size1 = FIXED_BUFFER_SIZE,
+           memory_size2 = FIXED_BUFFER_SIZE * 10;
+    size_t alloc_size1 = memory_size1 / 2, alloc_size2 = memory_size2 / 2;
+    void *memory_buffer1 = nullptr;
+    void *memory_buffer2 = nullptr;
+    memory_buffer1 = malloc(memory_size1);
+    memory_buffer2 = malloc(memory_size2);
+    void *ptr1 = nullptr;
+    void *ptr2 = nullptr;
+    const char *source_str = "Allocated memory!";
+
+    umf_fixed_memory_provider_params_handle_t params = nullptr;
+    umf_result_t umf_result = umfFixedMemoryProviderParamsCreate(
+        memory_buffer1, memory_size1, &params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
+                                         &provider1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfMemoryProviderAlloc(provider1, alloc_size1, 0, &ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr1, nullptr);
+
+    // provider1: write to the allocated memory and free it
+    memset(ptr1, '\0', alloc_size1);
+    memcpy(ptr1, (const void *)source_str, sizeof(source_str));
+    ASSERT_GE((uintptr_t)ptr1, (uintptr_t)memory_buffer1);
+    ASSERT_LE((uintptr_t)ptr1 + alloc_size1,
+              (uintptr_t)memory_buffer1 + memory_size1);
+
+    umf_result = umfMemoryProviderFree(provider1, ptr1, alloc_size1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // Reuse the same params for the new provider
+    umf_result = umfFixedMemoryProviderParamsSetMemory(params, memory_buffer2,
+                                                       memory_size2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
+                                         &provider2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfMemoryProviderAlloc(provider2, alloc_size2, 0, &ptr2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr2, nullptr);
+
+    // provider2: write to the allocated memory and free it
+    memset(ptr2, '\0', alloc_size2);
+    memcpy(ptr2, (const void *)source_str, sizeof(source_str));
+    ASSERT_GE((uintptr_t)ptr2, (uintptr_t)memory_buffer2);
+    ASSERT_LE((uintptr_t)ptr2 + alloc_size2,
+              (uintptr_t)memory_buffer2 + memory_size2);
+
+    umf_result = umfMemoryProviderFree(provider2, ptr2, alloc_size2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_NE(ptr1, ptr2);
+    ASSERT_NE(provider1, provider2);
+
+    // Cleanup
+    umfMemoryProviderDestroy(provider1);
+    umfMemoryProviderDestroy(provider2);
+
+    umf_result = umfFixedMemoryProviderParamsDestroy(params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    free(memory_buffer1);
+    free(memory_buffer2);
+}
+
+TEST_F(test, params_invalid_set_memory) {
+    constexpr size_t memory_size = 100;
+    char memory_buffer[memory_size];
+    umf_fixed_memory_provider_params_handle_t valid_params = nullptr;
+    umf_result_t umf_result = umfFixedMemoryProviderParamsCreate(
+        memory_buffer, memory_size, &valid_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result =
+        umfFixedMemoryProviderParamsSetMemory(NULL, memory_buffer, memory_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result =
+        umfFixedMemoryProviderParamsSetMemory(valid_params, NULL, memory_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result =
+        umfFixedMemoryProviderParamsSetMemory(valid_params, memory_buffer, 0);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result = umfFixedMemoryProviderParamsDestroy(valid_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+// Split / merge tests
+
+TEST_P(FixedProviderTest, merge) {
+    umf_result_t umf_result;
+    void *ptr1 = nullptr;
+    void *ptr2 = nullptr;
+    size_t size = page_size;
+    size_t alignment = page_size;
+
+    umf_result = umfMemoryProviderAlloc(provider.get(), size, alignment, &ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr1, nullptr);
+
+    umf_result = umfMemoryProviderAlloc(provider.get(), size, alignment, &ptr2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr2, nullptr);
+
+    ASSERT_EQ((uintptr_t)ptr2 - (uintptr_t)ptr1, size);
+
+    memset(ptr1, 0x11, size);
+    memset(ptr2, 0x22, size);
+
+    size_t merged_size = size * 2;
+    umf_result = umfMemoryProviderAllocationMerge(provider.get(), ptr1, ptr2,
+                                                  merged_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfMemoryProviderFree(provider.get(), ptr1, merged_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(FixedProviderTest, split) {
+    umf_result_t umf_result;
+    void *ptr1 = nullptr;
+    void *ptr2 = nullptr;
+    size_t size = page_size;
+    size_t alignment = page_size;
+
+    umf_result =
+        umfMemoryProviderAlloc(provider.get(), size * 2, alignment, &ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr1, nullptr);
+
+    umf_result =
+        umfMemoryProviderAllocationSplit(provider.get(), ptr1, size * 2, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ptr2 = (void *)((uintptr_t)ptr1 + size);
+    memset(ptr1, 0x11, size);
+
+    umf_result = umfMemoryProviderFree(provider.get(), ptr1, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    memset(ptr2, 0x22, size);
+    umf_result = umfMemoryProviderFree(provider.get(), ptr2, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(FixedProviderTest, pool_from_ptr_whole_size_success) {
+    umf_result_t umf_result;
+    size_t size_of_first_alloc;
+    size_t size_of_pool_from_ptr;
+    void *ptr_for_pool = nullptr;
+    void *ptr = nullptr;
+
+    umf_memory_pool_handle_t proxyFixedPool = nullptr;
+    umf_result = umfPoolCreate(umfProxyPoolOps(), provider.get(), nullptr, 0,
+                               &proxyFixedPool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    size_of_first_alloc = FIXED_BUFFER_SIZE - (2 * page_size);
+    ptr_for_pool = umfPoolMalloc(proxyFixedPool, size_of_first_alloc);
+    ASSERT_NE(ptr_for_pool, nullptr);
+
+    // Create provider parameters
+    size_of_pool_from_ptr = size_of_first_alloc; // whole size
+    umf_fixed_memory_provider_params_handle_t params = nullptr;
+    umf_result = umfFixedMemoryProviderParamsCreate(
+        ptr_for_pool, size_of_pool_from_ptr, &params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(params, nullptr);
+
+    umf_memory_provider_handle_t providerFromPtr = nullptr;
+    umf_result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
+                                         &providerFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(providerFromPtr, nullptr);
+
+    umf_memory_pool_handle_t poolFromPtr = nullptr;
+    umf_result = umfPoolCreate(umfProxyPoolOps(), providerFromPtr, nullptr, 0,
+                               &poolFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ptr = umfPoolMalloc(poolFromPtr, size_of_pool_from_ptr);
+    ASSERT_NE(ptr, nullptr);
+
+    memset(ptr, 0xFF, size_of_pool_from_ptr);
+
+    umf_result = umfPoolFree(poolFromPtr, ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolDestroy(poolFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umfMemoryProviderDestroy(providerFromPtr);
+    umfFixedMemoryProviderParamsDestroy(params);
+
+    umf_result = umfPoolFree(proxyFixedPool, ptr_for_pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolDestroy(proxyFixedPool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(FixedProviderTest, pool_from_ptr_half_size_success) {
+    umf_result_t umf_result;
+    size_t size_of_first_alloc;
+    size_t size_of_pool_from_ptr;
+    void *ptr_for_pool = nullptr;
+    void *ptr = nullptr;
+
+    umf_memory_pool_handle_t proxyFixedPool = nullptr;
+    umf_result = umfPoolCreate(umfProxyPoolOps(), provider.get(), nullptr, 0,
+                               &proxyFixedPool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    size_of_first_alloc = FIXED_BUFFER_SIZE - (2 * page_size);
+    ptr_for_pool = umfPoolMalloc(proxyFixedPool, size_of_first_alloc);
+    ASSERT_NE(ptr_for_pool, nullptr);
+
+    // Create provider parameters
+    size_of_pool_from_ptr = size_of_first_alloc / 2; // half size
+    umf_fixed_memory_provider_params_handle_t params = nullptr;
+    umf_result = umfFixedMemoryProviderParamsCreate(
+        ptr_for_pool, size_of_pool_from_ptr, &params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(params, nullptr);
+
+    umf_memory_provider_handle_t providerFromPtr = nullptr;
+    umf_result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
+                                         &providerFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(providerFromPtr, nullptr);
+
+    umf_memory_pool_handle_t poolFromPtr = nullptr;
+    umf_result = umfPoolCreate(umfProxyPoolOps(), providerFromPtr, nullptr, 0,
+                               &poolFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ptr = umfPoolMalloc(poolFromPtr, size_of_pool_from_ptr);
+    ASSERT_NE(ptr, nullptr);
+
+    memset(ptr, 0xFF, size_of_pool_from_ptr);
+
+    umf_result = umfPoolFree(poolFromPtr, ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolDestroy(poolFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umfMemoryProviderDestroy(providerFromPtr);
+    umfFixedMemoryProviderParamsDestroy(params);
+
+    umf_result = umfPoolFree(proxyFixedPool, ptr_for_pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolDestroy(proxyFixedPool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
diff --git a/test/provider_os_memory.cpp b/test/provider_os_memory.cpp
index 57bce46d24..49b023a741 100644
--- a/test/provider_os_memory.cpp
+++ b/test/provider_os_memory.cpp
@@ -1,22 +1,21 @@
-// Copyright (C) 2023 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 "base.hpp"
-
-#include "cpp_helpers.hpp"
-#include "ipcFixtures.hpp"
-#include "test_helpers.h"
-
+#include <umf/experimental/ctl.h>
 #include <umf/memory_provider.h>
-#include <umf/providers/provider_os_memory.h>
-#if (defined UMF_POOL_DISJOINT_ENABLED)
 #include <umf/pools/pool_disjoint.h>
-#endif
+#include <umf/providers/provider_os_memory.h>
 #ifdef UMF_POOL_JEMALLOC_ENABLED
 #include <umf/pools/pool_jemalloc.h>
 #endif
 
+#include "base.hpp"
+#include "ipcFixtures.hpp"
+#include "provider.hpp"
+#include "test_helpers.h"
+#include "utils/cpp_helpers.hpp"
+
 using umf_test::test;
 
 #define INVALID_PTR ((void *)0x01)
@@ -46,22 +45,6 @@ static int compare_native_error_str(const char *message, int error) {
     return strncmp(message, error_str, len);
 }
 
-using providerCreateExtParams = std::tuple<umf_memory_provider_ops_t *, void *>;
-
-static void providerCreateExt(providerCreateExtParams params,
-                              umf::provider_unique_handle_t *handle) {
-    umf_memory_provider_handle_t hProvider = nullptr;
-    auto [provider_ops, provider_params] = params;
-
-    auto ret =
-        umfMemoryProviderCreate(provider_ops, provider_params, &hProvider);
-    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-    ASSERT_NE(hProvider, nullptr);
-
-    *handle =
-        umf::provider_unique_handle_t(hProvider, &umfMemoryProviderDestroy);
-}
-
 struct umfProviderTest
     : umf_test::test,
       ::testing::WithParamInterface<providerCreateExtParams> {
@@ -77,7 +60,7 @@ struct umfProviderTest
 
     void TearDown() override { test::TearDown(); }
 
-    umf::provider_unique_handle_t provider;
+    umf_test::provider_unique_handle_t provider;
     size_t page_size;
     size_t page_plus_64;
 };
@@ -110,7 +93,9 @@ static void verify_last_native_error(umf_memory_provider_handle_t provider,
                                      int32_t err) {
     const char *message;
     int32_t error;
-    umfMemoryProviderGetLastNativeError(provider, &message, &error);
+    umf_result_t ret =
+        umfMemoryProviderGetLastNativeError(provider, &message, &error);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_EQ(error, err);
     ASSERT_EQ(compare_native_error_str(message, error), 0);
 }
@@ -217,9 +202,9 @@ TEST_F(test, create_ZERO_WEIGHT_PARTITION) {
         os_memory_provider_params, &p, 1);
     EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(),
-                                         &os_memory_provider_params,
-                                         &os_memory_provider);
+    umf_result =
+        umfMemoryProviderCreate(umfOsMemoryProviderOps(),
+                                os_memory_provider_params, &os_memory_provider);
 
     umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
 
@@ -246,7 +231,8 @@ auto defaultParams = createOsMemoryProviderParams();
 
 INSTANTIATE_TEST_SUITE_P(osProviderTest, umfProviderTest,
                          ::testing::Values(providerCreateExtParams{
-                             umfOsMemoryProviderOps(), defaultParams.get()}));
+                             umfOsMemoryProviderOps(), defaultParams.get()}),
+                         providerCreateExtParamsNameGen);
 
 TEST_P(umfProviderTest, create_destroy) {}
 
@@ -327,10 +313,38 @@ TEST_P(umfProviderTest, get_recommended_page_size) {
 }
 
 TEST_P(umfProviderTest, get_name) {
-    const char *name = umfMemoryProviderGetName(provider.get());
+    const char *name = nullptr;
+    umf_result_t ret = umfMemoryProviderGetName(provider.get(), &name);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_STREQ(name, "OS");
 }
 
+TEST(OsProviderName, custom_name) {
+    auto params = createOsMemoryProviderParams();
+    ASSERT_NE(params.get(), nullptr);
+    const char *custom = "my_os";
+    auto ret = umfOsMemoryProviderParamsSetName(params.get(), custom);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    umf_memory_provider_handle_t prov = nullptr;
+    ret =
+        umfMemoryProviderCreate(umfOsMemoryProviderOps(), params.get(), &prov);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    const char *name = nullptr;
+    ret = umfMemoryProviderGetName(prov, &name);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, custom);
+    umfMemoryProviderDestroy(prov);
+}
+
+TEST(OsProviderName, default_name_null_handle) {
+    const char *name = nullptr;
+    auto ret = umfOsMemoryProviderOps()->get_name(nullptr, &name);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, "OS");
+}
+
 TEST_P(umfProviderTest, free_size_0_ptr_not_null) {
     umf_result_t umf_result =
         umfMemoryProviderFree(provider.get(), INVALID_PTR, 0);
@@ -405,13 +419,61 @@ TEST_P(umfProviderTest, close_ipc_handle_wrong_visibility) {
     ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
 
-GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest);
+TEST_P(umfProviderTest, ctl_stats) {
+    size_t allocated = 0, peak = 0;
+    umf_result_t ret =
+        umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                  &allocated, sizeof(allocated), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, 0u);
 
-using os_params_unique_handle_t =
-    std::unique_ptr<umf_os_memory_provider_params_t,
-                    decltype(&umfOsMemoryProviderParamsDestroy)>;
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, 0u);
 
-os_params_unique_handle_t osMemoryProviderParamsShared() {
+    void *ptr = nullptr;
+    size_t size = page_size;
+    ret = umfMemoryProviderAlloc(provider.get(), size, 0, &ptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                    &allocated, sizeof(allocated), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, size);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, size);
+
+    ret = umfMemoryProviderFree(provider.get(), ptr, size);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                    &allocated, sizeof(allocated), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, 0u);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, size);
+
+    ret = umfCtlExec("umf.provider.by_handle.{}.stats.peak_memory.reset", NULL,
+                     0, provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider.get());
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, 0u);
+}
+
+GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest);
+
+void *createOsMemoryProviderParamsShared() {
     umf_os_memory_provider_params_handle_t params = nullptr;
     umf_result_t res = umfOsMemoryProviderParamsCreate(&params);
     if (res != UMF_RESULT_SUCCESS) {
@@ -422,18 +484,17 @@ os_params_unique_handle_t osMemoryProviderParamsShared() {
         throw std::runtime_error("Failed to set protection");
     }
 
-    return os_params_unique_handle_t(params, &umfOsMemoryProviderParamsDestroy);
+    return params;
 }
-auto os_params = osMemoryProviderParamsShared();
 
-HostMemoryAccessor hostAccessor;
+umf_result_t destroyOsMemoryProviderParamsShared(void *params) {
+    return umfOsMemoryProviderParamsDestroy(
+        static_cast<umf_os_memory_provider_params_handle_t>(params));
+}
 
-#if (defined UMF_POOL_DISJOINT_ENABLED)
-using disjoint_params_unique_handle_t =
-    std::unique_ptr<umf_disjoint_pool_params_t,
-                    decltype(&umfDisjointPoolParamsDestroy)>;
+HostMemoryAccessor hostAccessor;
 
-disjoint_params_unique_handle_t disjointPoolParams() {
+void *createDisjointPoolParams() {
     umf_disjoint_pool_params_handle_t params = nullptr;
     umf_result_t res = umfDisjointPoolParamsCreate(&params);
     if (res != UMF_RESULT_SUCCESS) {
@@ -441,37 +502,70 @@ disjoint_params_unique_handle_t disjointPoolParams() {
     }
     res = umfDisjointPoolParamsSetSlabMinSize(params, 4096);
     if (res != UMF_RESULT_SUCCESS) {
+        umfDisjointPoolParamsDestroy(params);
         throw std::runtime_error("Failed to set slab min size");
     }
     res = umfDisjointPoolParamsSetMaxPoolableSize(params, 4096);
     if (res != UMF_RESULT_SUCCESS) {
+        umfDisjointPoolParamsDestroy(params);
         throw std::runtime_error("Failed to set max poolable size");
     }
     res = umfDisjointPoolParamsSetCapacity(params, 4);
     if (res != UMF_RESULT_SUCCESS) {
+        umfDisjointPoolParamsDestroy(params);
         throw std::runtime_error("Failed to set capacity");
     }
     res = umfDisjointPoolParamsSetMinBucketSize(params, 64);
     if (res != UMF_RESULT_SUCCESS) {
+        umfDisjointPoolParamsDestroy(params);
         throw std::runtime_error("Failed to set min bucket size");
     }
 
-    return disjoint_params_unique_handle_t(params,
-                                           &umfDisjointPoolParamsDestroy);
+    return params;
 }
-disjoint_params_unique_handle_t disjointParams = disjointPoolParams();
+
+umf_result_t destroyDisjointPoolParams(void *params) {
+    return umfDisjointPoolParamsDestroy(
+        static_cast<umf_disjoint_pool_params_handle_t>(params));
+}
+
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+void *createJemallocParams() {
+    umf_jemalloc_pool_params_handle_t jemalloc_params = NULL;
+    umf_result_t res = umfJemallocPoolParamsCreate(&jemalloc_params);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error("Failed to create Jemalloc Pool params");
+    }
+
+    // This test creates multiple pools, so we need to reduce the number of arenas
+    // to avoid hitting the maximum arena limit on systems with many cores.
+    res = umfJemallocPoolParamsSetNumArenas(jemalloc_params, 1);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfJemallocPoolParamsDestroy(jemalloc_params);
+        throw std::runtime_error("Failed to set number of arenas for Jemalloc "
+                                 "Pool params");
+    }
+    return jemalloc_params;
+}
+
+umf_result_t destroyJemallocParams(void *params) {
+    return umfJemallocPoolParamsDestroy(
+        (umf_jemalloc_pool_params_handle_t)params);
+}
+
 #endif
 
 static std::vector<ipcTestParams> ipcTestParamsList = {
-#if (defined UMF_POOL_DISJOINT_ENABLED)
-    {umfDisjointPoolOps(), disjointParams.get(), umfOsMemoryProviderOps(),
-     os_params.get(), &hostAccessor, false},
-#endif
+    {umfDisjointPoolOps(), createDisjointPoolParams, destroyDisjointPoolParams,
+     umfOsMemoryProviderOps(), createOsMemoryProviderParamsShared,
+     destroyOsMemoryProviderParamsShared, &hostAccessor},
 #ifdef UMF_POOL_JEMALLOC_ENABLED
-    {umfJemallocPoolOps(), nullptr, umfOsMemoryProviderOps(), os_params.get(),
-     &hostAccessor, false},
+    {umfJemallocPoolOps(), createJemallocParams, destroyJemallocParams,
+     umfOsMemoryProviderOps(), createOsMemoryProviderParamsShared,
+     destroyOsMemoryProviderParamsShared, &hostAccessor},
 #endif
 };
 
 INSTANTIATE_TEST_SUITE_P(osProviderTest, umfIpcTest,
-                         ::testing::ValuesIn(ipcTestParamsList));
+                         ::testing::ValuesIn(ipcTestParamsList),
+                         ipcTestParamsNameGen);
diff --git a/test/provider_os_memory_config.cpp b/test/provider_os_memory_config.cpp
index ed34566182..e5e2fdf973 100644
--- a/test/provider_os_memory_config.cpp
+++ b/test/provider_os_memory_config.cpp
@@ -1,20 +1,20 @@
 /*
  *
- * 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
  *
  */
 
+#include <numa.h>
+#include <numaif.h>
+
 #include "base.hpp"
 
 #include <umf/memory_provider.h>
 #include <umf/providers/provider_os_memory.h>
 
-#include <numa.h>
-#include <numaif.h>
-
 static constexpr size_t allocSize = 4096;
 
 struct providerConfigTest : testing::Test {
@@ -238,11 +238,17 @@ struct providerConfigTestNumaMode
     }
 };
 
-INSTANTIATE_TEST_SUITE_P(numa_modes, providerConfigTestNumaMode,
-                         testing::Values(UMF_NUMA_MODE_DEFAULT,
-                                         UMF_NUMA_MODE_BIND,
-                                         UMF_NUMA_MODE_INTERLEAVE,
-                                         UMF_NUMA_MODE_LOCAL));
+INSTANTIATE_TEST_SUITE_P(
+    numa_modes, providerConfigTestNumaMode,
+    testing::Values(UMF_NUMA_MODE_DEFAULT, UMF_NUMA_MODE_BIND,
+                    UMF_NUMA_MODE_INTERLEAVE, UMF_NUMA_MODE_LOCAL),
+    ([](auto const &info) -> std::string {
+        static const char *names[] = {
+            "UMF_NUMA_MODE_DEFAULT", "UMF_NUMA_MODE_BIND",
+            "UMF_NUMA_MODE_INTERLEAVE", "UMF_NUMA_MODE_LOCAL"};
+        return names[info.index];
+    }));
+
 #ifndef MPOL_LOCAL
 #define MPOL_LOCAL 4
 #endif
diff --git a/test/provider_os_memory_multiple_numa_nodes.cpp b/test/provider_os_memory_multiple_numa_nodes.cpp
index e493a427ca..69db6759f3 100644
--- a/test/provider_os_memory_multiple_numa_nodes.cpp
+++ b/test/provider_os_memory_multiple_numa_nodes.cpp
@@ -1,11 +1,7 @@
-// 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
 
-#include "base.hpp"
-#include "numa_helpers.hpp"
-#include "test_helpers.h"
-
 #include <algorithm>
 #include <numa.h>
 #include <numaif.h>
@@ -14,6 +10,10 @@
 
 #include <umf/providers/provider_os_memory.h>
 
+#include "base.hpp"
+#include "numa_helpers.hpp"
+#include "test_helpers.h"
+
 std::vector<unsigned> get_available_numa_nodes() {
     if (numa_available() == -1 || numa_all_nodes_ptr == nullptr) {
         return std::vector<unsigned>();
@@ -147,7 +147,10 @@ using the macro)
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(testNumaOnEachNode);
 
 INSTANTIATE_TEST_SUITE_P(testNumaNodesAllocations, testNumaOnEachNode,
-                         ::testing::ValuesIn(get_available_numa_nodes()));
+                         ::testing::ValuesIn(get_available_numa_nodes()),
+                         ([](auto const &info) -> std::string {
+                             return "numa_" + std::to_string(info.param);
+                         }));
 
 // Test for allocations on numa nodes. It will be executed on each of
 // the available numa nodes.
@@ -252,6 +255,7 @@ TEST_P(testNumaOnEachNode, checkModeInterleaveSingleNode) {
 
     constexpr int pages_num = 1024;
     size_t page_size = sysconf(_SC_PAGE_SIZE);
+    ASSERT_GT(page_size, 0);
     umf_result_t umf_result;
     umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
 
@@ -293,7 +297,10 @@ struct testNumaOnEachCpu : testNuma, testing::WithParamInterface<int> {
 };
 
 INSTANTIATE_TEST_SUITE_P(testNumaNodesAllocationsAllCpus, testNumaOnEachCpu,
-                         ::testing::ValuesIn(get_available_cpus()));
+                         ::testing::ValuesIn(get_available_cpus()),
+                         ([](auto const &info) -> std::string {
+                             return "cpu_" + std::to_string(info.param);
+                         }));
 
 // Test for allocation on numa node with mode preferred and an empty nodeset.
 // For the empty nodeset the memory is allocated on the node of the CPU that
@@ -421,6 +428,7 @@ TEST_F(testNuma, checkModeDefault) {
 TEST_F(testNuma, checkModeInterleave) {
     constexpr int pages_num = 1024;
     size_t page_size = sysconf(_SC_PAGE_SIZE);
+    ASSERT_GT(page_size, 0);
     umf_result_t umf_result;
     umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
 
@@ -674,17 +682,17 @@ TEST_P(testNumaSplit, checkModeSplit) {
     auto [required_numa_nodes, pages, in, out] = param;
     umf_result_t umf_result;
 
-    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
-
-    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-
     std::vector<unsigned> numa_nodes = get_available_numa_nodes();
 
     if (numa_nodes.size() < required_numa_nodes) {
         GTEST_SKIP_("Not enough numa nodes");
     }
 
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
     ASSERT_EQ(out.size(), pages)
         << "Wrong test input - out array size doesn't match page count";
 
diff --git a/test/provider_os_memory_not_impl.cpp b/test/provider_os_memory_not_impl.cpp
deleted file mode 100644
index 13c123fb7e..0000000000
--- a/test/provider_os_memory_not_impl.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright (C) 2024 Intel Corporation
-// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-#include "base.hpp"
-
-#include <umf/providers/provider_os_memory.h>
-
-using umf_test::test;
-
-TEST_F(test, os_provider_not_implemented) {
-    umf_os_memory_provider_params_handle_t params = nullptr;
-    umf_result_t umf_result = umfOsMemoryProviderParamsCreate(&params);
-    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
-    EXPECT_EQ(params, nullptr);
-
-    umf_result = umfOsMemoryProviderParamsDestroy(params);
-    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
-
-    umf_result = umfOsMemoryProviderParamsSetProtection(params, 0);
-    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
-
-    umf_result =
-        umfOsMemoryProviderParamsSetVisibility(params, UMF_MEM_MAP_PRIVATE);
-    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
-
-    umf_result = umfOsMemoryProviderParamsSetShmName(params, "shm_name");
-    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
-
-    umf_result = umfOsMemoryProviderParamsSetNumaList(params, nullptr, 0);
-    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
-
-    umf_result =
-        umfOsMemoryProviderParamsSetNumaMode(params, UMF_NUMA_MODE_DEFAULT);
-    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
-
-    umf_result = umfOsMemoryProviderParamsSetPartSize(params, 4096);
-    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
-
-    umf_numa_split_partition_t partitions[1];
-    umf_result = umfOsMemoryProviderParamsSetPartitions(params, partitions, 1);
-    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
-
-    umf_memory_provider_ops_t *ops = umfOsMemoryProviderOps();
-    EXPECT_EQ(ops, nullptr);
-}
diff --git a/test/provider_tracking.cpp b/test/provider_tracking.cpp
new file mode 100644
index 0000000000..52d5eeb8fd
--- /dev/null
+++ b/test/provider_tracking.cpp
@@ -0,0 +1,373 @@
+// 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/memory_provider.h>
+#include <umf/pools/pool_proxy.h>
+#include <umf/providers/provider_fixed_memory.h>
+
+#include "base.hpp"
+#include "provider.hpp"
+#include "test_helpers.h"
+#include "utils/cpp_helpers.hpp"
+#ifndef _WIN32
+#include "test_helpers_linux.h"
+#endif
+
+using umf_test::test;
+
+#define FIXED_BUFFER_SIZE (512 * utils_get_page_size())
+#define INVALID_PTR ((void *)0x01)
+
+struct TrackingProviderTest
+    : umf_test::test,
+      ::testing::WithParamInterface<providerCreateExtParams> {
+    void SetUp() override {
+        test::SetUp();
+
+        // Allocate a memory buffer to use with the fixed memory provider
+        memory_size = FIXED_BUFFER_SIZE;
+        memory_buffer = malloc(memory_size);
+        ASSERT_NE(memory_buffer, nullptr);
+
+        // Create provider parameters
+        umf_fixed_memory_provider_params_handle_t params = nullptr;
+        umf_result_t res = umfFixedMemoryProviderParamsCreate(
+            memory_buffer, memory_size, &params);
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+        ASSERT_NE(params, nullptr);
+
+        providerCreateExt(std::make_tuple(umfFixedMemoryProviderOps(), params),
+                          &provider);
+
+        umfFixedMemoryProviderParamsDestroy(params);
+        umf_result_t umf_result =
+            umfMemoryProviderGetMinPageSize(provider.get(), NULL, &page_size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+        page_plus_64 = page_size + 64;
+
+        umf_memory_pool_handle_t hPool = nullptr;
+        umf_result = umfPoolCreate(umfProxyPoolOps(), provider.get(), nullptr,
+                                   0, &hPool);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+        pool = umf_test::pool_unique_handle_t(hPool, &umfPoolDestroy);
+    }
+
+    void TearDown() override {
+        if (memory_buffer) {
+            free(memory_buffer);
+            memory_buffer = nullptr;
+        }
+        test::TearDown();
+    }
+
+    umf_test::provider_unique_handle_t provider;
+    umf_test::pool_unique_handle_t pool;
+    size_t page_size;
+    size_t page_plus_64;
+    void *memory_buffer = nullptr;
+    size_t memory_size = 0;
+};
+
+static void
+createPoolFromAllocation(void *ptr0, size_t size1,
+                         umf_memory_provider_handle_t *_providerFromPtr,
+                         umf_memory_pool_handle_t *_poolFromPtr) {
+    umf_result_t umf_result;
+
+    // Create provider parameters
+    umf_fixed_memory_provider_params_handle_t params = nullptr;
+    umf_result = umfFixedMemoryProviderParamsCreate(ptr0, size1, &params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(params, nullptr);
+
+    umf_memory_provider_handle_t provider1 = nullptr;
+    umf_result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
+                                         &provider1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider1, nullptr);
+
+    umf_memory_pool_handle_t pool1 = nullptr;
+    umf_result =
+        umfPoolCreate(umfProxyPoolOps(), provider1, nullptr, 0, &pool1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfFixedMemoryProviderParamsDestroy(params);
+
+    *_providerFromPtr = provider1;
+    *_poolFromPtr = pool1;
+}
+
+// TESTS
+
+INSTANTIATE_TEST_SUITE_P(trackingProviderTest, TrackingProviderTest,
+                         ::testing::Values(providerCreateExtParams{
+                             umfFixedMemoryProviderOps(), nullptr}),
+                         providerCreateExtParamsNameGen);
+
+TEST_P(TrackingProviderTest, create_destroy) {
+    // Creation and destruction are handled in SetUp and TearDown
+}
+
+TEST_P(TrackingProviderTest, whole_size_success) {
+    umf_result_t umf_result;
+    size_t size0;
+    size_t size1;
+    void *ptr0 = nullptr;
+    void *ptr1 = nullptr;
+
+    umf_memory_pool_handle_t pool0 = pool.get();
+
+    size0 = FIXED_BUFFER_SIZE - (2 * page_size);
+    ptr0 = umfPoolAlignedMalloc(pool0, size0, utils_get_page_size());
+    ASSERT_NE(ptr0, nullptr);
+
+    size1 = size0; // whole size
+
+    umf_memory_provider_handle_t provider1 = nullptr;
+    umf_memory_pool_handle_t pool1 = nullptr;
+    createPoolFromAllocation(ptr0, size1, &provider1, &pool1);
+
+    ptr1 = umfPoolMalloc(pool1, size1);
+    ASSERT_NE(ptr1, nullptr);
+
+    umf_result = umfPoolFree(pool1, ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolDestroy(pool1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(provider1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolFree(pool0, ptr0);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(TrackingProviderTest, half_size_success) {
+    umf_result_t umf_result;
+    size_t size0;
+    size_t size1;
+    void *ptr0 = nullptr;
+    void *ptr1 = nullptr;
+
+    umf_memory_pool_handle_t pool0 = pool.get();
+
+    size0 = FIXED_BUFFER_SIZE - (2 * page_size);
+    ptr0 = umfPoolAlignedMalloc(pool0, size0, utils_get_page_size());
+    ASSERT_NE(ptr0, nullptr);
+
+    size1 = size0 / 2; // half size
+
+    umf_memory_provider_handle_t provider1 = nullptr;
+    umf_memory_pool_handle_t pool1 = nullptr;
+    createPoolFromAllocation(ptr0, size1, &provider1, &pool1);
+
+    ptr1 = umfPoolMalloc(pool1, size1);
+    ASSERT_NE(ptr1, nullptr);
+
+    umf_result = umfPoolFree(pool1, ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolDestroy(pool1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(provider1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolFree(pool0, ptr0);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(TrackingProviderTest, failure_exceeding_size) {
+    umf_result_t umf_result;
+    size_t size0;
+    size_t size1;
+    void *ptr0 = nullptr;
+    void *ptr1 = nullptr;
+
+    umf_memory_pool_handle_t pool0 = pool.get();
+
+    size0 = FIXED_BUFFER_SIZE - (2 * page_size);
+    ptr0 = umfPoolAlignedMalloc(pool0, size0, utils_get_page_size());
+    ASSERT_NE(ptr0, nullptr);
+
+    size1 = FIXED_BUFFER_SIZE - page_size; // exceeding size
+
+    umf_memory_provider_handle_t provider1 = nullptr;
+    umf_memory_pool_handle_t pool1 = nullptr;
+    createPoolFromAllocation(ptr0, size1, &provider1, &pool1);
+
+    ptr1 = umfPoolMalloc(pool1, size1);
+    ASSERT_EQ(ptr1, nullptr);
+
+    umf_result = umfPoolDestroy(pool1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(provider1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolFree(pool0, ptr0);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+#define MAX_ARRAY 9
+#define TEST_LEVEL_SUCCESS 7
+#define TEST_LEVEL_FAILURE 8
+
+TEST_P(TrackingProviderTest, success_max_levels) {
+    umf_result_t umf_result;
+    size_t size;
+    void *ptr[MAX_ARRAY] = {0};
+    umf_memory_provider_handle_t providers[MAX_ARRAY] = {0};
+    umf_memory_pool_handle_t pools[MAX_ARRAY] = {0};
+
+    size = FIXED_BUFFER_SIZE - (2 * page_size);
+    pools[0] = pool.get();
+
+    for (int i = 0; i < TEST_LEVEL_SUCCESS; i++) {
+        fprintf(stderr, "Alloc #%d\n", i);
+        ptr[i] = umfPoolAlignedMalloc(pools[i], size, utils_get_page_size());
+        ASSERT_NE(ptr[i], nullptr);
+
+        createPoolFromAllocation(ptr[i], size, &providers[i + 1],
+                                 &pools[i + 1]);
+    }
+
+    int s = TEST_LEVEL_SUCCESS;
+    fprintf(stderr, "Alloc #%d\n", s);
+    ptr[s] = umfPoolAlignedMalloc(pools[s], size, utils_get_page_size());
+    ASSERT_NE(ptr[s], nullptr);
+
+    fprintf(stderr, "Free #%d\n", s);
+    umf_result = umfPoolFree(pools[s], ptr[s]);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    for (int i = TEST_LEVEL_SUCCESS - 1; i >= 0; i--) {
+        umf_result = umfPoolDestroy(pools[i + 1]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        umf_result = umfMemoryProviderDestroy(providers[i + 1]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+        fprintf(stderr, "Free #%d\n", i);
+        umf_result = umfPoolFree(pools[i], ptr[i]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+}
+
+TEST_P(TrackingProviderTest, failure_exceeding_levels) {
+    umf_result_t umf_result;
+    size_t size;
+    void *ptr[MAX_ARRAY] = {0};
+    umf_memory_provider_handle_t providers[MAX_ARRAY] = {0};
+    umf_memory_pool_handle_t pools[MAX_ARRAY] = {0};
+
+    size = FIXED_BUFFER_SIZE - (2 * page_size);
+    pools[0] = pool.get();
+
+    for (int i = 0; i < TEST_LEVEL_FAILURE; i++) {
+        fprintf(stderr, "Alloc #%d\n", i);
+        ptr[i] = umfPoolAlignedMalloc(pools[i], size, utils_get_page_size());
+        ASSERT_NE(ptr[i], nullptr);
+
+        createPoolFromAllocation(ptr[i], size, &providers[i + 1],
+                                 &pools[i + 1]);
+    }
+
+    // tracker level is too high
+    int f = TEST_LEVEL_FAILURE;
+    fprintf(stderr, "Alloc #%d\n", f);
+    ptr[f] = umfPoolAlignedMalloc(pools[f], size, utils_get_page_size());
+    ASSERT_EQ(ptr[f], nullptr);
+
+    for (int i = TEST_LEVEL_FAILURE - 1; i >= 0; i--) {
+        umf_result = umfPoolDestroy(pools[i + 1]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        umf_result = umfMemoryProviderDestroy(providers[i + 1]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+        fprintf(stderr, "Free #%d\n", i);
+        umf_result = umfPoolFree(pools[i], ptr[i]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+}
+
+TEST_P(TrackingProviderTest, reverted_free_half_size) {
+    umf_result_t umf_result;
+    size_t size0;
+    size_t size1;
+    void *ptr0 = nullptr;
+    void *ptr1 = nullptr;
+
+    umf_memory_pool_handle_t pool0 = pool.get();
+
+    size0 = FIXED_BUFFER_SIZE - (2 * page_size);
+    ptr0 = umfPoolAlignedMalloc(pool0, size0, utils_get_page_size());
+    ASSERT_NE(ptr0, nullptr);
+
+    umf_memory_provider_handle_t provider1 = nullptr;
+    umf_memory_pool_handle_t pool1 = nullptr;
+    createPoolFromAllocation(ptr0, size0, &provider1, &pool1);
+
+    size1 = size0 / 2; // half size
+
+    ptr1 = umfPoolMalloc(pool1, size1);
+    ASSERT_NE(ptr1, nullptr);
+
+    // Freeing the "busy" pointer from the first pool is an Undefined Behavior
+    // It fails now if the sizes are different.
+    // see: https://github.com/oneapi-src/unified-memory-framework/pull/1161
+    umf_result = umfPoolFree(pool0, ptr0);
+
+    umf_result = umfPoolFree(pool1, ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolDestroy(pool1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(provider1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // It could have been freed above,
+    // so we cannot verify the result here.
+    umf_result = umfPoolFree(pool0, ptr0);
+}
+
+TEST_P(TrackingProviderTest, reverted_free_the_same_size) {
+    umf_result_t umf_result;
+    size_t size0;
+    size_t size1;
+    void *ptr0 = nullptr;
+    void *ptr1 = nullptr;
+
+    umf_memory_pool_handle_t pool0 = pool.get();
+
+    size0 = FIXED_BUFFER_SIZE - (2 * page_size);
+    ptr0 = umfPoolAlignedMalloc(pool0, size0, utils_get_page_size());
+    ASSERT_NE(ptr0, nullptr);
+
+    umf_memory_provider_handle_t provider1 = nullptr;
+    umf_memory_pool_handle_t pool1 = nullptr;
+    createPoolFromAllocation(ptr0, size0, &provider1, &pool1);
+
+    size1 = size0; // the same size
+
+    ptr1 = umfPoolMalloc(pool1, size1);
+    ASSERT_NE(ptr1, nullptr);
+
+    // Freeing the "busy" pointer from the first pool is an Undefined Behavior
+    // It succeeds now if the sizes are equal.
+    // see: https://github.com/oneapi-src/unified-memory-framework/pull/1161
+    umf_result = umfPoolFree(pool0, ptr0);
+
+    // try to free the pointer from the second pool (the same size)
+    umf_result = umfPoolFree(pool1, ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolDestroy(pool1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(provider1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // It could have been freed above,
+    // so we cannot verify the result here.
+    umf_result = umfPoolFree(pool0, ptr0);
+}
diff --git a/test/provider_tracking_fixture_tests.cpp b/test/provider_tracking_fixture_tests.cpp
new file mode 100644
index 0000000000..60ff9a1761
--- /dev/null
+++ b/test/provider_tracking_fixture_tests.cpp
@@ -0,0 +1,103 @@
+// 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/memory_provider.h>
+#include <umf/pools/pool_proxy.h>
+#include <umf/providers/provider_file_memory.h>
+
+#include "base.hpp"
+#include "provider.hpp"
+
+#include "test_helpers.h"
+#include "utils/cpp_helpers.hpp"
+#ifndef _WIN32
+#include "test_helpers_linux.h"
+#endif
+
+#include "poolFixtures.hpp"
+
+#define FILE_PATH ((char *)"tmp_file")
+
+struct provider_from_pool : public umf_test::provider_base_t {
+    umf_memory_pool_handle_t pool;
+
+    provider_from_pool() : pool(nullptr) {}
+
+    umf_result_t initialize(const umf_memory_pool_t *_pool) noexcept {
+        if (!_pool) {
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+        // drop const qualifier
+        pool = (umf_memory_pool_handle_t)_pool;
+        return UMF_RESULT_SUCCESS;
+    }
+
+    umf_result_t alloc(size_t size, size_t align, void **ptr) noexcept {
+        *ptr = umfPoolAlignedMalloc(pool, size, align);
+        return (*ptr) ? UMF_RESULT_SUCCESS
+                      : UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    umf_result_t free(void *ptr, size_t) noexcept {
+        return umfPoolFree(pool, ptr);
+    }
+
+    umf_result_t get_name(const char **name) noexcept {
+        *name = "provider_from_pool";
+        return UMF_RESULT_SUCCESS;
+    }
+
+    virtual ~provider_from_pool() {
+        if (pool) {
+            umfPoolDestroy(pool);
+            pool = nullptr;
+        }
+    }
+};
+
+umf_memory_provider_ops_t PROVIDER_FROM_POOL_OPS =
+    umf_test::providerMakeCOps<provider_from_pool, umf_memory_pool_t>();
+
+static void *providerFromPoolParamsCreate(void) {
+    umf_file_memory_provider_params_handle_t paramsFile = NULL;
+    umf_result_t umf_result =
+        umfFileMemoryProviderParamsCreate(FILE_PATH, &paramsFile);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    EXPECT_NE(paramsFile, nullptr);
+
+    umf_memory_provider_handle_t providerFile = nullptr;
+    umf_result = umfMemoryProviderCreate(umfFileMemoryProviderOps(), paramsFile,
+                                         &providerFile);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    EXPECT_NE(providerFile, nullptr);
+
+    umf_memory_pool_handle_t poolProxyFile = nullptr;
+    umf_result =
+        umfPoolCreate(umfProxyPoolOps(), providerFile, nullptr,
+                      UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &poolProxyFile);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    EXPECT_NE(poolProxyFile, nullptr);
+
+    umf_result = umfFileMemoryProviderParamsDestroy(paramsFile);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    paramsFile = nullptr;
+
+    return poolProxyFile;
+}
+
+// TESTS
+
+INSTANTIATE_TEST_SUITE_P(TrackingProviderPoolTest, umfPoolTest,
+                         ::testing::Values(poolCreateExtParams{
+                             umfProxyPoolOps(), nullptr, nullptr,
+                             &PROVIDER_FROM_POOL_OPS,
+                             providerFromPoolParamsCreate, nullptr}),
+                         poolCreateExtParamsNameGen);
+
+INSTANTIATE_TEST_SUITE_P(TrackingProviderMultiPoolTest, umfMultiPoolTest,
+                         ::testing::Values(poolCreateExtParams{
+                             umfProxyPoolOps(), nullptr, nullptr,
+                             &PROVIDER_FROM_POOL_OPS,
+                             providerFromPoolParamsCreate, nullptr}),
+                         poolCreateExtParamsNameGen);
diff --git a/test/providers/cuda_helpers.cpp b/test/providers/cuda_helpers.cpp
index 9c41d9382f..4678ea4acd 100644
--- a/test/providers/cuda_helpers.cpp
+++ b/test/providers/cuda_helpers.cpp
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -22,7 +22,7 @@ struct libcu_ops {
     CUresult (*cuDeviceGet)(CUdevice *device, int ordinal);
     CUresult (*cuMemAlloc)(CUdeviceptr *dptr, size_t size);
     CUresult (*cuMemFree)(CUdeviceptr dptr);
-    CUresult (*cuMemAllocHost)(void **pp, size_t size);
+    CUresult (*cuMemHostAlloc)(void **pp, size_t size, unsigned int flags);
     CUresult (*cuMemAllocManaged)(CUdeviceptr *dptr, size_t bytesize,
                                   unsigned int flags);
     CUresult (*cuMemFreeHost)(void *p);
@@ -34,6 +34,7 @@ struct libcu_ops {
     CUresult (*cuPointerGetAttributes)(unsigned int numAttributes,
                                        CUpointer_attribute *attributes,
                                        void **data, CUdeviceptr ptr);
+    CUresult (*cuMemHostGetFlags)(unsigned int *pFlags, void *p);
     CUresult (*cuStreamSynchronize)(CUstream hStream);
     CUresult (*cuCtxSynchronize)(void);
 } libcu_ops;
@@ -69,7 +70,7 @@ struct DlHandleCloser {
             libcu_ops.cuMemFree = [](auto... args) {
                 return noop_stub(args...);
             };
-            libcu_ops.cuMemAllocHost = [](auto... args) {
+            libcu_ops.cuMemHostAlloc = [](auto... args) {
                 return noop_stub(args...);
             };
             libcu_ops.cuMemAllocManaged = [](auto... args) {
@@ -90,6 +91,9 @@ struct DlHandleCloser {
             libcu_ops.cuPointerGetAttributes = [](auto... args) {
                 return noop_stub(args...);
             };
+            libcu_ops.cuMemHostGetFlags = [](auto... args) {
+                return noop_stub(args...);
+            };
             libcu_ops.cuStreamSynchronize = [](auto... args) {
                 return noop_stub(args...);
             };
@@ -106,13 +110,18 @@ int InitCUDAOps() {
 #ifdef _WIN32
     const char *lib_name = "nvcuda.dll";
 #else
-    const char *lib_name = "libcuda.so";
+    const char *lib_name = "libcuda.so.1";
 #endif
     // CUDA symbols
-    // NOTE that we use UMF_UTIL_OPEN_LIBRARY_GLOBAL which add all loaded
-    // symbols to the global symbol table.
+#if OPEN_CU_LIBRARY_GLOBAL
+    // NOTE UMF_UTIL_OPEN_LIBRARY_GLOBAL adds all loaded symbols to the
+    // global symbol table.
+    int open_flags = UMF_UTIL_OPEN_LIBRARY_GLOBAL;
+#else
+    int open_flags = 0;
+#endif
     cuDlHandle = std::unique_ptr<void, DlHandleCloser>(
-        utils_open_library(lib_name, UMF_UTIL_OPEN_LIBRARY_GLOBAL));
+        utils_open_library(lib_name, open_flags));
 
     // NOTE: some symbols defined in the lib have _vX postfixes - this is
     // important to load the proper version of functions
@@ -164,10 +173,10 @@ int InitCUDAOps() {
         fprintf(stderr, "cuMemFree_v2 symbol not found in %s\n", lib_name);
         return -1;
     }
-    *(void **)&libcu_ops.cuMemAllocHost =
-        utils_get_symbol_addr(cuDlHandle.get(), "cuMemAllocHost_v2", lib_name);
-    if (libcu_ops.cuMemAllocHost == nullptr) {
-        fprintf(stderr, "cuMemAllocHost_v2 symbol not found in %s\n", lib_name);
+    *(void **)&libcu_ops.cuMemHostAlloc =
+        utils_get_symbol_addr(cuDlHandle.get(), "cuMemHostAlloc", lib_name);
+    if (libcu_ops.cuMemHostAlloc == nullptr) {
+        fprintf(stderr, "cuMemHostAlloc symbol not found in %s\n", lib_name);
         return -1;
     }
     *(void **)&libcu_ops.cuMemAllocManaged =
@@ -208,6 +217,12 @@ int InitCUDAOps() {
                 lib_name);
         return -1;
     }
+    *(void **)&libcu_ops.cuMemHostGetFlags =
+        utils_get_symbol_addr(cuDlHandle.get(), "cuMemHostGetFlags", lib_name);
+    if (libcu_ops.cuMemHostGetFlags == nullptr) {
+        fprintf(stderr, "cuMemHostGetFlags symbol not found in %s\n", lib_name);
+        return -1;
+    }
     *(void **)&libcu_ops.cuStreamSynchronize = utils_get_symbol_addr(
         cuDlHandle.get(), "cuStreamSynchronize", lib_name);
     if (libcu_ops.cuStreamSynchronize == nullptr) {
@@ -236,7 +251,7 @@ int InitCUDAOps() {
     libcu_ops.cuCtxSetCurrent = cuCtxSetCurrent;
     libcu_ops.cuDeviceGet = cuDeviceGet;
     libcu_ops.cuMemAlloc = cuMemAlloc;
-    libcu_ops.cuMemAllocHost = cuMemAllocHost;
+    libcu_ops.cuMemHostAlloc = cuMemHostAlloc;
     libcu_ops.cuMemAllocManaged = cuMemAllocManaged;
     libcu_ops.cuMemFree = cuMemFree;
     libcu_ops.cuMemFreeHost = cuMemFreeHost;
@@ -244,6 +259,7 @@ int InitCUDAOps() {
     libcu_ops.cuMemcpy = cuMemcpy;
     libcu_ops.cuPointerGetAttribute = cuPointerGetAttribute;
     libcu_ops.cuPointerGetAttributes = cuPointerGetAttributes;
+    libcu_ops.cuMemHostGetFlags = cuMemHostGetFlags;
     libcu_ops.cuStreamSynchronize = cuStreamSynchronize;
     libcu_ops.cuCtxSynchronize = cuCtxSynchronize;
 
@@ -251,7 +267,7 @@ int InitCUDAOps() {
 }
 #endif // USE_DLOPEN
 
-static CUresult set_context(CUcontext required_ctx, CUcontext *restore_ctx) {
+CUresult set_context(CUcontext required_ctx, CUcontext *restore_ctx) {
     CUcontext current_ctx = NULL;
     CUresult cu_result = libcu_ops.cuCtxGetCurrent(&current_ctx);
     if (cu_result != CUDA_SUCCESS) {
@@ -259,7 +275,10 @@ static CUresult set_context(CUcontext required_ctx, CUcontext *restore_ctx) {
         return cu_result;
     }
 
-    *restore_ctx = current_ctx;
+    if (restore_ctx != NULL) {
+        *restore_ctx = current_ctx;
+    }
+
     if (current_ctx != required_ctx) {
         cu_result = libcu_ops.cuCtxSetCurrent(required_ctx);
         if (cu_result != CUDA_SUCCESS) {
@@ -370,6 +389,17 @@ umf_usm_memory_type_t get_mem_type(CUcontext context, void *ptr) {
     return UMF_MEMORY_TYPE_UNKNOWN;
 }
 
+unsigned int get_mem_host_alloc_flags(void *ptr) {
+    unsigned int flags;
+    CUresult res = libcu_ops.cuMemHostGetFlags(&flags, ptr);
+    if (res != CUDA_SUCCESS) {
+        fprintf(stderr, "cuPointerGetAttribute() failed!\n");
+        return 0;
+    }
+
+    return flags;
+}
+
 CUcontext get_mem_context(void *ptr) {
     CUcontext context;
     CUresult res = libcu_ops.cuPointerGetAttribute(
@@ -382,6 +412,18 @@ CUcontext get_mem_context(void *ptr) {
     return context;
 }
 
+int get_mem_device(void *ptr) {
+    int device;
+    CUresult res = libcu_ops.cuPointerGetAttribute(
+        &device, CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL, (CUdeviceptr)ptr);
+    if (res != CUDA_SUCCESS) {
+        fprintf(stderr, "cuPointerGetAttribute() failed!\n");
+        return -1;
+    }
+
+    return device;
+}
+
 CUcontext get_current_context() {
     CUcontext context;
     CUresult res = libcu_ops.cuCtxGetCurrent(&context);
@@ -403,7 +445,7 @@ void init_cuda_once() {
     InitResult = init_cuda_lib();
 }
 
-int init_cuda() {
+int init_cuda(void) {
     utils_init_once(&cuda_init_flag, init_cuda_once);
 
     return InitResult;
@@ -412,12 +454,6 @@ int init_cuda() {
 int get_cuda_device(CUdevice *device) {
     CUdevice cuDevice = -1;
 
-    int ret = init_cuda();
-    if (ret != 0) {
-        fprintf(stderr, "init_cuda() failed!\n");
-        return ret;
-    }
-
     CUresult res = libcu_ops.cuDeviceGet(&cuDevice, 0);
     if (res != CUDA_SUCCESS || cuDevice < 0) {
         return -1;
@@ -430,12 +466,6 @@ int get_cuda_device(CUdevice *device) {
 int create_context(CUdevice device, CUcontext *context) {
     CUcontext cuContext = nullptr;
 
-    int ret = init_cuda();
-    if (ret != 0) {
-        fprintf(stderr, "init_cuda() failed!\n");
-        return ret;
-    }
-
     CUresult res = libcu_ops.cuCtxCreate(&cuContext, 0, device);
     if (res != CUDA_SUCCESS || cuContext == nullptr) {
         return -1;
diff --git a/test/providers/cuda_helpers.h b/test/providers/cuda_helpers.h
index fc06c1fcff..944e6dbef8 100644
--- a/test/providers/cuda_helpers.h
+++ b/test/providers/cuda_helpers.h
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -26,10 +26,14 @@
 extern "C" {
 #endif
 
+int init_cuda(void);
+
 int get_cuda_device(CUdevice *device);
 
 int create_context(CUdevice device, CUcontext *context);
 
+CUresult set_context(CUcontext required_ctx, CUcontext *restore_ctx);
+
 int destroy_context(CUcontext context);
 
 int cuda_fill(CUcontext context, CUdevice device, void *ptr, size_t size,
@@ -40,8 +44,12 @@ int cuda_copy(CUcontext context, CUdevice device, void *dst_ptr,
 
 umf_usm_memory_type_t get_mem_type(CUcontext context, void *ptr);
 
+unsigned int get_mem_host_alloc_flags(void *ptr);
+
 CUcontext get_mem_context(void *ptr);
 
+int get_mem_device(void *ptr);
+
 CUcontext get_current_context();
 
 #ifdef __cplusplus
diff --git a/test/providers/ipc_cuda_prov.py b/test/providers/ipc_cuda_prov.py
new file mode 100755
index 0000000000..9200278cd8
--- /dev/null
+++ b/test/providers/ipc_cuda_prov.py
@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+#
+# 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
+#
+
+import os
+import sys
+import time
+import subprocess  # nosec B404
+import platform
+
+
+def main():
+    # Port should be a number from the range <1024, 65535>
+    # Use PROCESS_ID environment variable if set, otherwise use current PID
+    pid = int(os.environ.get("PROCESS_ID", os.getpid()))
+    port = 1024 + (pid % (65535 - 1024))
+
+    # Set UMF_LOG environment variable
+    os.environ["UMF_LOG"] = "level:debug;flush:debug;output:stderr;pid:yes"
+
+    build_type = os.environ.get("BUILD_TYPE", "Debug")
+
+    # Determine executable extension based on platform
+    exe_ext = ".exe" if platform.system() == "Windows" else ""
+
+    print(f"Starting test_ipc_cuda_prov CONSUMER on port {port} ...")
+
+    # Start consumer process
+    consumer_cmd = [f"./{build_type}/test_ipc_cuda_prov_consumer{exe_ext}", str(port)]
+    with open("consumer_log.txt", "w") as consumer_log:
+        consumer_proc = subprocess.Popen(  # nosec
+            consumer_cmd, stdout=consumer_log, stderr=subprocess.STDOUT
+        )
+
+    print("Waiting 5 sec ...")
+    time.sleep(5)
+
+    print(f"Starting test_ipc_cuda_prov PRODUCER on port {port} ...")
+
+    # Start producer process
+    producer_cmd = [f"./{build_type}/test_ipc_cuda_prov_producer{exe_ext}", str(port)]
+    with open("producer_log.txt", "w") as producer_log:
+        producer_proc = subprocess.Popen(  # nosec
+            producer_cmd, stdout=producer_log, stderr=subprocess.STDOUT
+        )
+
+    print("Waiting 10 sec for the consumer and producer to finish ...")
+    time.sleep(10)
+
+    # Wait for processes to complete
+    consumer_proc.wait()
+    producer_proc.wait()
+
+    print("Test finished")
+
+    # Display consumer log
+    print("Consumer log:")
+    try:
+        with open("consumer_log.txt", "r") as f:
+            print(f.read())
+    except FileNotFoundError:
+        print("consumer_log.txt not found")
+
+    # Display producer log
+    print("Producer log:")
+    try:
+        with open("producer_log.txt", "r") as f:
+            print(f.read())
+    except FileNotFoundError:
+        print("producer_log.txt not found")
+
+    # Check for errors in logs
+    error_found = False
+    for log_file in ["consumer_log.txt", "producer_log.txt"]:
+        try:
+            with open(log_file, "r") as f:
+                content = f.read().upper()
+                if "ERROR" in content or "FATAL" in content:
+                    error_found = True
+                    break
+        except FileNotFoundError:
+            continue
+
+    if error_found:
+        print("Test failed: ERROR or FATAL found in logs.")
+        sys.exit(1)
+
+    print("Test passed: No errors found in logs.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/test/providers/ipc_cuda_prov.sh b/test/providers/ipc_cuda_prov.sh
index 1e9b6b05d4..bb4be94747 100755
--- a/test/providers/ipc_cuda_prov.sh
+++ b/test/providers/ipc_cuda_prov.sh
@@ -1,5 +1,5 @@
 #
-# 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,10 +15,10 @@ PORT=$(( 1024 + ( $$ % ( 65535 - 1024 ))))
 UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
 
 echo "Starting ipc_cuda_prov CONSUMER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_cuda_prov_consumer $PORT &
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_cuda_prov_consumer $PORT &
 
 echo "Waiting 1 sec ..."
 sleep 1
 
 echo "Starting ipc_cuda_prov PRODUCER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_cuda_prov_producer $PORT
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_cuda_prov_producer $PORT
diff --git a/test/providers/ipc_cuda_prov_consumer.c b/test/providers/ipc_cuda_prov_consumer.c
index 1aeb5b15cb..3d4a707072 100644
--- a/test/providers/ipc_cuda_prov_consumer.c
+++ b/test/providers/ipc_cuda_prov_consumer.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -25,7 +25,13 @@ int main(int argc, char *argv[]) {
     CUdevice hDevice = -1;
     CUcontext hContext = NULL;
 
-    int ret = get_cuda_device(&hDevice);
+    int ret = init_cuda();
+    if (ret != 0) {
+        fprintf(stderr, "init_cuda() failed!\n");
+        return -1;
+    }
+
+    ret = get_cuda_device(&hDevice);
     if (ret != 0) {
         fprintf(stderr, "get_cuda_device() failed!\n");
         return -1;
diff --git a/test/providers/ipc_cuda_prov_producer.c b/test/providers/ipc_cuda_prov_producer.c
index c2cd1d1325..a7421da06c 100644
--- a/test/providers/ipc_cuda_prov_producer.c
+++ b/test/providers/ipc_cuda_prov_producer.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -25,7 +25,13 @@ int main(int argc, char *argv[]) {
     CUdevice hDevice = -1;
     CUcontext hContext = NULL;
 
-    int ret = get_cuda_device(&hDevice);
+    int ret = init_cuda();
+    if (ret != 0) {
+        fprintf(stderr, "init_cuda() failed!\n");
+        return -1;
+    }
+
+    ret = get_cuda_device(&hDevice);
     if (ret != 0) {
         fprintf(stderr, "get_cuda_device() failed!\n");
         return -1;
diff --git a/test/providers/ipc_level_zero_prov.py b/test/providers/ipc_level_zero_prov.py
new file mode 100755
index 0000000000..b08bf5bdf8
--- /dev/null
+++ b/test/providers/ipc_level_zero_prov.py
@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+#
+# 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
+#
+
+import os
+import sys
+import time
+import subprocess  # nosec B404
+import platform
+
+
+def main():
+    # Port should be a number from the range <1024, 65535>
+    # Use PROCESS_ID environment variable if set, otherwise use current PID
+    pid = int(os.environ.get("PROCESS_ID", os.getpid()))
+    port = 1024 + (pid % (65535 - 1024))
+
+    # Set UMF_LOG environment variable
+    os.environ["UMF_LOG"] = "level:debug;flush:debug;output:stderr;pid:yes"
+
+    build_type = os.environ.get("BUILD_TYPE", "Debug")
+
+    # Determine executable extension based on platform
+    exe_ext = ".exe" if platform.system() == "Windows" else ""
+
+    print(f"Starting test_ipc_level_zero_prov CONSUMER on port {port} ...")
+
+    # Start consumer process
+    consumer_cmd = [
+        f"./{build_type}/test_ipc_level_zero_prov_consumer{exe_ext}",
+        str(port),
+    ]
+    with open("consumer_log.txt", "w") as consumer_log:
+        consumer_proc = subprocess.Popen(  # nosec
+            consumer_cmd, stdout=consumer_log, stderr=subprocess.STDOUT
+        )
+
+    print("Waiting 5 sec ...")
+    time.sleep(5)
+
+    print(f"Starting test_ipc_level_zero_prov PRODUCER on port {port} ...")
+
+    # Start producer process
+    producer_cmd = [
+        f"./{build_type}/test_ipc_level_zero_prov_producer{exe_ext}",
+        str(port),
+    ]
+    with open("producer_log.txt", "w") as producer_log:
+        producer_proc = subprocess.Popen(  # nosec
+            producer_cmd, stdout=producer_log, stderr=subprocess.STDOUT
+        )
+
+    print("Waiting 10 sec for the consumer and producer to finish ...")
+    time.sleep(10)
+
+    # Wait for processes to complete
+    consumer_proc.wait()
+    producer_proc.wait()
+
+    print("Test finished")
+
+    # Display consumer log
+    print("Consumer log:")
+    try:
+        with open("consumer_log.txt", "r") as f:
+            print(f.read())
+    except FileNotFoundError:
+        print("consumer_log.txt not found")
+
+    # Display producer log
+    print("Producer log:")
+    try:
+        with open("producer_log.txt", "r") as f:
+            print(f.read())
+    except FileNotFoundError:
+        print("producer_log.txt not found")
+
+    # Check for errors in logs
+    error_found = False
+    for log_file in ["consumer_log.txt", "producer_log.txt"]:
+        try:
+            with open(log_file, "r") as f:
+                content = f.read().upper()
+                if "ERROR" in content or "FATAL" in content:
+                    error_found = True
+                    break
+        except FileNotFoundError:
+            continue
+
+    if error_found:
+        print("Test failed: ERROR or FATAL found in logs.")
+        sys.exit(1)
+
+    print("Test passed: No errors found in logs.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/test/providers/ipc_level_zero_prov.sh b/test/providers/ipc_level_zero_prov.sh
index d6bcef4f3a..cebd909328 100755
--- a/test/providers/ipc_level_zero_prov.sh
+++ b/test/providers/ipc_level_zero_prov.sh
@@ -1,5 +1,5 @@
 #
-# 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
@@ -12,28 +12,13 @@ set -e
 # port should be a number from the range <1024, 65535>
 PORT=$(( 1024 + ( $$ % ( 65535 - 1024 ))))
 
-# The ipc_level_zero_prov test requires using pidfd_getfd(2)
-# to obtain a duplicate of another process's file descriptor.
-# Permission to duplicate another process's file descriptor
-# is governed by a ptrace access mode PTRACE_MODE_ATTACH_REALCREDS check (see ptrace(2))
-# that can be changed using the /proc/sys/kernel/yama/ptrace_scope interface.
-PTRACE_SCOPE_FILE="/proc/sys/kernel/yama/ptrace_scope"
-VAL=0
-if [ -f $PTRACE_SCOPE_FILE ]; then
-	PTRACE_SCOPE_VAL=$(cat $PTRACE_SCOPE_FILE)
-	if [ $PTRACE_SCOPE_VAL -ne $VAL ]; then
-		echo "SKIP: ptrace_scope is not set to 0 (classic ptrace permissions) - skipping the test"
-		exit 125 # skip code defined in CMakeLists.txt
-	fi
-fi
-
 UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
 
 echo "Starting ipc_level_zero_prov CONSUMER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_level_zero_prov_consumer $PORT &
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_level_zero_prov_consumer $PORT &
 
 echo "Waiting 1 sec ..."
 sleep 1
 
 echo "Starting ipc_level_zero_prov PRODUCER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_level_zero_prov_producer $PORT
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_level_zero_prov_producer $PORT
diff --git a/test/providers/ipc_level_zero_prov_consumer.c b/test/providers/ipc_level_zero_prov_consumer.c
index 8ec0648e4f..abe08e7c82 100644
--- a/test/providers/ipc_level_zero_prov_consumer.c
+++ b/test/providers/ipc_level_zero_prov_consumer.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -8,6 +8,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <umf/experimental/ctl.h>
 #include <umf/pools/pool_disjoint.h>
 #include <umf/providers/provider_level_zero.h>
 
@@ -27,7 +28,13 @@ int main(int argc, char *argv[]) {
     ze_device_handle_t hDevice = NULL;
     ze_context_handle_t hContext = NULL;
 
-    int ret = utils_ze_find_driver_with_gpu(&driver_idx, &hDriver);
+    int ret = utils_ze_init_level_zero();
+    if (ret != 0) {
+        fprintf(stderr, "utils_ze_init_level_zero() failed!\n");
+        return -1;
+    }
+
+    ret = utils_ze_find_driver_with_gpu(&driver_idx, &hDriver);
     if (ret != 0 || hDriver == NULL) {
         fprintf(stderr, "utils_ze_find_driver_with_gpu() failed!\n");
         return -1;
@@ -82,6 +89,15 @@ int main(int argc, char *argv[]) {
         goto destroy_provider_params;
     }
 
+#ifdef _WIN32
+    // NOTE: On Windows, we must use the import / export memory exchange policy
+    // because IPC currently does not work
+    int use_import_export_for_IPC = 1;
+    umfCtlSet(
+        "umf.provider.default.LEVEL_ZERO.params.use_import_export_for_IPC",
+        &use_import_export_for_IPC, sizeof(use_import_export_for_IPC));
+#endif
+
     umf_disjoint_pool_params_handle_t pool_params = NULL;
 
     umf_result = umfDisjointPoolParamsCreate(&pool_params);
diff --git a/test/providers/ipc_level_zero_prov_producer.c b/test/providers/ipc_level_zero_prov_producer.c
index 2a8fedc374..535020eaeb 100644
--- a/test/providers/ipc_level_zero_prov_producer.c
+++ b/test/providers/ipc_level_zero_prov_producer.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -8,6 +8,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <umf/experimental/ctl.h>
 #include <umf/pools/pool_disjoint.h>
 #include <umf/providers/provider_level_zero.h>
 
@@ -27,7 +28,13 @@ int main(int argc, char *argv[]) {
     ze_device_handle_t hDevice = NULL;
     ze_context_handle_t hContext = NULL;
 
-    int ret = utils_ze_find_driver_with_gpu(&driver_idx, &hDriver);
+    int ret = utils_ze_init_level_zero();
+    if (ret != 0) {
+        fprintf(stderr, "utils_ze_init_level_zero() failed!\n");
+        return -1;
+    }
+
+    ret = utils_ze_find_driver_with_gpu(&driver_idx, &hDriver);
     if (ret != 0 || hDriver == NULL) {
         fprintf(stderr, "utils_ze_find_driver_with_gpu() failed!\n");
         return -1;
@@ -82,6 +89,15 @@ int main(int argc, char *argv[]) {
         goto destroy_provider_params;
     }
 
+#ifdef _WIN32
+    // NOTE: On Windows, we must use the import/export memory exchange policy
+    // because IPC currently does not work
+    int use_import_export_for_IPC = 1;
+    umfCtlSet(
+        "umf.provider.default.LEVEL_ZERO.params.use_import_export_for_IPC",
+        &use_import_export_for_IPC, sizeof(use_import_export_for_IPC));
+#endif
+
     umf_disjoint_pool_params_handle_t pool_params = NULL;
 
     umf_result = umfDisjointPoolParamsCreate(&pool_params);
diff --git a/test/providers/provider_cuda.cpp b/test/providers/provider_cuda.cpp
index 4f1d359113..8a3d729eb0 100644
--- a/test/providers/provider_cuda.cpp
+++ b/test/providers/provider_cuda.cpp
@@ -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
 
@@ -9,6 +9,8 @@
 
 #include <mutex>
 
+#include <umf/experimental/ctl.h>
+#include <umf/experimental/memory_properties.h>
 #include <umf/providers/provider_cuda.h>
 
 #include "cuda_helpers.h"
@@ -39,7 +41,13 @@ class CUDATestHelper {
 };
 
 CUDATestHelper::CUDATestHelper() {
-    int ret = get_cuda_device(&hDevice_);
+    int ret = init_cuda();
+    if (ret != 0) {
+        fprintf(stderr, "init_cuda() failed!\n");
+        return;
+    }
+
+    ret = get_cuda_device(&hDevice_);
     if (ret != 0) {
         fprintf(stderr, "get_cuda_device() failed!\n");
         return;
@@ -52,47 +60,46 @@ CUDATestHelper::CUDATestHelper() {
     }
 }
 
-using cuda_params_unique_handle_t =
-    std::unique_ptr<umf_cuda_memory_provider_params_t,
-                    decltype(&umfCUDAMemoryProviderParamsDestroy)>;
-
-cuda_params_unique_handle_t
+umf_cuda_memory_provider_params_handle_t
 create_cuda_prov_params(CUcontext context, CUdevice device,
-                        umf_usm_memory_type_t memory_type) {
+                        umf_usm_memory_type_t memory_type, unsigned int flags) {
     umf_cuda_memory_provider_params_handle_t params = nullptr;
 
     umf_result_t res = umfCUDAMemoryProviderParamsCreate(&params);
     if (res != UMF_RESULT_SUCCESS) {
-        return cuda_params_unique_handle_t(nullptr,
-                                           &umfCUDAMemoryProviderParamsDestroy);
+        return nullptr;
     }
 
     res = umfCUDAMemoryProviderParamsSetContext(params, context);
     if (res != UMF_RESULT_SUCCESS) {
         umfCUDAMemoryProviderParamsDestroy(params);
-        return cuda_params_unique_handle_t(nullptr,
-                                           &umfCUDAMemoryProviderParamsDestroy);
-        ;
+        return nullptr;
     }
 
     res = umfCUDAMemoryProviderParamsSetDevice(params, device);
     if (res != UMF_RESULT_SUCCESS) {
         umfCUDAMemoryProviderParamsDestroy(params);
-        return cuda_params_unique_handle_t(nullptr,
-                                           &umfCUDAMemoryProviderParamsDestroy);
-        ;
+        return nullptr;
     }
 
     res = umfCUDAMemoryProviderParamsSetMemoryType(params, memory_type);
     if (res != UMF_RESULT_SUCCESS) {
         umfCUDAMemoryProviderParamsDestroy(params);
-        return cuda_params_unique_handle_t(nullptr,
-                                           &umfCUDAMemoryProviderParamsDestroy);
-        ;
+        return nullptr;
     }
 
-    return cuda_params_unique_handle_t(params,
-                                       &umfCUDAMemoryProviderParamsDestroy);
+    res = umfCUDAMemoryProviderParamsSetAllocFlags(params, flags);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfCUDAMemoryProviderParamsDestroy(params);
+        return nullptr;
+    }
+
+    return params;
+}
+
+umf_result_t destroyCuParams(void *params) {
+    return umfCUDAMemoryProviderParamsDestroy(
+        (umf_cuda_memory_provider_params_handle_t)params);
 }
 
 class CUDAMemoryAccessor : public MemoryAccessor {
@@ -101,7 +108,7 @@ class CUDAMemoryAccessor : public MemoryAccessor {
         : hDevice_(hDevice), hContext_(hContext) {}
 
     void fill(void *ptr, size_t size, const void *pattern,
-              size_t pattern_size) {
+              size_t pattern_size) override {
         ASSERT_NE(hContext_, nullptr);
         ASSERT_GE(hDevice_, -1);
         ASSERT_NE(ptr, nullptr);
@@ -111,7 +118,7 @@ class CUDAMemoryAccessor : public MemoryAccessor {
         ASSERT_EQ(ret, 0);
     }
 
-    void copy(void *dst_ptr, void *src_ptr, size_t size) {
+    void copy(void *dst_ptr, void *src_ptr, size_t size) override {
         ASSERT_NE(hContext_, nullptr);
         ASSERT_GE(hDevice_, -1);
         ASSERT_NE(dst_ptr, nullptr);
@@ -121,35 +128,62 @@ class CUDAMemoryAccessor : public MemoryAccessor {
         ASSERT_EQ(ret, 0);
     }
 
+    const char *getName() override { return "CUDAMemoryAccessor"; }
+
   private:
     CUdevice hDevice_;
     CUcontext hContext_;
 };
 
-using CUDAProviderTestParams =
-    std::tuple<umf_cuda_memory_provider_params_handle_t, CUcontext,
-               umf_usm_memory_type_t, MemoryAccessor *>;
-
 struct umfCUDAProviderTest
     : umf_test::test,
-      ::testing::WithParamInterface<CUDAProviderTestParams> {
+      ::testing::WithParamInterface<umf_usm_memory_type_t> {
 
     void SetUp() override {
         test::SetUp();
 
-        auto [cuda_params, cu_context, memory_type, accessor] =
-            this->GetParam();
-        params = cuda_params;
-        memAccessor = accessor;
-        expected_context = cu_context;
+        umf_usm_memory_type_t memory_type = this->GetParam();
+
+        memAccessor = nullptr;
+        expected_context = cudaTestHelper.get_test_context();
+        expected_device = cudaTestHelper.get_test_device();
+        params = create_cuda_prov_params(cudaTestHelper.get_test_context(),
+                                         cudaTestHelper.get_test_device(),
+                                         memory_type, 0 /* alloc flags */);
+        ASSERT_NE(expected_context, nullptr);
+        ASSERT_GE(expected_device, 0);
+
+        switch (memory_type) {
+        case UMF_MEMORY_TYPE_DEVICE:
+            memAccessor = std::make_unique<CUDAMemoryAccessor>(
+                cudaTestHelper.get_test_context(),
+                cudaTestHelper.get_test_device());
+            break;
+        case UMF_MEMORY_TYPE_SHARED:
+        case UMF_MEMORY_TYPE_HOST:
+            memAccessor = std::make_unique<HostMemoryAccessor>();
+            break;
+        case UMF_MEMORY_TYPE_UNKNOWN:
+            break;
+        }
+
         expected_memory_type = memory_type;
     }
 
-    void TearDown() override { test::TearDown(); }
+    void TearDown() override {
+        if (params) {
+            destroyCuParams(params);
+        }
 
-    umf_cuda_memory_provider_params_handle_t params;
-    MemoryAccessor *memAccessor = nullptr;
-    CUcontext expected_context;
+        test::TearDown();
+    }
+
+    CUDATestHelper cudaTestHelper;
+    umf_cuda_memory_provider_params_handle_t params = nullptr;
+
+    std::unique_ptr<MemoryAccessor> memAccessor = nullptr;
+    CUcontext expected_context = nullptr;
+    int expected_device = -1;
     umf_usm_memory_type_t expected_memory_type;
 };
 
@@ -238,12 +272,97 @@ TEST_P(umfCUDAProviderTest, getName) {
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_NE(provider, nullptr);
 
-    const char *name = umfMemoryProviderGetName(provider);
+    const char *name = nullptr;
+    umf_result = umfMemoryProviderGetName(provider, &name);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_STREQ(name, "CUDA");
 
     umfMemoryProviderDestroy(provider);
 }
 
+TEST_P(umfCUDAProviderTest, ctl_stats) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t ret =
+        umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), params, &provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    size_t allocated = 0, peak = 0;
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                    &allocated, sizeof(allocated), provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, 0u);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, 0u);
+
+    void *ptr = nullptr;
+    const size_t size = 1024 * 8;
+    ret = umfMemoryProviderAlloc(provider, size, 0, &ptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                    &allocated, sizeof(allocated), provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, size);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, size);
+
+    ret = umfMemoryProviderFree(provider, ptr, size);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                    &allocated, sizeof(allocated), provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, 0u);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, size);
+
+    ret = umfCtlExec("umf.provider.by_handle.{}.stats.peak_memory.reset", NULL,
+                     0, provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, 0u);
+    umfMemoryProviderDestroy(provider);
+}
+
+TEST_P(umfCUDAProviderTest, custom_name) {
+    const char *custom = "my_cuda";
+    ASSERT_EQ(umfCUDAMemoryProviderParamsSetName(params, custom),
+              UMF_RESULT_SUCCESS);
+
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t res =
+        umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), params, &provider);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    const char *name = nullptr;
+    res = umfMemoryProviderGetName(provider, &name);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, custom);
+    umfMemoryProviderDestroy(provider);
+}
+
+TEST(umfCUDAProviderOps, default_name_null_handle) {
+    const char *name = nullptr;
+    auto ret = umfCUDAMemoryProviderOps()->get_name(nullptr, &name);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, "CUDA");
+}
+
 TEST_P(umfCUDAProviderTest, allocInvalidSize) {
     CUcontext expected_current_context = get_current_context();
     // create CUDA provider
@@ -300,6 +419,44 @@ TEST_P(umfCUDAProviderTest, getPageSizeInvalidArgs) {
     umfMemoryProviderDestroy(provider);
 }
 
+TEST_P(umfCUDAProviderTest, cudaProviderDefaultParams) {
+    umf_cuda_memory_provider_params_handle_t defaultParams = nullptr;
+    umf_result_t umf_result = umfCUDAMemoryProviderParamsCreate(&defaultParams);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfCUDAMemoryProviderParamsSetMemoryType(defaultParams,
+                                                          expected_memory_type);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // NOTE: we intentionally do not set any context and device params
+
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result = umfMemoryProviderCreate(umfCUDAMemoryProviderOps(),
+                                         defaultParams, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    // do single alloc and check if the context and device id of allocated
+    // memory are correct
+
+    void *ptr = nullptr;
+    umf_result = umfMemoryProviderAlloc(provider, 128, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    CUcontext actual_mem_context = get_mem_context(ptr);
+    ASSERT_EQ(actual_mem_context, expected_context);
+
+    int actual_device = get_mem_device(ptr);
+    ASSERT_EQ(actual_device, expected_device);
+
+    umf_result = umfMemoryProviderFree(provider, ptr, 128);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfMemoryProviderDestroy(provider);
+    umfCUDAMemoryProviderParamsDestroy(defaultParams);
+}
+
 TEST_P(umfCUDAProviderTest, cudaProviderNullParams) {
     umf_result_t res = umfCUDAMemoryProviderParamsCreate(nullptr);
     EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
@@ -315,36 +472,335 @@ TEST_P(umfCUDAProviderTest, cudaProviderNullParams) {
     EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
 
-// TODO add tests that mixes CUDA Memory Provider and Disjoint Pool
+TEST_P(umfCUDAProviderTest, cudaProviderInvalidCreate) {
+    CUdevice device;
+    int ret = get_cuda_device(&device);
+    ASSERT_EQ(ret, 0);
+
+    CUcontext ctx;
+    ret = create_context(device, &ctx);
+    ASSERT_EQ(ret, 0);
+
+    // wrong memory type
+    umf_cuda_memory_provider_params_handle_t params_wrong_memtype =
+        create_cuda_prov_params(ctx, device,
+                                static_cast<umf_usm_memory_type_t>(0xFFFF), 0);
+    ASSERT_NE(params_wrong_memtype, nullptr);
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t umf_result = umfMemoryProviderCreate(
+        umfCUDAMemoryProviderOps(), params_wrong_memtype, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    umf_result = umfCUDAMemoryProviderParamsDestroy(params_wrong_memtype);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // wrong context
+    umf_cuda_memory_provider_params_handle_t params_wrong_ctx =
+        create_cuda_prov_params(nullptr, device, UMF_MEMORY_TYPE_HOST, 0);
+    ASSERT_NE(params_wrong_ctx, nullptr);
+    umf_result = umfMemoryProviderCreate(umfCUDAMemoryProviderOps(),
+                                         params_wrong_ctx, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    umf_result = umfCUDAMemoryProviderParamsDestroy(params_wrong_ctx);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // wrong device
+    umf_cuda_memory_provider_params_handle_t params_wrong_device =
+        create_cuda_prov_params(ctx, (CUdevice)-1, UMF_MEMORY_TYPE_HOST, 0);
+    ASSERT_NE(params_wrong_device, nullptr);
+    umf_result = umfMemoryProviderCreate(umfCUDAMemoryProviderOps(),
+                                         params_wrong_device, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    umf_result = umfCUDAMemoryProviderParamsDestroy(params_wrong_device);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
 
-CUDATestHelper cudaTestHelper;
+TEST_P(umfCUDAProviderTest, multiContext) {
+    CUdevice device;
+    int ret = get_cuda_device(&device);
+    ASSERT_EQ(ret, 0);
+
+    // create two CUDA contexts and two providers
+    CUcontext ctx1, ctx2;
+    ret = create_context(device, &ctx1);
+    ASSERT_EQ(ret, 0);
+    ret = create_context(device, &ctx2);
+    ASSERT_EQ(ret, 0);
+
+    umf_cuda_memory_provider_params_handle_t params1 =
+        create_cuda_prov_params(ctx1, device, UMF_MEMORY_TYPE_HOST, 0);
+    ASSERT_NE(params1, nullptr);
+    umf_memory_provider_handle_t provider1;
+    umf_result_t umf_result = umfMemoryProviderCreate(
+        umfCUDAMemoryProviderOps(), params1, &provider1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider1, nullptr);
+    umf_result = umfCUDAMemoryProviderParamsDestroy(params1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-cuda_params_unique_handle_t cuParams_device_memory = create_cuda_prov_params(
-    cudaTestHelper.get_test_context(), cudaTestHelper.get_test_device(),
-    UMF_MEMORY_TYPE_DEVICE);
-cuda_params_unique_handle_t cuParams_shared_memory = create_cuda_prov_params(
-    cudaTestHelper.get_test_context(), cudaTestHelper.get_test_device(),
-    UMF_MEMORY_TYPE_SHARED);
-cuda_params_unique_handle_t cuParams_host_memory = create_cuda_prov_params(
-    cudaTestHelper.get_test_context(), cudaTestHelper.get_test_device(),
-    UMF_MEMORY_TYPE_HOST);
+    umf_cuda_memory_provider_params_handle_t params2 =
+        create_cuda_prov_params(ctx2, device, UMF_MEMORY_TYPE_HOST, 0);
+    ASSERT_NE(params2, nullptr);
+    umf_memory_provider_handle_t provider2;
+    umf_result = umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), params2,
+                                         &provider2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider2, nullptr);
+    umf_result = umfCUDAMemoryProviderParamsDestroy(params2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // use the providers
+    // allocate from 1, then from 2, then free 1, then free 2
+    void *ptr1, *ptr2;
+    const int size = 128;
+    // NOTE: we use ctx1 here
+    umf_result = umfMemoryProviderAlloc(provider1, size, 0, &ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr1, nullptr);
+
+    // NOTE: we use ctx2 here
+    umf_result = umfMemoryProviderAlloc(provider2, size, 0, &ptr2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr2, nullptr);
+
+    // even if we change the context, we should be able to free the memory
+    ret = set_context(ctx2, NULL);
+    ASSERT_EQ(ret, 0);
+    // free memory from ctx1
+    umf_result = umfMemoryProviderFree(provider1, ptr1, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ret = set_context(ctx1, NULL);
+    ASSERT_EQ(ret, 0);
+    umf_result = umfMemoryProviderFree(provider2, ptr2, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // cleanup
+    umfMemoryProviderDestroy(provider2);
+    umfMemoryProviderDestroy(provider1);
+    ret = destroy_context(ctx1);
+    ASSERT_EQ(ret, 0);
+    ret = destroy_context(ctx2);
+    ASSERT_EQ(ret, 0);
+}
+
+TEST_P(umfCUDAProviderTest, memProps) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t umf_result =
+        umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    umf_memory_pool_handle_t pool = NULL;
+    umf_result = umfPoolCreate(umfProxyPoolOps(), provider, NULL, 0, &pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    size_t size = 1024;
+    void *ptr = umfPoolMalloc(pool, size);
+    ASSERT_NE(ptr, nullptr);
+
+    umf_memory_properties_handle_t props_handle = NULL;
+    umf_result_t result = umfGetMemoryPropertiesHandle(ptr, &props_handle);
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(props_handle, nullptr);
+
+    umf_usm_memory_type_t type = UMF_MEMORY_TYPE_UNKNOWN;
+    result = umfGetMemoryProperty(
+        props_handle, UMF_MEMORY_PROPERTY_POINTER_TYPE, &type, sizeof(type));
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(type, expected_memory_type);
+
+    void *baseAddress = nullptr;
+    result =
+        umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_BASE_ADDRESS,
+                             &baseAddress, sizeof(baseAddress));
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(baseAddress, ptr);
+
+    size_t baseSize = 0;
+    result = umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_BASE_SIZE,
+                                  &baseSize, sizeof(baseSize));
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_GE(baseSize, size);
+
+    int64_t bufferId = 0;
+    result = umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_BUFFER_ID,
+                                  &bufferId, sizeof(bufferId));
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_GE(bufferId, 0);
+
+    if (expected_memory_type != UMF_MEMORY_TYPE_HOST) {
+        CUdevice device = -1;
+        result = umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_DEVICE,
+                                      &device, sizeof(device));
+        ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+        ASSERT_EQ(device, cudaTestHelper.get_test_device());
+    }
+
+    CUcontext context = nullptr;
+    result = umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_CONTEXT,
+                                  &context, sizeof(context));
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(context, cudaTestHelper.get_test_context());
+
+    // check the props of pointer from the middle of alloc
+    void *midPtr = static_cast<char *>(ptr) + size / 2;
+    result = umfGetMemoryPropertiesHandle(midPtr, &props_handle);
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(props_handle, nullptr);
+    result = umfGetMemoryProperty(
+        props_handle, UMF_MEMORY_PROPERTY_POINTER_TYPE, &type, sizeof(type));
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(type, expected_memory_type);
+
+    result =
+        umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_BASE_ADDRESS,
+                             &baseAddress, sizeof(baseAddress));
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(baseAddress, ptr);
+
+    umfFree(ptr);
+
+    umfPoolDestroy(pool);
+    umfMemoryProviderDestroy(provider);
+}
+
+struct umfCUDAProviderAllocFlagsTest
+    : umf_test::test,
+      ::testing::WithParamInterface<
+          std::tuple<umf_usm_memory_type_t, unsigned int>> {
+
+    void SetUp() override {
+        test::SetUp();
+
+        get_cuda_device(&device);
+        create_context(device, &context);
+    }
+
+    void TearDown() override {
+        destroy_context(context);
+
+        test::TearDown();
+    }
+
+    CUdevice device;
+    CUcontext context;
+};
+
+TEST_P(umfCUDAProviderAllocFlagsTest, cudaAllocFlags) {
+    auto [memory_type, test_flags] = this->GetParam();
+
+    umf_cuda_memory_provider_params_handle_t test_params =
+        create_cuda_prov_params(context, device, memory_type, test_flags);
+
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t umf_result = umfMemoryProviderCreate(
+        umfCUDAMemoryProviderOps(), test_params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    void *ptr = nullptr;
+    umf_result = umfMemoryProviderAlloc(provider, 128, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    if (memory_type == UMF_MEMORY_TYPE_HOST) {
+        // check if the memory allocation flag is set correctly
+        unsigned int flags = get_mem_host_alloc_flags(ptr);
+        ASSERT_TRUE(flags & test_flags);
+    }
+
+    umf_result = umfMemoryProviderFree(provider, ptr, 128);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfMemoryProviderDestroy(provider);
+    umfCUDAMemoryProviderParamsDestroy(test_params);
+}
+
+TEST_P(umfCUDAProviderAllocFlagsTest, reuseParams) {
+    auto [memory_type, test_flags] = this->GetParam();
+
+    // first, create a provider for SHARED memory type with empty alloc flags,
+    // and the reuse the test_params to create a provider for test params
+    umf_cuda_memory_provider_params_handle_t test_params =
+        create_cuda_prov_params(context, device, UMF_MEMORY_TYPE_SHARED, 0);
+
+    umf_memory_provider_handle_t provider = nullptr;
+
+    umf_result_t umf_result = umfMemoryProviderCreate(
+        umfCUDAMemoryProviderOps(), test_params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    void *ptr = nullptr;
+    umf_result = umfMemoryProviderAlloc(provider, 128, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    umf_result = umfMemoryProviderFree(provider, ptr, 128);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfMemoryProviderDestroy(provider);
+
+    // reuse the test_params to create a provider for test params
+    umf_result =
+        umfCUDAMemoryProviderParamsSetMemoryType(test_params, memory_type);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result =
+        umfCUDAMemoryProviderParamsSetAllocFlags(test_params, test_flags);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfMemoryProviderCreate(umfCUDAMemoryProviderOps(),
+                                         test_params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    umf_result = umfMemoryProviderAlloc(provider, 128, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    if (memory_type == UMF_MEMORY_TYPE_HOST) {
+        // check if the memory allocation flag is set correctly
+        unsigned int flags = get_mem_host_alloc_flags(ptr);
+        ASSERT_TRUE(flags & test_flags);
+    }
+
+    umf_result = umfMemoryProviderFree(provider, ptr, 128);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfMemoryProviderDestroy(provider);
+
+    umfCUDAMemoryProviderParamsDestroy(test_params);
+}
+
+// TODO add tests that mixes CUDA Memory Provider and Disjoint Pool
 
-CUDAMemoryAccessor cuAccessor(cudaTestHelper.get_test_context(),
-                              cudaTestHelper.get_test_device());
-HostMemoryAccessor hostAccessor;
+INSTANTIATE_TEST_SUITE_P(umfCUDAProviderTestSuite, umfCUDAProviderTest,
+                         ::testing::Values(UMF_MEMORY_TYPE_HOST,
+                                           UMF_MEMORY_TYPE_SHARED,
+                                           UMF_MEMORY_TYPE_DEVICE),
+                         ([](auto const &info) -> std::string {
+                             static const char *names[] = {
+                                 "UMF_MEMORY_TYPE_HOST",
+                                 "UMF_MEMORY_TYPE_SHARED",
+                                 "UMF_MEMORY_TYPE_DEVICE"};
+                             return names[info.index];
+                         }));
 
 INSTANTIATE_TEST_SUITE_P(
-    umfCUDAProviderTestSuite, umfCUDAProviderTest,
+    umfCUDAProviderAllocFlagsTestSuite, umfCUDAProviderAllocFlagsTest,
     ::testing::Values(
-        CUDAProviderTestParams{cuParams_device_memory.get(),
-                               cudaTestHelper.get_test_context(),
-                               UMF_MEMORY_TYPE_DEVICE, &cuAccessor},
-        CUDAProviderTestParams{cuParams_shared_memory.get(),
-                               cudaTestHelper.get_test_context(),
-                               UMF_MEMORY_TYPE_SHARED, &hostAccessor},
-        CUDAProviderTestParams{cuParams_host_memory.get(),
-                               cudaTestHelper.get_test_context(),
-                               UMF_MEMORY_TYPE_HOST, &hostAccessor}));
+        std::make_tuple(UMF_MEMORY_TYPE_SHARED, CU_MEM_ATTACH_GLOBAL),
+        std::make_tuple(UMF_MEMORY_TYPE_SHARED, CU_MEM_ATTACH_HOST),
+        std::make_tuple(UMF_MEMORY_TYPE_HOST, CU_MEMHOSTALLOC_PORTABLE),
+        std::make_tuple(UMF_MEMORY_TYPE_HOST, CU_MEMHOSTALLOC_DEVICEMAP),
+        std::make_tuple(UMF_MEMORY_TYPE_HOST, CU_MEMHOSTALLOC_WRITECOMBINED)),
+    ([](auto const &info) -> std::string {
+        static const char *names[] = {"SHARED_GLOBAL", "SHARED_HOST",
+                                      "HOST_PORTABLE", "HOST_DEVICEMAP",
+                                      "HOST_WRITECOMBINED"};
+        return names[info.index];
+    }));
 
 // TODO: add IPC API
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest);
diff --git a/test/providers/provider_cuda_not_impl.cpp b/test/providers/provider_cuda_not_impl.cpp
index 30fc373ca3..9ddea2048c 100644
--- a/test/providers/provider_cuda_not_impl.cpp
+++ b/test/providers/provider_cuda_not_impl.cpp
@@ -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
 
@@ -26,6 +26,9 @@ TEST_F(test, cuda_provider_not_implemented) {
                                                       UMF_MEMORY_TYPE_DEVICE);
     ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
 
-    umf_memory_provider_ops_t *ops = umfCUDAMemoryProviderOps();
+    result = umfCUDAMemoryProviderParamsSetAllocFlags(hParams, 0);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    const umf_memory_provider_ops_t *ops = umfCUDAMemoryProviderOps();
     ASSERT_EQ(ops, nullptr);
 }
diff --git a/test/providers/provider_level_zero.cpp b/test/providers/provider_level_zero.cpp
index d0584777be..1894d0aa4e 100644
--- a/test/providers/provider_level_zero.cpp
+++ b/test/providers/provider_level_zero.cpp
@@ -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
 
@@ -9,6 +9,8 @@
 
 #include <mutex>
 
+#include <umf/experimental/ctl.h>
+#include <umf/experimental/memory_properties.h>
 #include <umf/providers/provider_level_zero.h>
 
 #include "ipcFixtures.hpp"
@@ -42,7 +44,13 @@ class LevelZeroTestHelper {
 LevelZeroTestHelper::LevelZeroTestHelper() {
     uint32_t driver_idx = 0;
 
-    int ret = utils_ze_find_driver_with_gpu(&driver_idx, &hDriver_);
+    int ret = utils_ze_init_level_zero();
+    if (ret != 0) {
+        fprintf(stderr, "utils_ze_init_level_zero() failed!\n");
+        return;
+    }
+
+    ret = utils_ze_find_driver_with_gpu(&driver_idx, &hDriver_);
     if (ret != 0 || hDriver_ == NULL) {
         fprintf(stderr, "utils_ze_find_driver_with_gpu() failed!\n");
         return;
@@ -61,11 +69,7 @@ LevelZeroTestHelper::LevelZeroTestHelper() {
     }
 }
 
-using level_zero_params_unique_handle_t =
-    std::unique_ptr<umf_level_zero_memory_provider_params_t,
-                    decltype(&umfLevelZeroMemoryProviderParamsDestroy)>;
-
-level_zero_params_unique_handle_t
+umf_level_zero_memory_provider_params_handle_t
 create_level_zero_prov_params(ze_context_handle_t context,
                               ze_device_handle_t device,
                               umf_usm_memory_type_t memory_type) {
@@ -73,51 +77,55 @@ create_level_zero_prov_params(ze_context_handle_t context,
 
     umf_result_t res = umfLevelZeroMemoryProviderParamsCreate(&params);
     if (res != UMF_RESULT_SUCCESS) {
-        return level_zero_params_unique_handle_t(
-            nullptr, &umfLevelZeroMemoryProviderParamsDestroy);
+        return nullptr;
     }
 
     res = umfLevelZeroMemoryProviderParamsSetContext(params, context);
     if (res != UMF_RESULT_SUCCESS) {
         umfLevelZeroMemoryProviderParamsDestroy(params);
-        return level_zero_params_unique_handle_t(
-            nullptr, &umfLevelZeroMemoryProviderParamsDestroy);
-        ;
+        return nullptr;
     }
 
     res = umfLevelZeroMemoryProviderParamsSetDevice(params, device);
     if (res != UMF_RESULT_SUCCESS) {
         umfLevelZeroMemoryProviderParamsDestroy(params);
-        return level_zero_params_unique_handle_t(
-            nullptr, &umfLevelZeroMemoryProviderParamsDestroy);
-        ;
+        return nullptr;
     }
 
     res = umfLevelZeroMemoryProviderParamsSetMemoryType(params, memory_type);
     if (res != UMF_RESULT_SUCCESS) {
         umfLevelZeroMemoryProviderParamsDestroy(params);
-        return level_zero_params_unique_handle_t(
-            nullptr, &umfLevelZeroMemoryProviderParamsDestroy);
-        ;
+        return nullptr;
     }
 
-    return level_zero_params_unique_handle_t(
-        params, &umfLevelZeroMemoryProviderParamsDestroy);
+    return params;
+}
+
+umf_result_t destroyL0Params(void *params) {
+    return umfLevelZeroMemoryProviderParamsDestroy(
+        static_cast<umf_level_zero_memory_provider_params_handle_t>(params));
 }
 
 struct LevelZeroProviderInit
     : public test,
-      public ::testing::WithParamInterface<umf_usm_memory_type_t> {};
+      public ::testing::WithParamInterface<umf_usm_memory_type_t> {
+    LevelZeroTestHelper l0TestHelper;
+};
 
 INSTANTIATE_TEST_SUITE_P(, LevelZeroProviderInit,
                          ::testing::Values(UMF_MEMORY_TYPE_HOST,
                                            UMF_MEMORY_TYPE_DEVICE,
-                                           UMF_MEMORY_TYPE_SHARED));
-
-LevelZeroTestHelper l0TestHelper;
+                                           UMF_MEMORY_TYPE_SHARED),
+                         ([](auto const &info) -> std::string {
+                             static const char *names[] = {
+                                 "UMF_MEMORY_TYPE_HOST",
+                                 "UMF_MEMORY_TYPE_DEVICE",
+                                 "UMF_MEMORY_TYPE_SHARED"};
+                             return names[info.index];
+                         }));
 
 TEST_P(LevelZeroProviderInit, FailNullContext) {
-    umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
+    const umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
     ASSERT_NE(ops, nullptr);
 
     auto memory_type = GetParam();
@@ -147,7 +155,7 @@ TEST_P(LevelZeroProviderInit, FailNullDevice) {
         GTEST_SKIP() << "Host memory does not require device handle";
     }
 
-    umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
+    const umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
     ASSERT_NE(ops, nullptr);
 
     auto memory_type = GetParam();
@@ -168,12 +176,14 @@ TEST_P(LevelZeroProviderInit, FailNullDevice) {
     umfLevelZeroMemoryProviderParamsDestroy(hParams);
 }
 
-TEST_F(test, FailNonNullDevice) {
-    umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
+TEST_F(LevelZeroProviderInit, FailNonNullDevice) {
+    if (GetParam() != UMF_MEMORY_TYPE_HOST) {
+        GTEST_SKIP() << "Host memory does not require device handle";
+    }
+    const umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
     ASSERT_NE(ops, nullptr);
 
-    auto memory_type = UMF_MEMORY_TYPE_HOST;
-
+    auto memory_type = GetParam();
     umf_level_zero_memory_provider_params_handle_t hParams = nullptr;
     umf_result_t result = umfLevelZeroMemoryProviderParamsCreate(&hParams);
     ASSERT_EQ(result, UMF_RESULT_SUCCESS);
@@ -194,28 +204,44 @@ TEST_F(test, FailNonNullDevice) {
     umfLevelZeroMemoryProviderParamsDestroy(hParams);
 }
 
-TEST_F(test, FailMismatchedResidentHandlesCount) {
-    umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
+static void
+invalidResidentDevicesHandlesTestHelper(ze_device_handle_t *hDevices,
+                                        uint32_t deviceCount) {
+    const umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
     ASSERT_NE(ops, nullptr);
 
     umf_level_zero_memory_provider_params_handle_t hParams = nullptr;
-    umf_result_t result = umfLevelZeroMemoryProviderParamsCreate(&hParams);
-    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    const umf_result_t create_result =
+        umfLevelZeroMemoryProviderParamsCreate(&hParams);
+    ASSERT_EQ(create_result, UMF_RESULT_SUCCESS);
 
-    result = umfLevelZeroMemoryProviderParamsSetResidentDevices(hParams,
-                                                                nullptr, 99);
-    ASSERT_EQ(result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    const umf_result_t set_resident_result =
+        umfLevelZeroMemoryProviderParamsSetResidentDevices(hParams, hDevices,
+                                                           deviceCount);
+    ASSERT_EQ(set_resident_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     umfLevelZeroMemoryProviderParamsDestroy(hParams);
 }
 
+TEST_F(test, FailMismatchedResidentHandlesCount) {
+    invalidResidentDevicesHandlesTestHelper(nullptr, 99);
+}
+
+TEST_F(test, FailRedundantResidentDeviceHandles) {
+    std::vector<ze_device_handle_t> hDevices{
+        reinterpret_cast<ze_device_handle_t>(0x100),
+        reinterpret_cast<ze_device_handle_t>(0x101),
+        reinterpret_cast<ze_device_handle_t>(0x100)};
+    invalidResidentDevicesHandlesTestHelper(hDevices.data(), 3);
+}
+
 class LevelZeroMemoryAccessor : public MemoryAccessor {
   public:
     LevelZeroMemoryAccessor(ze_context_handle_t hContext,
                             ze_device_handle_t hDevice)
         : hDevice_(hDevice), hContext_(hContext) {}
     void fill(void *ptr, size_t size, const void *pattern,
-              size_t pattern_size) {
+              size_t pattern_size) override {
         ASSERT_NE(ptr, nullptr);
 
         int ret = utils_ze_level_zero_fill(hContext_, hDevice_, ptr, size,
@@ -223,7 +249,7 @@ class LevelZeroMemoryAccessor : public MemoryAccessor {
         ASSERT_EQ(ret, 0);
     }
 
-    void copy(void *dst_ptr, void *src_ptr, size_t size) {
+    void copy(void *dst_ptr, void *src_ptr, size_t size) override {
         ASSERT_NE(dst_ptr, nullptr);
         ASSERT_NE(src_ptr, nullptr);
 
@@ -232,38 +258,51 @@ class LevelZeroMemoryAccessor : public MemoryAccessor {
         ASSERT_EQ(ret, 0);
     }
 
+    const char *getName() override { return "LevelZeroMemoryAccessor"; }
+
   private:
     ze_device_handle_t hDevice_;
     ze_context_handle_t hContext_;
 };
 
-using LevelZeroProviderTestParams =
-    std::tuple<umf_level_zero_memory_provider_params_handle_t,
-               ze_context_handle_t, umf_usm_memory_type_t, MemoryAccessor *>;
-
 struct umfLevelZeroProviderTest
     : umf_test::test,
-      ::testing::WithParamInterface<LevelZeroProviderTestParams> {
+      ::testing::WithParamInterface<umf_usm_memory_type_t> {
 
     void SetUp() override {
         test::SetUp();
 
-        auto [l0_params, ze_context, memory_type, accessor] = this->GetParam();
-        params = l0_params;
-        memAccessor = accessor;
-        hContext = ze_context;
+        umf_usm_memory_type_t memory_type = this->GetParam();
+        umfExpectedMemoryType = memory_type;
+
+        params = nullptr;
+        memAccessor = nullptr;
+        hContext = l0TestHelper.get_test_context();
 
         ASSERT_NE(hContext, nullptr);
 
         switch (memory_type) {
         case UMF_MEMORY_TYPE_DEVICE:
             zeMemoryTypeExpected = ZE_MEMORY_TYPE_DEVICE;
+            params = create_level_zero_prov_params(
+                l0TestHelper.get_test_context(), l0TestHelper.get_test_device(),
+                memory_type);
+            memAccessor = std::make_unique<LevelZeroMemoryAccessor>(
+                l0TestHelper.get_test_context(),
+                l0TestHelper.get_test_device());
             break;
         case UMF_MEMORY_TYPE_SHARED:
             zeMemoryTypeExpected = ZE_MEMORY_TYPE_SHARED;
+            params = create_level_zero_prov_params(
+                l0TestHelper.get_test_context(), l0TestHelper.get_test_device(),
+                memory_type);
+            memAccessor = std::make_unique<HostMemoryAccessor>();
             break;
         case UMF_MEMORY_TYPE_HOST:
             zeMemoryTypeExpected = ZE_MEMORY_TYPE_HOST;
+            params = create_level_zero_prov_params(
+                l0TestHelper.get_test_context(), nullptr, memory_type);
+            memAccessor = std::make_unique<HostMemoryAccessor>();
             break;
         case UMF_MEMORY_TYPE_UNKNOWN:
             zeMemoryTypeExpected = ZE_MEMORY_TYPE_UNKNOWN;
@@ -273,12 +312,21 @@ struct umfLevelZeroProviderTest
         ASSERT_NE(zeMemoryTypeExpected, ZE_MEMORY_TYPE_UNKNOWN);
     }
 
-    void TearDown() override { test::TearDown(); }
+    void TearDown() override {
+        if (params) {
+            destroyL0Params(params);
+        }
+
+        test::TearDown();
+    }
+
+    LevelZeroTestHelper l0TestHelper;
+    umf_level_zero_memory_provider_params_handle_t params = nullptr;
 
-    umf_level_zero_memory_provider_params_handle_t params;
-    MemoryAccessor *memAccessor = nullptr;
+    std::unique_ptr<MemoryAccessor> memAccessor = nullptr;
     ze_context_handle_t hContext = nullptr;
     ze_memory_type_t zeMemoryTypeExpected = ZE_MEMORY_TYPE_UNKNOWN;
+    umf_usm_memory_type_t umfExpectedMemoryType = UMF_MEMORY_TYPE_UNKNOWN;
 };
 
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfLevelZeroProviderTest);
@@ -340,6 +388,18 @@ TEST_P(umfLevelZeroProviderTest, getPageSize) {
 
     ASSERT_GE(recommendedPageSize, minPageSize);
 
+    void *ptr;
+    umf_result = umfMemoryProviderAlloc(provider, 1, 0, &ptr);
+
+    size_t actualPageSize = 0;
+    umf_result =
+        umfMemoryProviderGetMinPageSize(provider, ptr, &actualPageSize);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_GE(actualPageSize, minPageSize);
+
+    umf_result = umfMemoryProviderFree(provider, ptr, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
     umfMemoryProviderDestroy(provider);
 }
 
@@ -350,12 +410,133 @@ TEST_P(umfLevelZeroProviderTest, getName) {
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_NE(provider, nullptr);
 
-    const char *name = umfMemoryProviderGetName(provider);
+    const char *name = nullptr;
+    umf_result = umfMemoryProviderGetName(provider, &name);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_STREQ(name, "LEVEL_ZERO");
 
     umfMemoryProviderDestroy(provider);
 }
 
+TEST_P(umfLevelZeroProviderTest, ctl_stats) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t ret = umfMemoryProviderCreate(umfLevelZeroMemoryProviderOps(),
+                                               params, &provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    size_t allocated = 0, peak = 0;
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                    &allocated, sizeof(allocated), provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, 0u);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, 0u);
+
+    void *ptr = nullptr;
+    const size_t size = 1024 * 8;
+    ret = umfMemoryProviderAlloc(provider, size, 0, &ptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                    &allocated, sizeof(allocated), provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, size);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, size);
+
+    ret = umfMemoryProviderFree(provider, ptr, size);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.allocated_memory",
+                    &allocated, sizeof(allocated), provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(allocated, 0u);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, size);
+
+    ret = umfCtlExec("umf.provider.by_handle.{}.stats.peak_memory.reset", NULL,
+                     0, provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfCtlGet("umf.provider.by_handle.{}.stats.peak_memory", &peak,
+                    sizeof(peak), provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(peak, 0u);
+    umfMemoryProviderDestroy(provider);
+}
+
+TEST_P(umfLevelZeroProviderTest, ctl_use_import_export_for_IPC) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t ret = umfMemoryProviderCreate(umfLevelZeroMemoryProviderOps(),
+                                               params, &provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    // Test reading the default value (0 = IPC)
+    int use_import_export_for_IPC = 1; // Set to invalid value first
+    ret =
+        umfCtlGet("umf.provider.by_handle.{}.params.use_import_export_for_IPC",
+                  &use_import_export_for_IPC, sizeof(use_import_export_for_IPC),
+                  provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(use_import_export_for_IPC, 0); // Default is IPC (0)
+
+    // Test writing a new value (1 = import/export)
+    int new_policy = 1;
+    ret =
+        umfCtlSet("umf.provider.by_handle.{}.params.use_import_export_for_IPC",
+                  &new_policy, sizeof(new_policy), provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    // Test reading the updated value
+    use_import_export_for_IPC = 0; // Set to different value first
+    ret =
+        umfCtlGet("umf.provider.by_handle.{}.params.use_import_export_for_IPC",
+                  &use_import_export_for_IPC, sizeof(use_import_export_for_IPC),
+                  provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(use_import_export_for_IPC, 1); // Should be import/export (1)
+
+    umfMemoryProviderDestroy(provider);
+}
+
+TEST_P(umfLevelZeroProviderTest, custom_name) {
+    const char *custom = "my_level_zero";
+    ASSERT_EQ(umfLevelZeroMemoryProviderParamsSetName(params, custom),
+              UMF_RESULT_SUCCESS);
+
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t res = umfMemoryProviderCreate(umfLevelZeroMemoryProviderOps(),
+                                               params, &provider);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    const char *name = nullptr;
+    res = umfMemoryProviderGetName(provider, &name);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, custom);
+    umfMemoryProviderDestroy(provider);
+}
+
+TEST(umfLevelZeroProviderOps, default_name_null_handle) {
+    const char *name = nullptr;
+    auto ret = umfLevelZeroMemoryProviderOps()->get_name(nullptr, &name);
+
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, "LEVEL_ZERO");
+}
+
 TEST_P(umfLevelZeroProviderTest, allocInvalidSize) {
     umf_memory_provider_handle_t provider = nullptr;
     umf_result_t umf_result = umfMemoryProviderCreate(
@@ -369,7 +550,9 @@ TEST_P(umfLevelZeroProviderTest, allocInvalidSize) {
     ASSERT_EQ(umf_result, UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC);
     const char *message;
     int32_t error;
-    umfMemoryProviderGetLastNativeError(provider, &message, &error);
+    umf_result =
+        umfMemoryProviderGetLastNativeError(provider, &message, &error);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED); // TODO: see #1385
     ASSERT_EQ(error, ZE_RESULT_ERROR_UNSUPPORTED_SIZE);
 
     umfMemoryProviderDestroy(provider);
@@ -414,41 +597,147 @@ TEST_P(umfLevelZeroProviderTest, levelZeroProviderNullParams) {
     res = umfLevelZeroMemoryProviderParamsSetMemoryType(nullptr,
                                                         UMF_MEMORY_TYPE_DEVICE);
     EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(nullptr, 0);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
 
-// TODO add tests that mixes Level Zero Memory Provider and Disjoint Pool
+TEST_P(umfLevelZeroProviderTest, setDeviceOrdinalValid) {
+    int64_t numProps =
+        utils_ze_get_num_memory_properties(l0TestHelper.get_test_device());
+    ASSERT_GE(numProps, 0);
+
+    for (uint32_t ordinal = 0; ordinal < static_cast<uint32_t>(numProps);
+         ordinal++) {
+        umf_memory_provider_handle_t provider = nullptr;
+        umf_result_t res =
+            umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(params, ordinal);
+        EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+
+        res = umfMemoryProviderCreate(umfLevelZeroMemoryProviderOps(), params,
+                                      &provider);
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+        ASSERT_NE(provider, nullptr);
+
+        size_t size = 1024;
+        void *ptr = nullptr;
+        res = umfMemoryProviderAlloc(provider, size, 0, &ptr);
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ptr, nullptr);
 
-level_zero_params_unique_handle_t l0Params_device_memory =
-    create_level_zero_prov_params(l0TestHelper.get_test_context(),
-                                  l0TestHelper.get_test_device(),
-                                  UMF_MEMORY_TYPE_DEVICE);
-level_zero_params_unique_handle_t l0Params_shared_memory =
-    create_level_zero_prov_params(l0TestHelper.get_test_context(),
-                                  l0TestHelper.get_test_device(),
-                                  UMF_MEMORY_TYPE_SHARED);
-level_zero_params_unique_handle_t l0Params_host_memory =
-    create_level_zero_prov_params(l0TestHelper.get_test_context(), nullptr,
-                                  UMF_MEMORY_TYPE_HOST);
+        res = umfMemoryProviderFree(provider, ptr, size);
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
 
-LevelZeroMemoryAccessor
-    l0Accessor((ze_context_handle_t)l0TestHelper.get_test_context(),
-               (ze_device_handle_t)l0TestHelper.get_test_device());
+        umfMemoryProviderDestroy(provider);
+    }
+}
+
+TEST_P(umfLevelZeroProviderTest, memProps) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t umf_result = umfMemoryProviderCreate(
+        umfLevelZeroMemoryProviderOps(), params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
 
-HostMemoryAccessor hostAccessor;
+    umf_memory_pool_handle_t pool = NULL;
+    umf_result = umfPoolCreate(umfProxyPoolOps(), provider, NULL, 0, &pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    size_t size = 1024;
+    void *ptr = umfPoolMalloc(pool, size);
+    ASSERT_NE(ptr, nullptr);
+
+    umf_memory_properties_handle_t props_handle = NULL;
+    umf_result_t result = umfGetMemoryPropertiesHandle(ptr, &props_handle);
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(props_handle, nullptr);
+
+    umf_usm_memory_type_t type = UMF_MEMORY_TYPE_UNKNOWN;
+    result = umfGetMemoryProperty(
+        props_handle, UMF_MEMORY_PROPERTY_POINTER_TYPE, &type, sizeof(type));
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(type, umfExpectedMemoryType);
+
+    // base address and size
+    void *baseAddress = nullptr;
+    result =
+        umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_BASE_ADDRESS,
+                             &baseAddress, sizeof(baseAddress));
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(baseAddress, ptr);
+
+    size_t baseSize = 0;
+    result = umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_BASE_SIZE,
+                                  &baseSize, sizeof(baseSize));
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_GE(baseSize, size);
+
+    int64_t bufferId = 0;
+    result = umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_BUFFER_ID,
+                                  &bufferId, sizeof(bufferId));
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_GE(bufferId, 0);
+
+    if (umfExpectedMemoryType != UMF_MEMORY_TYPE_HOST) {
+        ze_device_handle_t device = nullptr;
+        result = umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_DEVICE,
+                                      &device, sizeof(device));
+        ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+        ASSERT_EQ(device, l0TestHelper.get_test_device());
+    }
+
+    ze_context_handle_t context = nullptr;
+    result = umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_CONTEXT,
+                                  &context, sizeof(context));
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(context, l0TestHelper.get_test_context());
+
+    // check the props of pointer from the middle of alloc
+    void *midPtr = static_cast<char *>(ptr) + size / 2;
+    result = umfGetMemoryPropertiesHandle(midPtr, &props_handle);
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(props_handle, nullptr);
+    result = umfGetMemoryProperty(
+        props_handle, UMF_MEMORY_PROPERTY_POINTER_TYPE, &type, sizeof(type));
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(type, umfExpectedMemoryType);
+
+    result =
+        umfGetMemoryProperty(props_handle, UMF_MEMORY_PROPERTY_BASE_ADDRESS,
+                             &baseAddress, sizeof(baseAddress));
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(baseAddress, ptr);
+
+    umfFree(ptr);
+
+    umfPoolDestroy(pool);
+    umfMemoryProviderDestroy(provider);
+}
+
+// TODO add tests that mixes Level Zero Memory Provider and Disjoint Pool
 
 INSTANTIATE_TEST_SUITE_P(
     umfLevelZeroProviderTestSuite, umfLevelZeroProviderTest,
-    ::testing::Values(
-        LevelZeroProviderTestParams{l0Params_device_memory.get(),
-                                    l0TestHelper.get_test_context(),
-                                    UMF_MEMORY_TYPE_DEVICE, &l0Accessor},
-        LevelZeroProviderTestParams{l0Params_shared_memory.get(),
-                                    l0TestHelper.get_test_context(),
-                                    UMF_MEMORY_TYPE_SHARED, &hostAccessor},
-        LevelZeroProviderTestParams{l0Params_host_memory.get(),
-                                    l0TestHelper.get_test_context(),
-                                    UMF_MEMORY_TYPE_HOST, &hostAccessor}));
+    ::testing::Values(UMF_MEMORY_TYPE_HOST, UMF_MEMORY_TYPE_SHARED,
+                      UMF_MEMORY_TYPE_DEVICE),
+    ([](auto const &info) -> std::string {
+        static const char *names[] = {"UMF_MEMORY_TYPE_HOST",
+                                      "UMF_MEMORY_TYPE_SHARED",
+                                      "UMF_MEMORY_TYPE_DEVICE"};
+        return names[info.index];
+    }));
 
+LevelZeroTestHelper l0TestHelper;
+
+void *createL0ParamsDeviceMemory() {
+    return create_level_zero_prov_params(l0TestHelper.get_test_context(),
+                                         l0TestHelper.get_test_device(),
+                                         UMF_MEMORY_TYPE_DEVICE);
+}
+
+LevelZeroMemoryAccessor
+    l0Accessor((ze_context_handle_t)l0TestHelper.get_test_context(),
+               (ze_device_handle_t)l0TestHelper.get_test_device());
 // TODO: it looks like there is some problem with IPC implementation in Level
 // Zero on windows. Issue: #494
 #ifdef _WIN32
@@ -457,6 +746,7 @@ GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest);
 INSTANTIATE_TEST_SUITE_P(
     umfLevelZeroProviderTestSuite, umfIpcTest,
     ::testing::Values(ipcTestParams{
-        umfProxyPoolOps(), nullptr, umfLevelZeroMemoryProviderOps(),
-        l0Params_device_memory.get(), &l0Accessor, false}));
+        umfProxyPoolOps(), nullptr, nullptr, umfLevelZeroMemoryProviderOps(),
+        createL0ParamsDeviceMemory, destroyL0Params, &l0Accessor}),
+    ipcTestParamsNameGen);
 #endif
diff --git a/test/providers/provider_level_zero_not_impl.cpp b/test/providers/provider_level_zero_not_impl.cpp
index bea1acbe79..dfbd4a2b21 100644
--- a/test/providers/provider_level_zero_not_impl.cpp
+++ b/test/providers/provider_level_zero_not_impl.cpp
@@ -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
 
@@ -31,6 +31,13 @@ TEST_F(test, level_zero_provider_not_implemented) {
                                                                 hDevices, 1);
     ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
 
-    umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
+    result = umfLevelZeroMemoryProviderParamsSetFreePolicy(
+        hParams, UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFAULT);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    result = umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(hParams, 0);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    const umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
     ASSERT_EQ(ops, nullptr);
 }
diff --git a/test/providers/provider_level_zero_residency.cpp b/test/providers/provider_level_zero_residency.cpp
new file mode 100644
index 0000000000..88f761455d
--- /dev/null
+++ b/test/providers/provider_level_zero_residency.cpp
@@ -0,0 +1,94 @@
+// 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 "../common/level_zero_mocks.h"
+#include "utils_level_zero.h"
+#include "utils_log.h"
+
+#include "gtest/gtest.h"
+
+using namespace testing;
+
+class LevelZeroResidencyTestFixture : public Test {
+  protected:
+    StrictMock<LevelZeroMock> l0mock;
+    umf_memory_provider_handle_t provider = nullptr;
+    const ze_device_handle_t OUR_DEVICE;
+
+    LevelZeroResidencyTestFixture()
+        : OUR_DEVICE(TestCreatePointer<ze_device_handle_t>(777)) {
+        *MockedLevelZeroTestEnvironment::l0interface = &l0mock;
+    }
+
+    void SetUp() override {}
+    void TearDown() override {
+        Mock::VerifyAndClearExpectations(&l0mock);
+        umfMemoryProviderDestroy(provider);
+    }
+};
+
+TEST_F(LevelZeroResidencyTestFixture, addNonexistingDeviceShouldSucceed) {
+    provider = l0mock.initializeMemoryProviderWithResidentDevices(
+        OUR_DEVICE, {DEVICE_1, DEVICE_5, DEVICE_3});
+    ASSERT_EQ(umfLevelZeroMemoryProviderResidentDeviceChange(provider, DEVICE_2,
+                                                             true),
+              UMF_RESULT_SUCCESS);
+}
+
+TEST_F(LevelZeroResidencyTestFixture, addExistingDeviceShouldFail) {
+    provider = l0mock.initializeMemoryProviderWithResidentDevices(
+        OUR_DEVICE, {DEVICE_1, DEVICE_5, DEVICE_3});
+    ASSERT_EQ(umfLevelZeroMemoryProviderResidentDeviceChange(provider, DEVICE_5,
+                                                             true),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(LevelZeroResidencyTestFixture, removeNonexistingDeviceShouldFail) {
+    provider = l0mock.initializeMemoryProviderWithResidentDevices(
+        OUR_DEVICE, {DEVICE_1, DEVICE_5, DEVICE_3});
+    ASSERT_EQ(umfLevelZeroMemoryProviderResidentDeviceChange(provider, DEVICE_0,
+                                                             false),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(LevelZeroResidencyTestFixture, removeExistingDeviceShouldSucceed) {
+    provider = l0mock.initializeMemoryProviderWithResidentDevices(
+        OUR_DEVICE, {DEVICE_1, DEVICE_5, DEVICE_3});
+    ASSERT_EQ(umfLevelZeroMemoryProviderResidentDeviceChange(provider, DEVICE_1,
+                                                             false),
+              UMF_RESULT_SUCCESS);
+}
+
+TEST_F(LevelZeroResidencyTestFixture, addDeviceTwiceShouldFail) {
+    provider = l0mock.initializeMemoryProviderWithResidentDevices(
+        OUR_DEVICE, {DEVICE_1, DEVICE_5, DEVICE_3});
+    ASSERT_EQ(umfLevelZeroMemoryProviderResidentDeviceChange(provider, DEVICE_2,
+                                                             true),
+              UMF_RESULT_SUCCESS);
+    ASSERT_EQ(umfLevelZeroMemoryProviderResidentDeviceChange(provider, DEVICE_2,
+                                                             true),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(LevelZeroResidencyTestFixture, removeDeviceTwiceShouldFail) {
+    provider = l0mock.initializeMemoryProviderWithResidentDevices(
+        OUR_DEVICE, {DEVICE_1, DEVICE_5, DEVICE_3});
+    ASSERT_EQ(umfLevelZeroMemoryProviderResidentDeviceChange(provider, DEVICE_3,
+                                                             false),
+              UMF_RESULT_SUCCESS);
+    ASSERT_EQ(umfLevelZeroMemoryProviderResidentDeviceChange(provider, DEVICE_3,
+                                                             false),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+int main(int argc, char **argv) {
+    try {
+        InitGoogleTest(&argc, argv);
+        AddGlobalTestEnvironment(new MockedLevelZeroTestEnvironment);
+        return RUN_ALL_TESTS();
+    } catch (...) {
+        std::cerr << "Exception occurred." << std::endl;
+        return 1;
+    }
+}
diff --git a/test/supp/drd-umf_test-provider_file_memory_ipc.supp b/test/supp/drd-test_ipc.supp
similarity index 50%
rename from test/supp/drd-umf_test-provider_file_memory_ipc.supp
rename to test/supp/drd-test_ipc.supp
index 7fce241167..e55b2ee8d8 100644
--- a/test/supp/drd-umf_test-provider_file_memory_ipc.supp
+++ b/test/supp/drd-test_ipc.supp
@@ -9,6 +9,18 @@
 {
    [false-positive] Double check locking pattern in trackingOpenIpcHandle
    drd:ConflictingAccess
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
    fun:trackingOpenIpcHandle
    fun:umfMemoryProviderOpenIPCHandle
    fun:umfOpenIPCHandle
diff --git a/test/supp/drd-test_ipc_max_opened_limit.supp b/test/supp/drd-test_ipc_max_opened_limit.supp
new file mode 100644
index 0000000000..e55b2ee8d8
--- /dev/null
+++ b/test/supp/drd-test_ipc_max_opened_limit.supp
@@ -0,0 +1,28 @@
+{
+   Conditional variable destruction false-positive
+   drd:CondErr
+   ...
+   fun:pthread_cond_destroy@*
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
diff --git a/test/supp/drd-test_jemalloc_coarse_devdax.supp b/test/supp/drd-test_jemalloc_coarse_devdax.supp
new file mode 100644
index 0000000000..cb6179f875
--- /dev/null
+++ b/test/supp/drd-test_jemalloc_coarse_devdax.supp
@@ -0,0 +1,7 @@
+{
+   False-positive ConflictingAccess in jemalloc
+   drd:ConflictingAccess
+   ...
+   fun:je_*
+   ...
+}
diff --git a/test/supp/drd-test_jemalloc_coarse_file.supp b/test/supp/drd-test_jemalloc_coarse_file.supp
new file mode 100644
index 0000000000..cb6179f875
--- /dev/null
+++ b/test/supp/drd-test_jemalloc_coarse_file.supp
@@ -0,0 +1,7 @@
+{
+   False-positive ConflictingAccess in jemalloc
+   drd:ConflictingAccess
+   ...
+   fun:je_*
+   ...
+}
diff --git a/test/supp/drd-test_jemalloc_pool.supp b/test/supp/drd-test_jemalloc_pool.supp
new file mode 100644
index 0000000000..cb6179f875
--- /dev/null
+++ b/test/supp/drd-test_jemalloc_pool.supp
@@ -0,0 +1,7 @@
+{
+   False-positive ConflictingAccess in jemalloc
+   drd:ConflictingAccess
+   ...
+   fun:je_*
+   ...
+}
diff --git a/test/supp/drd-test_provider_devdax_memory_ipc.supp b/test/supp/drd-test_provider_devdax_memory_ipc.supp
new file mode 100644
index 0000000000..31608d30ca
--- /dev/null
+++ b/test/supp/drd-test_provider_devdax_memory_ipc.supp
@@ -0,0 +1,37 @@
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   False-positive ConflictingAccess in jemalloc
+   drd:ConflictingAccess
+   fun:atomic_*
+   ...
+   fun:je_*
+   ...
+}
+
+{
+   False-positive ConflictingAccess in tbbmalloc
+   drd:ConflictingAccess
+   ...
+   fun:tbb_pool_finalize
+   ...
+}
diff --git a/test/supp/drd-test_provider_file_memory_ipc.supp b/test/supp/drd-test_provider_file_memory_ipc.supp
new file mode 100644
index 0000000000..2252cb021b
--- /dev/null
+++ b/test/supp/drd-test_provider_file_memory_ipc.supp
@@ -0,0 +1,45 @@
+{
+   Conditional variable destruction false-positive
+   drd:CondErr
+   ...
+   fun:pthread_cond_destroy@*
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   False-positive ConflictingAccess in jemalloc
+   drd:ConflictingAccess
+   fun:atomic_*
+   ...
+   fun:je_*
+   ...
+}
+
+{
+   False-positive ConflictingAccess in tbbmalloc
+   drd:ConflictingAccess
+   ...
+   fun:tbb_pool_finalize
+   ...
+}
diff --git a/test/supp/drd-test_provider_os_memory.supp b/test/supp/drd-test_provider_os_memory.supp
new file mode 100644
index 0000000000..31608d30ca
--- /dev/null
+++ b/test/supp/drd-test_provider_os_memory.supp
@@ -0,0 +1,37 @@
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   False-positive ConflictingAccess in jemalloc
+   drd:ConflictingAccess
+   fun:atomic_*
+   ...
+   fun:je_*
+   ...
+}
+
+{
+   False-positive ConflictingAccess in tbbmalloc
+   drd:ConflictingAccess
+   ...
+   fun:tbb_pool_finalize
+   ...
+}
diff --git a/test/supp/drd-umf_test-scalable_coarse_devdax.supp b/test/supp/drd-test_scalable_coarse_devdax.supp
similarity index 100%
rename from test/supp/drd-umf_test-scalable_coarse_devdax.supp
rename to test/supp/drd-test_scalable_coarse_devdax.supp
diff --git a/test/supp/drd-umf_test-scalable_coarse_file.supp b/test/supp/drd-test_scalable_coarse_file.supp
similarity index 100%
rename from test/supp/drd-umf_test-scalable_coarse_file.supp
rename to test/supp/drd-test_scalable_coarse_file.supp
diff --git a/test/supp/drd-umf_test-scalable_pool.supp b/test/supp/drd-test_scalable_pool.supp
similarity index 100%
rename from test/supp/drd-umf_test-scalable_pool.supp
rename to test/supp/drd-test_scalable_pool.supp
diff --git a/test/supp/drd-umf_test-ipc.supp b/test/supp/drd-umf_test-ipc.supp
deleted file mode 100644
index 76844585d1..0000000000
--- a/test/supp/drd-umf_test-ipc.supp
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-   Conditional variable destruction false-positive
-   drd:CondErr
-   ...
-   fun:pthread_cond_destroy@*
-   ...
-}
diff --git a/test/supp/drd-umf_test-jemalloc_coarse_devdax.supp b/test/supp/drd-umf_test-jemalloc_coarse_devdax.supp
deleted file mode 100644
index fd071432b6..0000000000
--- a/test/supp/drd-umf_test-jemalloc_coarse_devdax.supp
+++ /dev/null
@@ -1,34 +0,0 @@
-{
-   False-positive ConflictingAccess in libjemalloc.so
-   drd:ConflictingAccess
-   obj:*/libjemalloc.so*
-   ...
-   fun:mallocx
-   ...
-}
-
-{
-   False-positive ConflictingAccess in libjemalloc.so
-   drd:ConflictingAccess
-   obj:*/libjemalloc.so*
-   ...
-   fun:op_free
-   ...
-}
-
-{
-   False-positive ConflictingAccess in libjemalloc.so
-   drd:ConflictingAccess
-   obj:*/libjemalloc.so*
-   ...
-   fun:__nptl_deallocate_tsd
-   ...
-}
-
-{
-   False-positive ConflictingAccess in critnib_insert
-   drd:ConflictingAccess
-   fun:store
-   fun:critnib_insert
-   ...
-}
diff --git a/test/supp/drd-umf_test-jemalloc_coarse_file.supp b/test/supp/drd-umf_test-jemalloc_coarse_file.supp
deleted file mode 100644
index fd071432b6..0000000000
--- a/test/supp/drd-umf_test-jemalloc_coarse_file.supp
+++ /dev/null
@@ -1,34 +0,0 @@
-{
-   False-positive ConflictingAccess in libjemalloc.so
-   drd:ConflictingAccess
-   obj:*/libjemalloc.so*
-   ...
-   fun:mallocx
-   ...
-}
-
-{
-   False-positive ConflictingAccess in libjemalloc.so
-   drd:ConflictingAccess
-   obj:*/libjemalloc.so*
-   ...
-   fun:op_free
-   ...
-}
-
-{
-   False-positive ConflictingAccess in libjemalloc.so
-   drd:ConflictingAccess
-   obj:*/libjemalloc.so*
-   ...
-   fun:__nptl_deallocate_tsd
-   ...
-}
-
-{
-   False-positive ConflictingAccess in critnib_insert
-   drd:ConflictingAccess
-   fun:store
-   fun:critnib_insert
-   ...
-}
diff --git a/test/supp/drd-umf_test-jemalloc_pool.supp b/test/supp/drd-umf_test-jemalloc_pool.supp
deleted file mode 100644
index 965ef38844..0000000000
--- a/test/supp/drd-umf_test-jemalloc_pool.supp
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-   Conflicting Access in libjemalloc.so - internal issue of libjemalloc
-   drd:ConflictingAccess
-   obj:*libjemalloc.so*
-   ...
-}
diff --git a/test/supp/drd-umf_test-provider_devdax_memory_ipc.supp b/test/supp/drd-umf_test-provider_devdax_memory_ipc.supp
deleted file mode 100644
index cd44bb49ae..0000000000
--- a/test/supp/drd-umf_test-provider_devdax_memory_ipc.supp
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-   [false-positive] Double check locking pattern in trackingOpenIpcHandle
-   drd:ConflictingAccess
-   fun:trackingOpenIpcHandle
-   fun:umfMemoryProviderOpenIPCHandle
-   fun:umfOpenIPCHandle
-   ...
-}
diff --git a/test/supp/drd-umf_test-provider_os_memory.supp b/test/supp/drd-umf_test-provider_os_memory.supp
deleted file mode 100644
index cd44bb49ae..0000000000
--- a/test/supp/drd-umf_test-provider_os_memory.supp
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-   [false-positive] Double check locking pattern in trackingOpenIpcHandle
-   drd:ConflictingAccess
-   fun:trackingOpenIpcHandle
-   fun:umfMemoryProviderOpenIPCHandle
-   fun:umfOpenIPCHandle
-   ...
-}
diff --git a/test/supp/helgrind-umf_test-disjointPool.supp b/test/supp/helgrind-test_disjoint_pool.supp
similarity index 52%
rename from test/supp/helgrind-umf_test-disjointPool.supp
rename to test/supp/helgrind-test_disjoint_pool.supp
index 3ada32736c..917237d7e9 100644
--- a/test/supp/helgrind-umf_test-disjointPool.supp
+++ b/test/supp/helgrind-test_disjoint_pool.supp
@@ -27,27 +27,3 @@
    fun:*gthread_mutex_unlock*pthread_mutex_t
    ...
 }
-
-{
-   Incompatibility with helgrind's implementation ("pthread_rwlock_{rd,rw}lock with a pthread_mutex_t* argument")
-   Helgrind:Misc
-   obj:*vgpreload_helgrind-amd64-linux.so
-   fun:*glibcxx_rwlock_wrlock*pthread_rwlock_t
-   ...
-}
-
-{
-   Incompatibility with helgrind's implementation ("pthread_rwlock_unlock with a pthread_mutex_t* argument")
-   Helgrind:Misc
-   obj:*vgpreload_helgrind-amd64-linux.so
-   fun:*glibcxx_rwlock_unlock*pthread_rwlock_t
-   ...
-}
-
-{
-   Incompatibility with helgrind's implementation ("pthread_rwlock_{rd,rw}lock with a pthread_mutex_t* argument")
-   Helgrind:Misc
-   obj:*vgpreload_helgrind-amd64-linux.so
-   fun:*glibcxx_rwlock_rdlock*pthread_rwlock_t*
-   ...
-}
diff --git a/test/supp/helgrind-test_ipc.supp b/test/supp/helgrind-test_ipc.supp
new file mode 100644
index 0000000000..fb17fd7a08
--- /dev/null
+++ b/test/supp/helgrind-test_ipc.supp
@@ -0,0 +1,20 @@
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
diff --git a/test/supp/helgrind-test_ipc_max_opened_limit.supp b/test/supp/helgrind-test_ipc_max_opened_limit.supp
new file mode 100644
index 0000000000..fb17fd7a08
--- /dev/null
+++ b/test/supp/helgrind-test_ipc_max_opened_limit.supp
@@ -0,0 +1,20 @@
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
diff --git a/test/supp/helgrind-test_jemalloc_coarse_devdax.supp b/test/supp/helgrind-test_jemalloc_coarse_devdax.supp
new file mode 100644
index 0000000000..98d748feac
--- /dev/null
+++ b/test/supp/helgrind-test_jemalloc_coarse_devdax.supp
@@ -0,0 +1,7 @@
+{
+   False-positive Race in jemalloc
+   Helgrind:Race
+   ...
+   fun:je_*
+   ...
+}
diff --git a/test/supp/helgrind-test_jemalloc_coarse_file.supp b/test/supp/helgrind-test_jemalloc_coarse_file.supp
new file mode 100644
index 0000000000..98d748feac
--- /dev/null
+++ b/test/supp/helgrind-test_jemalloc_coarse_file.supp
@@ -0,0 +1,7 @@
+{
+   False-positive Race in jemalloc
+   Helgrind:Race
+   ...
+   fun:je_*
+   ...
+}
diff --git a/test/supp/helgrind-test_jemalloc_pool.supp b/test/supp/helgrind-test_jemalloc_pool.supp
new file mode 100644
index 0000000000..98d748feac
--- /dev/null
+++ b/test/supp/helgrind-test_jemalloc_pool.supp
@@ -0,0 +1,7 @@
+{
+   False-positive Race in jemalloc
+   Helgrind:Race
+   ...
+   fun:je_*
+   ...
+}
diff --git a/test/supp/helgrind-test_provider_devdax_memory_ipc.supp b/test/supp/helgrind-test_provider_devdax_memory_ipc.supp
new file mode 100644
index 0000000000..63e7d626c2
--- /dev/null
+++ b/test/supp/helgrind-test_provider_devdax_memory_ipc.supp
@@ -0,0 +1,37 @@
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   False-positive ConflictingAccess in jemalloc
+   Helgrind:Race
+   fun:atomic_*
+   ...
+   fun:je_*
+   ...
+}
+
+{
+   False-positive ConflictingAccess in tbbmalloc
+   Helgrind:Race
+   ...
+   fun:tbb_pool_finalize
+   ...
+}
diff --git a/test/supp/helgrind-test_provider_file_memory_ipc.supp b/test/supp/helgrind-test_provider_file_memory_ipc.supp
new file mode 100644
index 0000000000..63e7d626c2
--- /dev/null
+++ b/test/supp/helgrind-test_provider_file_memory_ipc.supp
@@ -0,0 +1,37 @@
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   False-positive ConflictingAccess in jemalloc
+   Helgrind:Race
+   fun:atomic_*
+   ...
+   fun:je_*
+   ...
+}
+
+{
+   False-positive ConflictingAccess in tbbmalloc
+   Helgrind:Race
+   ...
+   fun:tbb_pool_finalize
+   ...
+}
diff --git a/test/supp/helgrind-test_provider_os_memory.supp b/test/supp/helgrind-test_provider_os_memory.supp
new file mode 100644
index 0000000000..63e7d626c2
--- /dev/null
+++ b/test/supp/helgrind-test_provider_os_memory.supp
@@ -0,0 +1,37 @@
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   False-positive ConflictingAccess in jemalloc
+   Helgrind:Race
+   fun:atomic_*
+   ...
+   fun:je_*
+   ...
+}
+
+{
+   False-positive ConflictingAccess in tbbmalloc
+   Helgrind:Race
+   ...
+   fun:tbb_pool_finalize
+   ...
+}
diff --git a/test/supp/helgrind-umf_test-scalable_coarse_devdax.supp b/test/supp/helgrind-test_scalable_coarse_devdax.supp
similarity index 100%
rename from test/supp/helgrind-umf_test-scalable_coarse_devdax.supp
rename to test/supp/helgrind-test_scalable_coarse_devdax.supp
diff --git a/test/supp/helgrind-umf_test-scalable_coarse_file.supp b/test/supp/helgrind-test_scalable_coarse_file.supp
similarity index 100%
rename from test/supp/helgrind-umf_test-scalable_coarse_file.supp
rename to test/supp/helgrind-test_scalable_coarse_file.supp
diff --git a/test/supp/helgrind-umf_test-scalable_pool.supp b/test/supp/helgrind-test_scalable_pool.supp
similarity index 100%
rename from test/supp/helgrind-umf_test-scalable_pool.supp
rename to test/supp/helgrind-test_scalable_pool.supp
diff --git a/test/supp/helgrind-umf_test-disjointCoarseMallocPool.supp b/test/supp/helgrind-umf_test-disjointCoarseMallocPool.supp
deleted file mode 100644
index 2f669eb311..0000000000
--- a/test/supp/helgrind-umf_test-disjointCoarseMallocPool.supp
+++ /dev/null
@@ -1,24 +0,0 @@
-{
-   Incompatibility with helgrind's implementation (pthread_mutex_lock with a pthread_rwlock_t* argument)
-   Helgrind:Misc
-   obj:*vgpreload_helgrind-amd64-linux.so
-   fun:_ZL20__gthread_mutex_lockP15pthread_mutex_t
-   ...
-}
-
-{
-   Incompatibility with helgrind's implementation (pthread_mutex_unlock with a pthread_rwlock_t* argument)
-   Helgrind:Misc
-   obj:*vgpreload_helgrind-amd64-linux.so
-   fun:_ZL22__gthread_mutex_unlockP15pthread_mutex_t
-   ...
-}
-
-{
-   Incompatibility with helgrind's implementation (lock order "0xA before 0xB" violated)
-   Helgrind:LockOrder
-   obj:*vgpreload_helgrind-amd64-linux.so
-   fun:_ZStL23__glibcxx_rwlock_wrlockP16pthread_rwlock_t
-   fun:_ZNSt22__shared_mutex_pthread4lockEv
-   ...
-}
diff --git a/test/supp/helgrind-umf_test-ipc.supp b/test/supp/helgrind-umf_test-ipc.supp
deleted file mode 100644
index e46140c197..0000000000
--- a/test/supp/helgrind-umf_test-ipc.supp
+++ /dev/null
@@ -1,16 +0,0 @@
-{
-   False-positive race in critnib_insert (lack of instrumentation)
-   Helgrind:Race
-   fun:store
-   fun:critnib_insert
-   ...
-}
-
-{
-   False-positive race in critnib_find (lack of instrumentation)
-   Helgrind:Race
-   fun:find_predecessor
-   fun:find_le
-   fun:critnib_find
-   ...
-}
diff --git a/test/supp/helgrind-umf_test-jemalloc_coarse_devdax.supp b/test/supp/helgrind-umf_test-jemalloc_coarse_devdax.supp
deleted file mode 100644
index 18774f387c..0000000000
--- a/test/supp/helgrind-umf_test-jemalloc_coarse_devdax.supp
+++ /dev/null
@@ -1,34 +0,0 @@
-{
-   False-positive Race in libjemalloc.so
-   Helgrind:Race
-   obj:*/libjemalloc.so*
-   ...
-   fun:mallocx
-   ...
-}
-
-{
-   False-positive Race in libjemalloc.so
-   Helgrind:Race
-   obj:*/libjemalloc.so*
-   ...
-   fun:op_free
-   ...
-}
-
-{
-   False-positive Race in libjemalloc.so
-   Helgrind:Race
-   obj:*/libjemalloc.so*
-   ...
-   fun:__nptl_deallocate_tsd
-   ...
-}
-
-{
-   False-positive Race in critnib_insert
-   Helgrind:Race
-   fun:store
-   fun:critnib_insert
-   ...
-}
diff --git a/test/supp/helgrind-umf_test-jemalloc_coarse_file.supp b/test/supp/helgrind-umf_test-jemalloc_coarse_file.supp
deleted file mode 100644
index 18774f387c..0000000000
--- a/test/supp/helgrind-umf_test-jemalloc_coarse_file.supp
+++ /dev/null
@@ -1,34 +0,0 @@
-{
-   False-positive Race in libjemalloc.so
-   Helgrind:Race
-   obj:*/libjemalloc.so*
-   ...
-   fun:mallocx
-   ...
-}
-
-{
-   False-positive Race in libjemalloc.so
-   Helgrind:Race
-   obj:*/libjemalloc.so*
-   ...
-   fun:op_free
-   ...
-}
-
-{
-   False-positive Race in libjemalloc.so
-   Helgrind:Race
-   obj:*/libjemalloc.so*
-   ...
-   fun:__nptl_deallocate_tsd
-   ...
-}
-
-{
-   False-positive Race in critnib_insert
-   Helgrind:Race
-   fun:store
-   fun:critnib_insert
-   ...
-}
diff --git a/test/supp/helgrind-umf_test-jemalloc_pool.supp b/test/supp/helgrind-umf_test-jemalloc_pool.supp
deleted file mode 100644
index 8068b023dc..0000000000
--- a/test/supp/helgrind-umf_test-jemalloc_pool.supp
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-   Race in libjemalloc.so  - internal issue of libjemalloc
-   Helgrind:Race
-   obj:*libjemalloc.so*
-   ...
-}
diff --git a/test/supp/helgrind-umf_test-provider_devdax_memory_ipc.supp b/test/supp/helgrind-umf_test-provider_devdax_memory_ipc.supp
deleted file mode 100644
index 4fcd2786cf..0000000000
--- a/test/supp/helgrind-umf_test-provider_devdax_memory_ipc.supp
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-   [false-positive] Double check locking pattern in trackingOpenIpcHandle
-   Helgrind:Race
-   fun:trackingOpenIpcHandle
-   fun:umfMemoryProviderOpenIPCHandle
-   fun:umfOpenIPCHandle
-   ...
-}
diff --git a/test/supp/helgrind-umf_test-provider_file_memory_ipc.supp b/test/supp/helgrind-umf_test-provider_file_memory_ipc.supp
deleted file mode 100644
index 4194f48479..0000000000
--- a/test/supp/helgrind-umf_test-provider_file_memory_ipc.supp
+++ /dev/null
@@ -1,25 +0,0 @@
-{
-   [false-positive] Double check locking pattern in trackingOpenIpcHandle
-   Helgrind:Race
-   fun:trackingOpenIpcHandle
-   fun:umfMemoryProviderOpenIPCHandle
-   fun:umfOpenIPCHandle
-   ...
-}
-
-{
-   False-positive race in critnib_insert (lack of instrumentation)
-   Helgrind:Race
-   fun:store
-   fun:critnib_insert
-   ...
-}
-
-{
-   False-positive race in critnib_find (lack of instrumentation)
-   Helgrind:Race
-   fun:find_predecessor
-   fun:find_le
-   fun:critnib_find
-   ...
-}
diff --git a/test/supp/helgrind-umf_test-provider_os_memory.supp b/test/supp/helgrind-umf_test-provider_os_memory.supp
deleted file mode 100644
index 4fcd2786cf..0000000000
--- a/test/supp/helgrind-umf_test-provider_os_memory.supp
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-   [false-positive] Double check locking pattern in trackingOpenIpcHandle
-   Helgrind:Race
-   fun:trackingOpenIpcHandle
-   fun:umfMemoryProviderOpenIPCHandle
-   fun:umfOpenIPCHandle
-   ...
-}
diff --git a/test/supp/memcheck-test_jemalloc_coarse_devdax.supp b/test/supp/memcheck-test_jemalloc_coarse_devdax.supp
new file mode 100644
index 0000000000..f719032779
--- /dev/null
+++ b/test/supp/memcheck-test_jemalloc_coarse_devdax.supp
@@ -0,0 +1,7 @@
+{
+   False-positive invalid write of size 8
+   Memcheck:Addr8
+   ...
+   fun:je_*
+   ...
+}
diff --git a/test/supp/memcheck-test_jemalloc_coarse_file.supp b/test/supp/memcheck-test_jemalloc_coarse_file.supp
new file mode 100644
index 0000000000..f719032779
--- /dev/null
+++ b/test/supp/memcheck-test_jemalloc_coarse_file.supp
@@ -0,0 +1,7 @@
+{
+   False-positive invalid write of size 8
+   Memcheck:Addr8
+   ...
+   fun:je_*
+   ...
+}
diff --git a/test/supp/memcheck-umf_test-jemalloc_pool.supp b/test/supp/memcheck-test_jemalloc_pool.supp
similarity index 100%
rename from test/supp/memcheck-umf_test-jemalloc_pool.supp
rename to test/supp/memcheck-test_jemalloc_pool.supp
diff --git a/test/supp/memcheck-umf_test-scalable_pool.supp b/test/supp/memcheck-test_scalable_pool.supp
similarity index 100%
rename from test/supp/memcheck-umf_test-scalable_pool.supp
rename to test/supp/memcheck-test_scalable_pool.supp
diff --git a/test/test_base_alloc_linear.cpp b/test/test_base_alloc_linear.cpp
index 3f8371d8d7..07c8cd979a 100644
--- a/test/test_base_alloc_linear.cpp
+++ b/test/test_base_alloc_linear.cpp
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -40,11 +40,11 @@ TEST_F(test, baseAllocLinearPoolContainsPointer) {
     ASSERT_NE(ptr, nullptr);
     memset(ptr, 0, size);
     // assert pool contains pointer ptr
-    ASSERT_NE(umf_ba_linear_pool_contains_pointer(pool.get(), ptr), 0);
+    ASSERT_NE(umf_ba_linear_pool_contains_pointer(pool.get(), ptr), (size_t)0);
 
     // assert pool does NOT contain pointer 0x0123
     ASSERT_EQ(umf_ba_linear_pool_contains_pointer(pool.get(), (void *)0x0123),
-              0);
+              (size_t)0);
 
     umf_ba_linear_free(pool.get(), ptr);
 }
diff --git a/test/test_init_teardown.c b/test/test_init_teardown.c
index e6141c135c..14409bbfc9 100644
--- a/test/test_init_teardown.c
+++ b/test/test_init_teardown.c
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -18,7 +18,7 @@ typedef int (*umfMemoryProviderCreateFromMemspace_t)(void *hMemspace,
                                                      void **hPool);
 typedef int (*umfPoolCreate_t)(void *ops, void *provider, void *params,
                                uint32_t flags, void **hPool);
-typedef void (*umfDestroy_t)(void *handle);
+typedef int (*umfDestroy_t)(void *handle);
 typedef void (*umfVoidVoid_t)(void);
 typedef void *(*umfGetPtr_t)(void);
 
diff --git a/test/test_installation.py b/test/test_installation.py
index 49a382969c..cba8a4fb3e 100644
--- a/test/test_installation.py
+++ b/test/test_installation.py
@@ -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
@@ -28,7 +28,8 @@ class UmfInstaller:
     proxy (bool): Determines whether the proxy library should be built together with the UMF library
     pools (List[str]): A list of enabled pools during the UMF compilation
     umf_version (Version): UMF version currently being built and installed
-    match_list (List[str]): A list of relative paths of files that should be installed
+    umfd_lib (bool): Determines if the UMF was built with the umfd library
+    hwloc (bool): Determines if hwloc is installed and should be checked
     """
 
     def __init__(
@@ -41,6 +42,8 @@ def __init__(
         proxy: bool,
         pools: List[str],
         umf_version: Version,
+        umfd_lib: bool,
+        hwloc: bool,
     ):
         self.workspace_dir = workspace_dir
         self.build_dir = build_dir
@@ -50,6 +53,8 @@ def __init__(
         self.proxy = proxy
         self.pools = pools
         self.umf_version = umf_version
+        self.umfd_lib = umfd_lib
+        self.hwloc = hwloc
         self.match_list = self._create_match_list()
 
     def _create_match_list(self) -> List[str]:
@@ -78,6 +83,8 @@ def _create_match_list(self) -> List[str]:
             bin.append("bin")
             if self.shared_library:
                 bin.append("bin/umf.dll")
+                if self.umfd_lib:
+                    bin.append("bin/umfd.dll")
             if self.proxy:
                 bin.append("bin/umf_proxy.dll")
 
@@ -97,10 +104,15 @@ def _create_match_list(self) -> List[str]:
             f"lib/cmake/umf/umf-targets-{self.build_type}.cmake",
             "lib/cmake/umf/umf-targets.cmake",
         ]
+
         for pool in self.pools:
             lib.append(f"lib/{lib_prefix}{pool}.{lib_ext_static}")
+        if platform.system() == "Windows" and self.hwloc:
+            lib.append(f"lib/{lib_prefix}hwloc.{lib_ext_static}")
         if self.shared_library:
             lib.append(f"lib/{lib_prefix}umf.{lib_ext_shared}")
+            if platform.system() == "Windows" and self.umfd_lib:
+                lib.append(f"lib/{lib_prefix}umfd.{lib_ext_shared}")
 
             if platform.system() == "Linux":
                 lib.append(
@@ -113,7 +125,12 @@ 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}")
 
         if self.proxy:
             lib.append(f"lib/{lib_prefix}umf_proxy.{lib_ext_shared}")
@@ -127,7 +144,6 @@ def _create_match_list(self) -> List[str]:
                     f"lib/{lib_prefix}umf_proxy.{self.umf_version.major}.{lib_ext_shared}"
                 )
 
-        share = []
         share = [
             "share",
             "share/doc",
@@ -168,8 +184,27 @@ def install_umf(self) -> None:
                     f"Error: Installation directory '{self.install_dir}' is not empty"
                 )
 
-        install_cmd = f"cmake --install {self.build_dir} --config {self.build_type.title()} --prefix {self.install_dir}"
+        # cmake <= 3.14 does not support --prefix option
         try:
+            cmake_ver_cmd = "cmake --version"
+            cmake_ver = subprocess.run(
+                cmake_ver_cmd.split(), capture_output=True, text=True
+            )  # nosec B603
+            cmake_ver = cmake_ver.stdout.splitlines()[0].split(" ")[2]
+            cmake_ver = Version(cmake_ver)
+            print(f"CMake version: {cmake_ver}", flush=True)
+        except subprocess.CalledProcessError:
+            sys.exit(f"Error: CMake check version command '{cmake_ver_cmd}' failed")
+
+        if cmake_ver <= Version("3.14"):  # both Linux and Windows
+            install_cmd = f"cmake --build {self.build_dir} --config {self.build_type.title()} --target install"
+        elif platform.system() == "Windows":
+            install_cmd = f"cmake --install {self.build_dir} --config {self.build_type.title()} --prefix {self.install_dir}"
+        else:
+            install_cmd = f"cmake --build {self.build_dir} --config {self.build_type.title()} --target install"
+
+        try:
+            print(f"Running command: {install_cmd}", flush=True)
             subprocess.run(install_cmd.split()).check_returncode()  # nosec B603
         except subprocess.CalledProcessError:
             sys.exit(f"Error: UMF installation command '{install_cmd}' failed")
@@ -279,19 +314,19 @@ def parse_arguments(self) -> argparse.Namespace:
             help="Add this argument if the proxy library should be built together with the UMF library",
         )
         self.parser.add_argument(
-            "--disjoint-pool",
-            action="store_true",
-            help="Add this argument if the UMF was built with Disjoint Pool enabled",
+            "--umf-version",
+            action="store",
+            help="Current version of the UMF, e.g. 1.0.0",
         )
         self.parser.add_argument(
-            "--jemalloc-pool",
+            "--umfd-lib",
             action="store_true",
-            help="Add this argument if the UMF was built with Jemalloc Pool enabled",
+            help="Add this argument if the UMF was built with the umfd library",
         )
         self.parser.add_argument(
-            "--umf-version",
-            action="store",
-            help="Current version of the UMF, e.g. 1.0.0",
+            "--hwloc",
+            action="store_true",
+            help="Add this argument if hwloc is installed and should be checked",
         )
         return self.parser.parse_args()
 
@@ -304,10 +339,6 @@ def run(self) -> None:
         build_dir = Path(workspace_dir, self.args.build_dir)
         install_dir = Path(workspace_dir, self.args.install_dir)
         pools = []
-        if self.args.disjoint_pool:
-            pools.append("disjoint_pool")
-        if self.args.jemalloc_pool:
-            pools.append("jemalloc_pool")
 
         umf_version = Version(self.args.umf_version)
 
@@ -320,6 +351,8 @@ def run(self) -> None:
             self.args.proxy,
             pools,
             umf_version,
+            self.args.umfd_lib,
+            self.args.hwloc,
         )
 
         print("Installation test - BEGIN", flush=True)
diff --git a/test/test_pool_null_params.cpp b/test/test_pool_null_params.cpp
new file mode 100644
index 0000000000..0952e029af
--- /dev/null
+++ b/test/test_pool_null_params.cpp
@@ -0,0 +1,76 @@
+/*
+ * 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 <gtest/gtest.h>
+
+#include <umf/memory_pool.h>
+#include <umf/memory_provider.h>
+#include <umf/pools/pool_disjoint.h>
+#include <umf/pools/pool_jemalloc.h>
+#include <umf/pools/pool_proxy.h>
+#include <umf/pools/pool_scalable.h>
+
+#include "provider_null.h"
+
+// Dummy provider implementation for testing
+static umf_memory_provider_ops_t dummy_provider_ops = UMF_NULL_PROVIDER_OPS;
+
+using PoolOpsFn = const umf_memory_pool_ops_t *(*)();
+
+class PoolNullParamsTest : public ::testing::TestWithParam<PoolOpsFn> {
+  protected:
+    umf_memory_provider_handle_t provider = NULL;
+    void SetUp() override {
+        ASSERT_EQ(umfMemoryProviderCreate(&dummy_provider_ops, NULL, &provider),
+                  UMF_RESULT_SUCCESS);
+    }
+    void TearDown() override {
+        if (provider) {
+            umfMemoryProviderDestroy(provider);
+        }
+    }
+};
+
+TEST_P(PoolNullParamsTest, CreateWithNullParams) {
+    umf_memory_pool_handle_t pool;
+    PoolOpsFn opsFn = GetParam();
+    umf_result_t res = umfPoolCreate(opsFn(), provider, NULL, 0, &pool);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    umfPoolDestroy(pool);
+}
+
+namespace {
+const PoolOpsFn poolOpsList[] = {
+#if defined(UMF_POOL_SCALABLE_ENABLED)
+    &umfScalablePoolOps,
+#endif
+#if defined(UMF_POOL_JEMALLOC_ENABLED)
+    &umfJemallocPoolOps,
+#endif
+#if defined(UMF_POOL_PROXY_ENABLED)
+    &umfProxyPoolOps
+#endif
+        &umfDisjointPoolOps};
+
+static const char *poolOpsNames[] = {
+#if defined(UMF_POOL_SCALABLE_ENABLED)
+    "umfScalablePoolOps",
+#endif
+#if defined(UMF_POOL_JEMALLOC_ENABLED)
+    "umfJemallocPoolOps",
+#endif
+#if defined(UMF_POOL_PROXY_ENABLED)
+    "umfProxyPoolOps",
+#endif
+    "umfDisjointPoolOps"};
+} // namespace
+
+INSTANTIATE_TEST_SUITE_P(poolNullParamsTest, PoolNullParamsTest,
+                         ::testing::ValuesIn(poolOpsList),
+                         ([](auto const &info) -> std::string {
+                             return poolOpsNames[info.index];
+                         }));
diff --git a/test/test_proxy_lib_size_threshold.cpp b/test/test_proxy_lib_size_threshold.cpp
index fac1c516b0..69394e787b 100644
--- a/test/test_proxy_lib_size_threshold.cpp
+++ b/test/test_proxy_lib_size_threshold.cpp
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -70,8 +70,13 @@ TEST_F(test, proxyLib_size_threshold_aligned_alloc) {
     ASSERT_EQ((int)(IS_ALIGNED((uintptr_t)ptr_LT, ALIGN_1024)), 1);
     ASSERT_EQ((int)(IS_ALIGNED((uintptr_t)ptr_EQ, ALIGN_1024)), 1);
 
-    ASSERT_EQ(umfPoolByPtr(ptr_LT), nullptr);
-    ASSERT_NE(umfPoolByPtr(ptr_EQ), nullptr);
+    umf_memory_pool_handle_t poolTmp = nullptr;
+    umf_result_t ret_pool = umfPoolByPtr(ptr_LT, &poolTmp);
+    ASSERT_NE(ret_pool, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(poolTmp, nullptr);
+    ret_pool = umfPoolByPtr(ptr_EQ, &poolTmp);
+    ASSERT_EQ(ret_pool, UMF_RESULT_SUCCESS);
+    ASSERT_NE(poolTmp, nullptr);
 
 #ifdef _WIN32
     _aligned_free(ptr_LT);
@@ -89,8 +94,13 @@ TEST_F(test, proxyLib_size_threshold_malloc) {
     ASSERT_NE(ptr_LT, nullptr);
     ASSERT_NE(ptr_EQ, nullptr);
 
-    ASSERT_EQ(umfPoolByPtr(ptr_LT), nullptr);
-    ASSERT_NE(umfPoolByPtr(ptr_EQ), nullptr);
+    umf_memory_pool_handle_t poolTmp = nullptr;
+    umf_result_t ret_pool = umfPoolByPtr(ptr_LT, &poolTmp);
+    ASSERT_NE(ret_pool, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(poolTmp, nullptr);
+    ret_pool = umfPoolByPtr(ptr_EQ, &poolTmp);
+    ASSERT_EQ(ret_pool, UMF_RESULT_SUCCESS);
+    ASSERT_NE(poolTmp, nullptr);
 
     ::free(ptr_LT);
     ::free(ptr_EQ);
@@ -103,8 +113,13 @@ TEST_F(test, proxyLib_size_threshold_calloc) {
     ASSERT_NE(ptr_LT, nullptr);
     ASSERT_NE(ptr_EQ, nullptr);
 
-    ASSERT_EQ(umfPoolByPtr(ptr_LT), nullptr);
-    ASSERT_NE(umfPoolByPtr(ptr_EQ), nullptr);
+    umf_memory_pool_handle_t poolTmp = nullptr;
+    umf_result_t ret_pool = umfPoolByPtr(ptr_LT, &poolTmp);
+    ASSERT_NE(ret_pool, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(poolTmp, nullptr);
+    ret_pool = umfPoolByPtr(ptr_EQ, &poolTmp);
+    ASSERT_EQ(ret_pool, UMF_RESULT_SUCCESS);
+    ASSERT_NE(poolTmp, nullptr);
 
     ::free(ptr_LT);
     ::free(ptr_EQ);
@@ -123,8 +138,13 @@ TEST_F(test, proxyLib_size_threshold_realloc_up) {
     ASSERT_NE(ptr_LT_r, nullptr);
     ASSERT_NE(ptr_EQ_r, nullptr);
 
-    ASSERT_EQ(umfPoolByPtr(ptr_LT_r), nullptr);
-    ASSERT_NE(umfPoolByPtr(ptr_EQ_r), nullptr);
+    umf_memory_pool_handle_t poolTmp = nullptr;
+    umf_result_t ret_pool = umfPoolByPtr(ptr_LT_r, &poolTmp);
+    ASSERT_NE(ret_pool, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(poolTmp, nullptr);
+    ret_pool = umfPoolByPtr(ptr_EQ_r, &poolTmp);
+    ASSERT_EQ(ret_pool, UMF_RESULT_SUCCESS);
+    ASSERT_NE(poolTmp, nullptr);
 
     ::free(ptr_LT_r);
     ::free(ptr_EQ_r);
@@ -143,8 +163,13 @@ TEST_F(test, proxyLib_size_threshold_realloc_down) {
     ASSERT_NE(ptr_LT_r, nullptr);
     ASSERT_NE(ptr_EQ_r, nullptr);
 
-    ASSERT_EQ(umfPoolByPtr(ptr_LT_r), nullptr);
-    ASSERT_NE(umfPoolByPtr(ptr_EQ_r), nullptr);
+    umf_memory_pool_handle_t poolTmp = nullptr;
+    umf_result_t ret_pool = umfPoolByPtr(ptr_LT_r, &poolTmp);
+    ASSERT_NE(ret_pool, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(poolTmp, nullptr);
+    ret_pool = umfPoolByPtr(ptr_EQ_r, &poolTmp);
+    ASSERT_EQ(ret_pool, UMF_RESULT_SUCCESS);
+    ASSERT_NE(poolTmp, nullptr);
 
     ::free(ptr_LT_r);
     ::free(ptr_EQ_r);
diff --git a/test/test_valgrind.sh b/test/test_valgrind.sh
index 9f84cf0d32..fa2610dd37 100755
--- a/test/test_valgrind.sh
+++ b/test/test_valgrind.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
-# 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
 
@@ -8,11 +8,17 @@ set -e
 WORKSPACE=$1
 BUILD_DIR=$2
 TOOL=$3
+TESTS=$4
 
 function print_usage() {
-	echo "$(basename $0) - run all UMF tests under a valgrind tool (memcheck, drd or helgrind)"
-	echo "This script looks for './test/umf_test-*' test executables in the UMF build directory."
-	echo "Usage: $(basename $0) <workspace_dir> <build_dir> <memcheck|drd|helgrind>"
+	echo "$(basename $0) - run UMF tests and examples under a valgrind tool (memcheck, drd, drdshort or helgrind)"
+	echo "                 drdshort - same as drd, but the longest lasting tests are excluded"
+	echo "Usage: $(basename $0) <workspace_dir> <build_dir> <memcheck|drd|drdshort|helgrind> [tests_examples]"
+	echo "Where:"
+	echo
+	echo "tests_examples - (optional) list of tests or examples to be run (paths relative to the <build_dir> build directory)."
+	echo "                 If it is empty, all tests (./test/test_*) and examples (./examples/umf_example_*)"
+	echo "                 found in <build_dir> will be run."
 }
 
 if ! valgrind --version > /dev/null; then
@@ -32,12 +38,14 @@ if [ ! -f $WORKSPACE/README.md ]; then
 	exit 1
 fi
 
-if [ $(ls -1 ${BUILD_DIR}/test/umf_test-* 2>/dev/null | wc -l) -eq 0 ]; then
-	echo -e "error: UMF tests ./test/umf_test-* not found in the build directory: ${BUILD_DIR}\n"
+if [ $(ls -1 ${BUILD_DIR}/test/test_* 2>/dev/null | wc -l) -eq 0 ]; then
+	echo -e "error: UMF tests ./test/test_* not found in the build directory: ${BUILD_DIR}\n"
 	print_usage
 	exit 1
 fi
 
+EXCLUDE_LONGEST_TESTS=0
+
 case $TOOL in
 memcheck)
 	OPTION="--leak-check=full"
@@ -45,6 +53,11 @@ memcheck)
 drd)
 	OPTION="--tool=drd"
 	;;
+drdshort)
+	OPTION="--tool=drd"
+	TOOL="drd"
+	EXCLUDE_LONGEST_TESTS=1
+	;;
 helgrind)
 	OPTION="--tool=helgrind"
 	;;
@@ -58,33 +71,44 @@ esac
 WORKSPACE=$(realpath $WORKSPACE)
 BUILD_DIR=$(realpath $BUILD_DIR)
 
-cd ${BUILD_DIR}/test/
+cd ${BUILD_DIR}
 mkdir -p cpuid
 
 echo "Gathering data for hwloc so it can be run under valgrind:"
-hwloc-gather-cpuid ./cpuid
+hwloc-gather-cpuid ./cpuid >/dev/null
 
 echo
 echo "Working directory: $(pwd)"
 echo "Running: \"valgrind $OPTION\" for the following tests:"
 
 ANY_TEST_FAILED=0
-rm -f umf_test-*.log umf_test-*.err
+PATH_TESTS="./test/test_*"
+PATH_EXAMPLES="./examples/umf_example_*"
 
-for test in $(ls -1 umf_test-*); do
+rm -f ${PATH_TESTS}.log ${PATH_TESTS}.err ${PATH_EXAMPLES}.log ${PATH_EXAMPLES}.err
+
+[ "$TESTS" = "" ] && TESTS=$(ls -1 ${PATH_TESTS} ${PATH_EXAMPLES})
+
+for test in $TESTS; do
+	if [ ! -f $test ]; then
+		echo
+		echo "error: the $test (${BUILD_DIR}/$test) file does not exist"
+		exit 1
+	fi
 	[ ! -x $test ] && continue
 	echo "$test - starting ..."
 	echo -n "$test "
 	LOG=${test}.log
 	ERR=${test}.err
-	SUP="${WORKSPACE}/test/supp/${TOOL}-${test}.supp"
+	NAME=$(basename $test)
+	SUP="${WORKSPACE}/test/supp/${TOOL}-${NAME}.supp"
 	OPT_SUP=""
-	[ -f ${SUP} ] && OPT_SUP="--suppressions=${SUP}" && echo -n "(${TOOL}-${test}.supp) "
+	[ -f ${SUP} ] && OPT_SUP="--suppressions=${SUP}" && echo -n "($(basename ${SUP})) "
 
 	# skip tests incompatible with valgrind
 	FILTER=""
 	case $test in
-	umf_test-disjointPool)
+	./test/test_disjointPool)
 		if [ "$TOOL" = "helgrind" ]; then
 			# skip because of the assert in helgrind:
 			# Helgrind: hg_main.c:308 (lockN_acquire_reader): Assertion 'lk->kind == LK_rdwr' failed.
@@ -92,53 +116,82 @@ for test in $(ls -1 umf_test-*); do
 			continue;
 		fi
 		;;
-	umf_test-ipc_os_prov_*)
+	./test/test_ipc_os_prov_*)
 		echo "- SKIPPED"
 		continue; # skip testing helper binaries used by the ipc_os_prov_* tests
 		;;
-	umf_test-ipc_devdax_prov_*)
+	./test/test_ipc_devdax_prov_*)
 		echo "- SKIPPED"
 		continue; # skip testing helper binaries used by the ipc_devdax_prov_* tests
 		;;
-	umf_test-ipc_file_prov_*)
+	./test/test_ipc_file_prov_*)
 		echo "- SKIPPED"
 		continue; # skip testing helper binaries used by the ipc_file_prov_* tests
 		;;
-	umf_test-memspace_host_all)
+	./test/test_ctl_env_app)
+		continue; # this is not a standalone test
+		;;
+	./test/test_memspace_host_all)
 		FILTER='--gtest_filter="-*allocsSpreadAcrossAllNumaNodes"'
 		;;
-	umf_test-provider_os_memory)
+	./test/test_provider_os_memory)
 		FILTER='--gtest_filter="-osProviderTest/umfIpcTest*"'
 		;;
-	umf_test-provider_os_memory_config)
+	./test/test_provider_os_memory_config)
 		FILTER='--gtest_filter="-*protection_flag_none:*protection_flag_read:*providerConfigTestNumaMode*"'
 		;;
-	umf_test-memspace_highest_capacity)
+	./test/test_memspace_highest_capacity)
 		FILTER='--gtest_filter="-*highestCapacityVerify*"'
 		;;
-	umf_test-provider_os_memory_multiple_numa_nodes)
+	./test/test_pool_residency)
+		echo "- SKIPPED"
+		continue; # TODO: set UMF_ZE_LOADER_LIB_NAME as ctest does
+		;;
+	./test/test_provider_os_memory_multiple_numa_nodes)
 		FILTER='--gtest_filter="-testNuma.checkModeInterleave*:testNumaNodesAllocations/testNumaOnEachNode.checkNumaNodesAllocations*:testNumaNodesAllocations/testNumaOnEachNode.checkModePreferred*:testNumaNodesAllocations/testNumaOnEachNode.checkModeInterleaveSingleNode*:testNumaNodesAllocationsAllCpus/testNumaOnEachCpu.checkModePreferredEmptyNodeset*:testNumaNodesAllocationsAllCpus/testNumaOnEachCpu.checkModeLocal*"'
 		;;
-	umf_test-memspace_highest_bandwidth)
+	./test/test_provider_level_zero_residency)
+		echo "- SKIPPED"
+		continue; # TODO: set UMF_ZE_LOADER_LIB_NAME as ctest does
+		;;
+	./test/test_memspace_highest_bandwidth)
 		FILTER='--gtest_filter="-*allocLocalMt*"'
 		;;
-	umf_test-memspace_lowest_latency)
+	./test/test_memspace_lowest_latency)
 		FILTER='--gtest_filter="-*allocLocalMt*"'
 		;;
-	umf_test-memoryPool)
+	./test/test_memoryPool)
 		FILTER='--gtest_filter="-*allocMaxSize*"'
 		;;
+	./examples/umf_example_ipc_ipcapi_*)
+		echo "- SKIPPED"
+		continue; # skip testing helper binaries used by the umf_example_ipc_ipcapi_* examples
+		;;
 	esac
 
+	if [ $EXCLUDE_LONGEST_TESTS -eq 1 ]; then
+		# skip the longest tests
+		case $test in
+		./test/test_jemalloc_pool|./test/test_jemalloc_coarse_file|./test/test_scalable_pool|./test/test_ipc_max_opened_limit)
+			echo "- SKIPPED (VERY LONG TEST)"
+			continue;
+			;;
+		esac
+	fi
+
 	[ "$FILTER" != "" ] && echo -n "($FILTER) "
 
 	LAST_TEST_FAILED=0
-
-	if ! HWLOC_CPUID_PATH=./cpuid valgrind $OPTION $OPT_SUP --gen-suppressions=all ./$test $FILTER >$LOG 2>&1; then
+	set +e
+	HWLOC_CPUID_PATH=./cpuid valgrind $OPTION $OPT_SUP --gen-suppressions=all $test $FILTER >$LOG 2>&1
+	RET=$?
+	set -e
+	# 125 is the return code when the test is skipped
+	if [ $RET -ne 0 -a $RET -ne 125 ]; then
 		LAST_TEST_FAILED=1
 		ANY_TEST_FAILED=1
-		echo "(valgrind FAILED) "
-		echo "Command: HWLOC_CPUID_PATH=./cpuid valgrind $OPTION $OPT_SUP --gen-suppressions=all ./$test $FILTER >$LOG 2>&1"
+		echo "(valgrind FAILED RV=$RET) "
+		echo "Command: HWLOC_CPUID_PATH=./cpuid valgrind $OPTION $OPT_SUP --gen-suppressions=all $test $FILTER >$LOG 2>&1"
 		echo "Output:"
 		cat $LOG
 		echo "====================="
@@ -147,7 +200,7 @@ for test in $(ls -1 umf_test-*); do
 	# grep for "ERROR SUMMARY" with errors (there can be many lines with "ERROR SUMMARY")
 	grep -e "ERROR SUMMARY:" $LOG | grep -v -e "ERROR SUMMARY: 0 errors from 0 contexts" > $ERR || true
 	if [ $LAST_TEST_FAILED -eq 0 -a $(cat $ERR | wc -l) -eq 0 ]; then
-		echo "- OK"
+		[ $RET -eq 0 ] && echo "- OK" || echo "- SKIPPED"
 		rm -f $LOG $ERR
 	else
 		echo "- FAILED!"
@@ -164,11 +217,33 @@ echo
 echo "======================================================================"
 echo
 
-for log in $(ls -1 umf_test-*.log); do
+LOG_FILES=""
+NT=$(ls -1 ${PATH_TESTS}.log 2>/dev/null | wc -l)
+if [ $NT -gt 0 ]; then
+	LOG_FILES="$LOG_FILES $(ls -1 ${PATH_TESTS}.log | xargs)"
+fi
+NE=$(ls -1 ${PATH_EXAMPLES}.log 2>/dev/null | wc -l)
+if [ $NE -gt 0 ]; then
+	LOG_FILES="$LOG_FILES $(ls -1 ${PATH_EXAMPLES}.log | xargs)"
+fi
+if [ $(($NT + $NE)) -eq 0 ]; then
+	echo
+	echo "FATAL ERROR: no log files found, but number of failed tests equals $ANY_TEST_FAILED!"
+	echo
+	exit 1
+fi
+
+for log in $LOG_FILES; do
 	echo ">>>>>>> LOG $log"
 	cat $log
 	echo
 	echo
 done
 
+if [ $(($NT + $NE)) -ne $ANY_TEST_FAILED ]; then
+	echo
+	echo "ERROR: incorrect number of log files: ANY_TEST_FAILED=$ANY_TEST_FAILED != ($NT + $NE)"
+	echo
+fi
+
 exit 1
diff --git a/src/cpp_helpers.hpp b/test/utils/cpp_helpers.hpp
similarity index 64%
rename from src/cpp_helpers.hpp
rename to test/utils/cpp_helpers.hpp
index 6316ccbc7e..1f8ffb4e7a 100644
--- a/src/cpp_helpers.hpp
+++ b/test/utils/cpp_helpers.hpp
@@ -1,19 +1,14 @@
 /*
  *
- * 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
  *
  */
 
-#ifndef UMF_HELPERS_HPP
-#define UMF_HELPERS_HPP 1
-
-#include <umf/memory_pool.h>
-#include <umf/memory_pool_ops.h>
-#include <umf/memory_provider.h>
-#include <umf/memory_provider_ops.h>
+#ifndef UMF_TEST_HELPERS_HPP
+#define UMF_TEST_HELPERS_HPP 1
 
 #include <array>
 #include <functional>
@@ -22,11 +17,17 @@
 #include <tuple>
 #include <utility>
 
-namespace umf {
+#include <umf/memory_pool.h>
+#include <umf/memory_pool_ops.h>
+#include <umf/memory_provider.h>
+#include <umf/memory_provider_ops.h>
+
+namespace umf_test {
 
 using pool_unique_handle_t =
     std::unique_ptr<umf_memory_pool_t,
                     std::function<void(umf_memory_pool_handle_t)>>;
+
 using provider_unique_handle_t =
     std::unique_ptr<umf_memory_provider_t,
                     std::function<void(umf_memory_provider_handle_t)>>;
@@ -34,6 +35,9 @@ using provider_unique_handle_t =
 #define UMF_ASSIGN_OP(ops, type, func, default_return)                         \
     ops.func = [](void *obj, auto... args) {                                   \
         try {                                                                  \
+            if (!obj) {                                                        \
+                return type().func(args...);                                   \
+            }                                                                  \
             return reinterpret_cast<type *>(obj)->func(args...);               \
         } catch (...) {                                                        \
             return default_return;                                             \
@@ -43,6 +47,9 @@ using provider_unique_handle_t =
 #define UMF_ASSIGN_OP_NORETURN(ops, type, func)                                \
     ops.func = [](void *obj, auto... args) {                                   \
         try {                                                                  \
+            if (!obj) {                                                        \
+                return type().func(args...);                                   \
+            }                                                                  \
             return reinterpret_cast<type *>(obj)->func(args...);               \
         } catch (...) {                                                        \
         }                                                                      \
@@ -67,37 +74,51 @@ umf_result_t initialize(T *obj, ArgsTuple &&args) {
 
 template <typename T> umf_memory_pool_ops_t poolOpsBase() {
     umf_memory_pool_ops_t ops{};
-    ops.version = UMF_VERSION_CURRENT;
-    ops.finalize = [](void *obj) { delete reinterpret_cast<T *>(obj); };
+    ops.version = UMF_POOL_OPS_VERSION_CURRENT;
+    ops.finalize = [](void *obj) {
+        delete reinterpret_cast<T *>(obj);
+        return UMF_RESULT_SUCCESS;
+    };
     UMF_ASSIGN_OP(ops, T, malloc, ((void *)nullptr));
     UMF_ASSIGN_OP(ops, T, calloc, ((void *)nullptr));
     UMF_ASSIGN_OP(ops, T, aligned_malloc, ((void *)nullptr));
     UMF_ASSIGN_OP(ops, T, realloc, ((void *)nullptr));
-    UMF_ASSIGN_OP(ops, T, malloc_usable_size, ((size_t)0));
-    UMF_ASSIGN_OP(ops, T, free, UMF_RESULT_SUCCESS);
+    UMF_ASSIGN_OP(ops, T, get_name, UMF_RESULT_ERROR_UNKNOWN);
+    UMF_ASSIGN_OP(ops, T, malloc_usable_size, UMF_RESULT_ERROR_UNKNOWN);
+    UMF_ASSIGN_OP(ops, T, free, UMF_RESULT_ERROR_UNKNOWN);
     UMF_ASSIGN_OP(ops, T, get_last_allocation_error, UMF_RESULT_ERROR_UNKNOWN);
+    UMF_ASSIGN_OP(ops, T, ext_ctl, UMF_RESULT_ERROR_INVALID_CTL_PATH);
+    UMF_ASSIGN_OP(ops, T, ext_trim_memory, UMF_RESULT_ERROR_UNKNOWN);
     return ops;
 }
 
 template <typename T> constexpr umf_memory_provider_ops_t providerOpsBase() {
     umf_memory_provider_ops_t ops{};
-    ops.version = UMF_VERSION_CURRENT;
-    ops.finalize = [](void *obj) { delete reinterpret_cast<T *>(obj); };
+    ops.version = UMF_PROVIDER_OPS_VERSION_CURRENT;
+    ops.finalize = [](void *obj) {
+        delete reinterpret_cast<T *>(obj);
+        return UMF_RESULT_SUCCESS;
+    };
     UMF_ASSIGN_OP(ops, T, alloc, UMF_RESULT_ERROR_UNKNOWN);
-    UMF_ASSIGN_OP(ops.ext, T, free, UMF_RESULT_ERROR_UNKNOWN);
-    UMF_ASSIGN_OP_NORETURN(ops, T, get_last_native_error);
+    UMF_ASSIGN_OP(ops, T, free, UMF_RESULT_ERROR_UNKNOWN);
+    UMF_ASSIGN_OP(ops, T, get_last_native_error, UMF_RESULT_ERROR_UNKNOWN);
     UMF_ASSIGN_OP(ops, T, get_recommended_page_size, UMF_RESULT_ERROR_UNKNOWN);
     UMF_ASSIGN_OP(ops, T, get_min_page_size, UMF_RESULT_ERROR_UNKNOWN);
-    UMF_ASSIGN_OP(ops, T, get_name, "");
-    UMF_ASSIGN_OP(ops.ext, T, purge_lazy, UMF_RESULT_ERROR_UNKNOWN);
-    UMF_ASSIGN_OP(ops.ext, T, purge_force, UMF_RESULT_ERROR_UNKNOWN);
-    UMF_ASSIGN_OP(ops.ext, T, allocation_merge, UMF_RESULT_ERROR_UNKNOWN);
-    UMF_ASSIGN_OP(ops.ext, T, allocation_split, UMF_RESULT_ERROR_UNKNOWN);
-    UMF_ASSIGN_OP(ops.ipc, T, get_ipc_handle_size, UMF_RESULT_ERROR_UNKNOWN);
-    UMF_ASSIGN_OP(ops.ipc, T, get_ipc_handle, UMF_RESULT_ERROR_UNKNOWN);
-    UMF_ASSIGN_OP(ops.ipc, T, put_ipc_handle, UMF_RESULT_ERROR_UNKNOWN);
-    UMF_ASSIGN_OP(ops.ipc, T, open_ipc_handle, UMF_RESULT_ERROR_UNKNOWN);
-    UMF_ASSIGN_OP(ops.ipc, T, close_ipc_handle, UMF_RESULT_ERROR_UNKNOWN);
+    UMF_ASSIGN_OP(ops, T, get_name, UMF_RESULT_ERROR_UNKNOWN);
+    UMF_ASSIGN_OP(ops, T, ext_purge_lazy, UMF_RESULT_ERROR_UNKNOWN);
+    UMF_ASSIGN_OP(ops, T, ext_purge_force, UMF_RESULT_ERROR_UNKNOWN);
+    UMF_ASSIGN_OP(ops, T, ext_allocation_merge, UMF_RESULT_ERROR_UNKNOWN);
+    UMF_ASSIGN_OP(ops, T, ext_allocation_split, UMF_RESULT_ERROR_UNKNOWN);
+    UMF_ASSIGN_OP(ops, T, ext_get_ipc_handle_size, UMF_RESULT_ERROR_UNKNOWN);
+    UMF_ASSIGN_OP(ops, T, ext_get_ipc_handle, UMF_RESULT_ERROR_UNKNOWN);
+    UMF_ASSIGN_OP(ops, T, ext_put_ipc_handle, UMF_RESULT_ERROR_UNKNOWN);
+    UMF_ASSIGN_OP(ops, T, ext_open_ipc_handle, UMF_RESULT_ERROR_UNKNOWN);
+    UMF_ASSIGN_OP(ops, T, ext_close_ipc_handle, UMF_RESULT_ERROR_UNKNOWN);
+    UMF_ASSIGN_OP(ops, T, ext_get_allocation_properties,
+                  UMF_RESULT_ERROR_UNKNOWN);
+    UMF_ASSIGN_OP(ops, T, ext_get_allocation_properties_size,
+                  UMF_RESULT_ERROR_UNKNOWN);
+    UMF_ASSIGN_OP(ops, T, ext_ctl, UMF_RESULT_ERROR_INVALID_CTL_PATH);
     return ops;
 }
 } // namespace detail
@@ -109,7 +130,7 @@ template <typename T, typename ParamType> umf_memory_pool_ops_t poolMakeCOps() {
     umf_memory_pool_ops_t ops = detail::poolOpsBase<T>();
 
     ops.initialize = [](umf_memory_provider_handle_t provider,
-                        [[maybe_unused]] void *params, void **obj) {
+                        [[maybe_unused]] const void *params, void **obj) {
         try {
             *obj = new T;
         } catch (...) {
@@ -123,7 +144,7 @@ template <typename T, typename ParamType> umf_memory_pool_ops_t poolMakeCOps() {
             return detail::initialize<T>(
                 reinterpret_cast<T *>(*obj),
                 std::make_tuple(provider,
-                                reinterpret_cast<ParamType *>(params)));
+                                reinterpret_cast<const ParamType *>(params)));
         }
     };
 
@@ -137,7 +158,7 @@ template <typename T, typename ParamType>
 constexpr umf_memory_provider_ops_t providerMakeCOps() {
     umf_memory_provider_ops_t ops = detail::providerOpsBase<T>();
 
-    ops.initialize = []([[maybe_unused]] void *params, void **obj) {
+    ops.initialize = []([[maybe_unused]] const void *params, void **obj) {
         try {
             *obj = new T;
         } catch (...) {
@@ -150,7 +171,7 @@ constexpr umf_memory_provider_ops_t providerMakeCOps() {
         } else {
             return detail::initialize<T>(
                 reinterpret_cast<T *>(*obj),
-                std::make_tuple(reinterpret_cast<ParamType *>(params)));
+                std::make_tuple(reinterpret_cast<const ParamType *>(params)));
         }
     };
 
@@ -162,6 +183,6 @@ template <typename Type> umf_result_t &getPoolLastStatusRef() {
     return last_status;
 }
 
-} // namespace umf
+} // namespace umf_test
 
-#endif /* UMF_HELPERS_HPP */
+#endif /* UMF_TEST_HELPERS_HPP */
diff --git a/test/utils/utils_log.cpp b/test/utils/utils_log.cpp
index cce61db585..3a3dd19fa7 100644
--- a/test/utils/utils_log.cpp
+++ b/test/utils/utils_log.cpp
@@ -1,8 +1,11 @@
-// 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
 
+#include <umf/experimental/ctl.h>
+
 #include "base.hpp"
+#include "ctl/ctl_internal.h"
 #include "test_helpers.h"
 
 #define MOCK_FILE_PTR (FILE *)0xBADBEEF
@@ -26,6 +29,14 @@ FILE *expected_stream = stderr;
 int expect_fput_count = 0;
 int fput_count = 0;
 
+// Some test of logging are disabled because log macros add filename and line
+// number to logs in developer mode, therefore check on exact log content fail.
+#ifdef UMF_DEVELOPER_MODE
+#define DISABLE_IN_DEVELOPER_MODE(TESTNAME) DISABLED_##TESTNAME
+#else
+#define DISABLE_IN_DEVELOPER_MODE(TESTNAME) TESTNAME
+#endif
+
 int mock_fputs(const char *s, FILE *stream) {
     fput_count++;
     if (!expected_message.empty()) {
@@ -93,7 +104,7 @@ int mock_strerror_windows(char *buff, size_t s, int errnum) {
 }
 
 extern "C" {
-
+#define DISABLE_CTL_LOGGER 1
 const char *env_variable = "";
 #define fopen(A, B) mock_fopen(A, B)
 #define fputs(A, B) mock_fputs(A, B)
@@ -135,13 +146,14 @@ void helper_checkConfig(utils_log_config_t *expected, utils_log_config_t *is) {
     EXPECT_EQ(expected->level, is->level);
     EXPECT_EQ(expected->flushLevel, is->flushLevel);
     EXPECT_EQ(expected->output, is->output);
-    EXPECT_EQ(expected->timestamp, is->timestamp);
-    EXPECT_EQ(expected->pid, is->pid);
+    EXPECT_EQ(expected->enableTimestamp, is->enableTimestamp);
+    EXPECT_EQ(expected->enablePid, is->enablePid);
 }
 
-TEST_F(test, parseEnv_errors) {
+TEST_F(test, DISABLE_IN_DEVELOPER_MODE(parseEnv_errors)) {
     expected_message = "";
-    loggerConfig = {0, 0, LOG_ERROR, LOG_ERROR, NULL};
+    loggerConfig =
+        utils_log_config_t{false, false, LOG_ERROR, LOG_ERROR, NULL, ""};
 
     expect_fput_count = 0;
     expected_stream = stderr;
@@ -164,7 +176,7 @@ TEST_F(test, parseEnv_errors) {
     helper_log_init(test_env.c_str());
 }
 
-TEST_F(test, parseEnv) {
+TEST_F(test, DISABLE_IN_DEVELOPER_MODE(parseEnv)) {
     utils_log_config_t b = loggerConfig;
     expected_message = "";
 
@@ -195,14 +207,16 @@ TEST_F(test, parseEnv) {
         {"output:file," + std::string(256, 'x'), MOCK_FILE_PTR},
         {"output:file," + std::string(257, 'x'), NULL},
     };
-    std::vector<std::pair<std::string, int>> timestamps = {
-        {"timestamp:yes", 1},
-        {"timestamp:invalid", 0},
-        {"timestamp:no", 0},
-        {"", 0}};
-
-    std::vector<std::pair<std::string, int>> pids = {
-        {"pid:yes", 1}, {"pid:invalid", 0}, {"pid:no", 0}, {"", 0}};
+    std::vector<std::pair<std::string, bool>> timestamps = {
+        {"timestamp:yes", true},
+        {"timestamp:invalid", false},
+        {"timestamp:no", false},
+        {"", false}};
+
+    std::vector<std::pair<std::string, int>> pids = {{"pid:yes", true},
+                                                     {"pid:invalid", false},
+                                                     {"pid:no", false},
+                                                     {"", false}};
     for (const auto &logLevel : logLevels) {
         for (const auto &flushLevel : flushLevels) {
             for (const auto &output : outputs) {
@@ -212,7 +226,8 @@ TEST_F(test, parseEnv) {
                                              flushLevel.first + ";" +
                                              output.first + ";" +
                                              timestamp.first + ";" + pid.first;
-                        b = loggerConfig = {0, 0, LOG_ERROR, LOG_ERROR, NULL};
+                        b = loggerConfig = utils_log_config_t{
+                            false, false, LOG_ERROR, LOG_ERROR, NULL, ""};
                         expect_fput_count = 0;
                         expect_fopen_count = 0;
                         expected_stream = stderr;
@@ -229,8 +244,8 @@ TEST_F(test, parseEnv) {
                                 expect_fopen_count = 1;
                             }
                             expected_stream = output.second;
-                            b.timestamp = timestamp.second;
-                            b.pid = pid.second;
+                            b.enableTimestamp = timestamp.second;
+                            b.enablePid = pid.second;
                             b.flushLevel = (utils_log_level_t)flushLevel.second;
 
                             b.level = (utils_log_level_t)logLevel.second;
@@ -254,10 +269,12 @@ TEST_F(test, parseEnv) {
     }
 }
 
-template <typename... Args> void helper_test_log(Args... args) {
+template <typename... Args>
+void helper_test_log(utils_log_level_t level, const char *func,
+                     const char *format, Args... args) {
     fput_count = 0;
     fflush_count = 0;
-    utils_log(args...);
+    utils_log(level, NULL, func, format, args...);
     EXPECT_EQ(fput_count, expect_fput_count);
     EXPECT_EQ(fflush_count, expect_fflush_count);
 }
@@ -284,7 +301,8 @@ TEST_F(test, log_levels) {
     expected_stream = stderr;
     for (int i = LOG_DEBUG; i <= LOG_ERROR; i++) {
         for (int j = LOG_DEBUG; j <= LOG_ERROR; j++) {
-            loggerConfig = {0, 0, (utils_log_level_t)i, LOG_DEBUG, stderr};
+            loggerConfig = utils_log_config_t{
+                false, false, (utils_log_level_t)i, LOG_DEBUG, stderr, ""};
             if (i > j) {
                 expect_fput_count = 0;
                 expect_fflush_count = 0;
@@ -307,7 +325,8 @@ TEST_F(test, log_outputs) {
     expect_fflush_count = 1;
     expected_message = "[DEBUG UMF] " + MOCK_FN_NAME + ": example log\n";
     for (auto o : outs) {
-        loggerConfig = {0, 0, LOG_DEBUG, LOG_DEBUG, o};
+        loggerConfig =
+            utils_log_config_t{false, false, LOG_DEBUG, LOG_DEBUG, o, ""};
         expected_stream = o;
         helper_test_log(LOG_DEBUG, MOCK_FN_NAME.c_str(), "%s", "example log");
     }
@@ -318,7 +337,8 @@ TEST_F(test, flush_levels) {
     expect_fput_count = 1;
     for (int i = LOG_DEBUG; i <= LOG_ERROR; i++) {
         for (int j = LOG_DEBUG; j <= LOG_ERROR; j++) {
-            loggerConfig = {0, 0, LOG_DEBUG, (utils_log_level_t)i, stderr};
+            loggerConfig = utils_log_config_t{
+                false, false, LOG_DEBUG, (utils_log_level_t)i, stderr, ""};
             if (i > j) {
                 expect_fflush_count = 0;
             } else {
@@ -335,7 +355,8 @@ TEST_F(test, flush_levels) {
 TEST_F(test, long_log) {
     expect_fput_count = 1;
     expect_fflush_count = 1;
-    loggerConfig = {0, 0, LOG_DEBUG, LOG_DEBUG, stderr};
+    loggerConfig =
+        utils_log_config_t{false, false, LOG_DEBUG, LOG_DEBUG, stderr, ""};
     expected_message = "[DEBUG UMF] " + MOCK_FN_NAME + ": " +
                        std::string(8189 - MOCK_FN_NAME.size(), 'x') + "\n";
     helper_test_log(LOG_DEBUG, MOCK_FN_NAME.c_str(), "%s",
@@ -350,7 +371,8 @@ TEST_F(test, long_log) {
 TEST_F(test, timestamp_log) {
     expect_fput_count = 1;
     expect_fflush_count = 1;
-    loggerConfig = {1, 0, LOG_DEBUG, LOG_DEBUG, stderr};
+    loggerConfig =
+        utils_log_config_t{true, false, LOG_DEBUG, LOG_DEBUG, stderr, ""};
     // TODO: for now we do not check output message,
     // as it requires more sophisticated message validation (a.k.a regrex)
     expected_message = "";
@@ -360,7 +382,8 @@ TEST_F(test, timestamp_log) {
 TEST_F(test, pid_log) {
     expect_fput_count = 1;
     expect_fflush_count = 1;
-    loggerConfig = {0, 1, LOG_DEBUG, LOG_DEBUG, stderr};
+    loggerConfig =
+        utils_log_config_t{false, true, LOG_DEBUG, LOG_DEBUG, stderr, ""};
     // TODO: for now we do not check output message,
     // as it requires more sophisticated message validation (a.k.a regrex)
     expected_message = "";
@@ -368,7 +391,8 @@ TEST_F(test, pid_log) {
 }
 
 TEST_F(test, log_fatal) {
-    loggerConfig = {0, 0, LOG_DEBUG, LOG_DEBUG, NULL};
+    loggerConfig =
+        utils_log_config_t{false, false, LOG_DEBUG, LOG_DEBUG, NULL, ""};
     expected_stream = stderr;
     expect_fput_count = 1;
     expect_fflush_count = 1;
@@ -378,11 +402,12 @@ TEST_F(test, log_fatal) {
     helper_test_log(LOG_FATAL, MOCK_FN_NAME.c_str(), "%s", "example log");
 }
 
-TEST_F(test, log_macros) {
+TEST_F(test, DISABLE_IN_DEVELOPER_MODE(log_macros)) {
     expected_stream = stderr;
     expect_fput_count = 1;
     expect_fflush_count = 1;
-    loggerConfig = {0, 0, LOG_DEBUG, LOG_DEBUG, stderr};
+    loggerConfig =
+        utils_log_config_t{false, false, LOG_DEBUG, LOG_DEBUG, stderr, ""};
 
     expected_message = "[DEBUG UMF] TestBody: example log\n";
     fput_count = 0;
@@ -420,16 +445,19 @@ TEST_F(test, log_macros) {
     EXPECT_EQ(fflush_count, expect_fflush_count);
 }
 
-template <typename... Args> void helper_test_plog(Args... args) {
+template <typename... Args>
+void helper_test_plog(utils_log_level_t level, const char *func,
+                      const char *format, Args... args) {
     fput_count = 0;
     fflush_count = 0;
-    utils_plog(args...);
+    utils_plog(level, NULL, func, format, args...);
     EXPECT_EQ(fput_count, expect_fput_count);
     EXPECT_EQ(fflush_count, expect_fflush_count);
 }
 
 TEST_F(test, plog_basic) {
-    loggerConfig = {0, 0, LOG_DEBUG, LOG_DEBUG, stderr};
+    loggerConfig =
+        utils_log_config_t{false, false, LOG_DEBUG, LOG_DEBUG, stderr, ""};
     expected_stream = stderr;
     errno = 1;
     strerr = "test error";
@@ -445,7 +473,8 @@ TEST_F(test, plog_basic) {
 }
 
 TEST_F(test, plog_invalid) {
-    loggerConfig = {0, 0, LOG_DEBUG, LOG_DEBUG, stderr};
+    loggerConfig =
+        utils_log_config_t{false, false, LOG_DEBUG, LOG_DEBUG, stderr, ""};
     expected_stream = stderr;
     errno = INVALID_ERRNO;
     strerr = "test error";
@@ -461,7 +490,8 @@ TEST_F(test, plog_invalid) {
 }
 
 TEST_F(test, plog_long_message) {
-    loggerConfig = {0, 0, LOG_DEBUG, LOG_DEBUG, stderr};
+    loggerConfig =
+        utils_log_config_t{false, false, LOG_DEBUG, LOG_DEBUG, stderr, ""};
     expected_stream = stderr;
     expect_fput_count = 1;
     expect_fflush_count = 1;
@@ -482,7 +512,8 @@ TEST_F(test, plog_long_message) {
 }
 
 TEST_F(test, plog_long_error) {
-    loggerConfig = {0, 0, LOG_DEBUG, LOG_DEBUG, stderr};
+    loggerConfig =
+        utils_log_config_t{false, false, LOG_DEBUG, LOG_DEBUG, stderr, ""};
     expected_stream = stderr;
     expect_fput_count = 1;
     expect_fflush_count = 1;
@@ -504,11 +535,12 @@ TEST_F(test, plog_long_error) {
     strerr = NULL; // do not use tmp.c_str() beyond its scope
 }
 
-TEST_F(test, log_pmacros) {
+TEST_F(test, DISABLE_IN_DEVELOPER_MODE(log_pmacros)) {
     expected_stream = stderr;
     expect_fput_count = 1;
     expect_fflush_count = 1;
-    loggerConfig = {0, 0, LOG_DEBUG, LOG_DEBUG, stderr};
+    loggerConfig =
+        utils_log_config_t{false, false, LOG_DEBUG, LOG_DEBUG, stderr, ""};
     errno = 1;
     strerr = "test error";
 
diff --git a/third_party/requirements.txt b/third_party/requirements.txt
index 6a8be6e46a..50e1ead7a7 100644
--- a/third_party/requirements.txt
+++ b/third_party/requirements.txt
@@ -1,17 +1,23 @@
 # Python requirements modules
 # Formatting the source code
+black==24.3.0
 clang-format==15.0.7
 cmake-format==0.6.13
-black==24.3.0
+# Linting the source code
+bandit==1.9.2
 # Tests
-packaging==24.2
+packaging==25.0
 # Generating HTML documentation
-pygments==2.18.0
+pygments==2.19.2
 sphinxcontrib_applehelp==2.0.0
 sphinxcontrib_devhelp==2.0.0
 sphinxcontrib_htmlhelp==2.1.0
 sphinxcontrib_serializinghtml==2.0.0
 sphinxcontrib_qthelp==2.0.0
-breathe==4.35.0
+breathe==4.36.0
 sphinx==8.1.3
 sphinx_book_theme==1.1.3
+# Spelling check in documentation
+codespell==2.4.1
+pyenchant==3.3.0
+sphinxcontrib-spelling==8.0.2