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 a6a45a8c1b..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="\
-	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 75c71c526c..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="\
-	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/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 81c54ce980..2aa19a298e 100755
--- a/.github/scripts/get_system_info.sh
+++ b/.github/scripts/get_system_info.sh
@@ -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
@@ -34,7 +34,7 @@ function system_info {
 	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
@@ -93,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/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
index 7eb3c7b06a..080b8f777f 100644
--- a/.github/workflows/benchmarks.yml
+++ b/.github/workflows/benchmarks.yml
@@ -7,25 +7,39 @@ on:
         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: ''
-      upload_report:
-        description: 'Upload HTML report'
-        type: boolean
+      bench_script_compare:
+        description: Compare label, passed to script executing benchmark as '--compare <label>'
+        type: choice
         required: false
-        default: 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
-  pull-requests: write
 
 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 }}
-      upload_report: ${{ inputs.upload_report }}
+      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 ebae6086a7..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
@@ -34,12 +34,14 @@ jobs:
         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: >
@@ -60,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 0918a36997..196fae1094 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -37,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 f209cf2c5f..3f13e8d133 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -9,62 +9,77 @@ on:
 
 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
 
@@ -79,7 +94,7 @@ jobs:
         -B ${{github.workspace}}/build
         -DCMAKE_BUILD_TYPE=Debug
         -DUMF_FORMAT_CODE_STYLE=OFF
-        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_DEVELOPER_MODE=OFF
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
         -DUMF_BUILD_CUDA_PROVIDER=OFF
@@ -92,8 +107,11 @@ jobs:
     - name: Run tests under valgrind
       run: ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{github.workspace}}/build ${{matrix.tool}}
 
+  # Build and test UMF with different CMake generators on Windows
   Windows-generators:
-    name: Windows ${{matrix.generator}} generator
+    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]
@@ -102,38 +120,47 @@ jobs:
         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@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
 
-    - name: Set VCPKG_PATH with hwloc
-      if: matrix.static_hwloc == 'OFF'
-      run: echo "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" >> $env:GITHUB_ENV
+    - 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: Set VCPKG_PATH without hwloc
-      if: matrix.static_hwloc == 'ON'
-      run: echo "VCPKG_PATH=${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows" >> $env:GITHUB_ENV
+    - 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
-      env: 
-        VCPKG_PATH: ${{env.VCPKG_PATH}}
       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@96bed6edff20d1dd61ecff9b75cc519d516e6401 # v5
+      uses: seanmiddleditch/gha-setup-ninja@3b1f8f94a2f8254bd26914c4ab9474d4f0015f67 # v6
 
     - name: Configure MSVC environment
       uses: ilammy/msvc-dev-cmd@0b201ec74fa43914dc39ae48a89fd1d8cb592756 # v1.13.0
@@ -185,13 +212,49 @@ jobs:
         ${{ matrix.umfd_lib == 'ON' && '--umfd-lib' || ''}}
         ${{ matrix.static_hwloc == 'ON' && '--hwloc' || '' }}
 
-  icx:
-   name: ICX
+    - 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-2019', 'windows-2022']
+       os: ['windows-2022', 'windows-2025']
        build_type: [Debug]
        compiler: [{c: icx, cxx: icx}]
        shared_library: ['ON', 'OFF']
@@ -200,80 +263,105 @@ jobs:
            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@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-     with:
-       fetch-depth: 0
-  
-   - 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
-  
-   - 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_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
-
-  hwloc-fallback:
+    - 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
-    name: "Fallback to static hwloc build"
+  Hwloc-fallback:
     strategy:
       matrix:
         include:
@@ -283,7 +371,7 @@ jobs:
           - 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:
@@ -292,7 +380,7 @@ jobs:
       run: sudo apt-get install -y libnuma-dev
 
     - name: Checkout
-      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
 
@@ -318,14 +406,71 @@ 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-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:
@@ -334,14 +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: read
+      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: '--save baseline'
-      upload_report: true
+      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/pr_push.yml b/.github/workflows/pr_push.yml
index 511808887e..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]
@@ -90,6 +98,6 @@ jobs:
     uses: ./.github/workflows/reusable_compatibility.yml
     strategy:
       matrix:
-        tag: ["v0.11.0-dev1"]
+        tag: ["v1.0.1"]
     with:
       tag: ${{matrix.tag}}
diff --git a/.github/workflows/reusable_basic.yml b/.github/workflows/reusable_basic.yml
index b30bfed4c8..7299cedabd 100644
--- a/.github/workflows/reusable_basic.yml
+++ b/.github/workflows/reusable_basic.yml
@@ -5,16 +5,22 @@ 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"
   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-22.04', 'ubuntu-24.04']
@@ -24,131 +30,117 @@ jobs:
         level_zero_provider: ['ON']
         cuda_provider: ['ON']
         install_tbb: ['ON']
-        disable_hwloc: ['OFF']
         link_hwloc_statically: ['OFF']
+        cmake_ver: ['default']
         include:
-          - 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'
+          - 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'
+            cmake_ver: 'default'
           # test lld linker
-          - os: 'ubuntu-24.04'
+          - 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: 'OFF'
             link_hwloc_statically: 'OFF'
             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'
+          - 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'
-            disable_hwloc: 'OFF'
             link_hwloc_statically: 'OFF'
-          - os: 'ubuntu-22.04'
-            build_type: Debug
-            compiler: {c: gcc, cxx: g++}
-            shared_library: 'ON'
-            level_zero_provider: 'ON'
-            cuda_provider: 'ON'
-            install_tbb: 'ON'
-            disable_hwloc: 'ON'
-            link_hwloc_statically: 'OFF'
-          - os: 'ubuntu-22.04'
+            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 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
+        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
 
@@ -168,7 +160,6 @@ jobs:
         -DUMF_DEVELOPER_MODE=ON
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=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 || '' }}
@@ -188,98 +179,202 @@ jobs:
       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}}
-        ${{ 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:
-          - os: 'windows-2019'
-            # clang build fails on Windows 2022
-            build_type: Release
+          # 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'
-            toolset: "-T ClangCL"
+            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'
-            build_type: Release
             compiler: {c: cl, cxx: cl}
             shared_library: 'ON'
             level_zero_provider: 'ON'
             cuda_provider: 'ON'
             umfd_lib: 'ON'
-          - os: 'windows-2022'
-            build_type: Release
-            compiler: {c: cl, cxx: cl}
-            shared_library: 'ON'
-            level_zero_provider: 'OFF'
-            cuda_provider: 'OFF'
-
+    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: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
-        vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
+        vcpkgDirectory: ${{github.workspace}}/vcpkg
         vcpkgJsonGlob: '**/vcpkg.json'
 
     - name: Install dependencies
+      if: steps.cache.outputs.cache-hit != 'true'
       run: vcpkg install --triplet x64-windows
-      shell: pwsh # Specifies PowerShell as the shell for running the script.
+
+    # 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_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_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 (Debug)
+      run: cmake --build ${{env.BUILD_DEBUG_DIR}} --config Debug -j $Env:NUMBER_OF_PROCESSORS
+
+    - 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: Configure build
+    - name: Test UMF installation and uninstallation (Debug)
+      run: >
+        python3 ${{github.workspace}}/test/test_installation.py
+        --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' || ''}}
+        ${{ matrix.umfd_lib == 'ON' && '--umfd-lib' || ''}}
+
+    - name: Configure build (Release)
       run: >
         cmake
-        -B ${{env.BUILD_DIR}}
-        ${{matrix.toolset}}
-        -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
+        -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}}
@@ -290,48 +385,73 @@ jobs:
         -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}}
+        -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 (Release)
+      run: cmake --build ${{env.BUILD_RELEASE_DIR}} --config Release -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 (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
-      # 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 (Release)
       run: >
         python3 ${{github.workspace}}/test/test_installation.py
-        --build-dir ${{env.BUILD_DIR}}
-        --install-dir ${{env.INSTL_DIR}}
-        --build-type ${{matrix.build_type}}
+        --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
+
+    - 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
 
@@ -369,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
 
@@ -399,71 +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: '-DUMF_LINK_HWLOC_STATICALLY=ON'
+            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
 
@@ -476,11 +547,11 @@ jobs:
         python3 -m pip install -r third_party/requirements.txt
 
     - name: Install dependencies
-      run: brew install jemalloc tbb automake libtool
+      run: brew install --quiet jemalloc tbb automake libtool
 
     - name: Install hwloc
-      if: ${{ !matrix.static_hwloc }}
-      run: brew install hwloc
+      if: ${{ matrix.static_hwloc == 'OFF' }}
+      run: brew install --quiet hwloc
 
     - name: Get UMF version
       run: |
@@ -499,7 +570,7 @@ jobs:
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
         -DUMF_BUILD_SHARED_LIBRARY=ON
         -DUMF_TESTS_FAIL_ON_SKIP=ON
-        ${{matrix.static_hwloc}}
+        -DUMF_LINK_HWLOC_STATICALLY=${{matrix.static_hwloc}}
 
     - name: Build UMF
       run: cmake --build ${{env.BUILD_DIR}} -j $(sysctl -n hw.logicalcpu)
diff --git a/.github/workflows/reusable_benchmarks.yml b/.github/workflows/reusable_benchmarks.yml
index 3953e98de5..a6dc2f1e2f 100644
--- a/.github/workflows/reusable_benchmarks.yml
+++ b/.github/workflows/reusable_benchmarks.yml
@@ -1,5 +1,5 @@
 # Executes benchmarks implemented in this repository using scripts
-# for results visualization from intel/llvm (unified-runtime dir).
+# for results visualization from intel/llvm.
 name: Benchmarks
 
 on:
@@ -14,14 +14,24 @@ on:
         required: false
         type: string
         default: ''
-      upload_report:
+      bench_script_compare:
         required: false
-        type: boolean
-        default: 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: write
+  pull-requests: read
 
 env:
   UMF_DIR: "${{github.workspace}}/umf-repo"
@@ -32,25 +42,30 @@ jobs:
     name: Benchmarks
     # run only on upstream; forks will not have the HW
     if: github.repository == 'oneapi-src/unified-memory-framework'
-    runs-on: L0_PERF
+    runs-on: ${{ inputs.runner }}
+    permissions:
+      contents: write
+      pull-requests: write
 
     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()
+    - name: Establish bench params
       run: |
-        ls -la ./
-        rm -rf ./* || true
+        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@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+      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 = '${{ inputs.bench_script_params }}';
+          const params = `${{ env.bench_params }}`;
           const body = `Compute Benchmarks run (with params: ${params}):\n${url}`;
 
           github.rest.issues.createComment({
@@ -61,7 +76,7 @@ jobs:
           })
 
     - name: Checkout UMF
-      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         path: ${{env.UMF_DIR}}
         fetch-depth: 0
@@ -97,27 +112,38 @@ jobs:
     - name: Build UMF
       run: cmake --build ${{env.BUILD_DIR}} -j $(nproc)
 
-    # Get scripts for benchmark data visualization.
-    # Use specific tag, as the scripts or files' location may change.
-    - name: Checkout SYCL
-      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+    - 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
-        # [BENCHMARK] fix default timeout parameter
-        # https://github.com/intel/llvm/pull/17412
-        ref: 357e9e0b253b7eba105d044e38452b3c09169f8a
-        path: sycl-repo
-        fetch-depth: 1
+        # 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: |
-        python -m venv .venv
+        python3 -m venv .venv
         source .venv/bin/activate
-        pip install -r ${{github.workspace}}/sycl-repo/unified-runtime/third_party/benchmark_requirements.txt
+        echo "$PATH" >> $GITHUB_PATH
+        pip install -r ${{github.workspace}}/sc/devops/scripts/benchmarks/requirements.txt
 
     - name: Set core range and GPU mask
       run: |
-        # Compute the core range for the second NUMA node; first node is for SYCL/UR jobs.
+        # 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}
@@ -130,37 +156,72 @@ jobs:
         echo "Selected core: $CORES"
         echo "CORES=$CORES" >> $GITHUB_ENV
 
-        ZE_AFFINITY_MASK=1
+        ZE_AFFINITY_MASK=${{ inputs.runner == 'L0_PERF_ARC' && '0' || '1' }}
         echo "ZE_AFFINITY_MASK=$ZE_AFFINITY_MASK" >> $GITHUB_ENV
 
-    - name: Run UMF benchmarks
+    - 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
-      working-directory: ${{env.BUILD_DIR}}
+      env:
+        LD_LIBRARY_PATH: ${{ env.SYCL_DIR }}/lib
+        CPATH: ${{ env.SYCL_DIR }}/include
       run: >
-        source ${{github.workspace}}/.venv/bin/activate &&
-        taskset -c ${{ env.CORES }} ${{ github.workspace }}/sycl-repo/unified-runtime/scripts/benchmarks/main.py
+        taskset -c ${{ env.CORES }} ./sc/devops/scripts/benchmarks/main.py
         ~/bench_workdir_umf
-        --umf ${{env.BUILD_DIR}}
-        --compare baseline
-        --timeout 3000
-        ${{ inputs.upload_report && '--output-html' || '' }}
-        ${{ inputs.pr_no != 0 && '--output-markdown' || '' }}
-        ${{ inputs.bench_script_params }}
+        --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() && inputs.pr_no != 0 }}
-      run: cat ${{env.BUILD_DIR}}/benchmark_results.md
+      if: ${{ always() }}
+      run: cat ${{ github.workspace }}/benchmark_results.md || true
 
     - name: Add comment to PR
-      uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+      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('${{env.BUILD_DIR}}/benchmark_results.md', 'utf8');
+            markdown = fs.readFileSync('${{ github.workspace }}/benchmark_results.md', 'utf8');
           } catch(err) {
           }
 
@@ -168,7 +229,7 @@ jobs:
           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 = '${{ inputs.bench_script_params }}';
+          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({
@@ -177,15 +238,44 @@ jobs:
             repo: context.repo.repo,
             body: body
           })
-  
-    - name: Upload HTML report
-      if: ${{ always() && inputs.upload_report }}
-      uses: actions/cache/save@1bd1e32a3bdc45362d1e726936510720a7c30a57 # v4.2.0
-      with:
-        path: umf-repo/build/benchmark_results.html
-        key: benchmark-results-${{ github.run_id }}
 
-    - name: Get information about platform
-      if: ${{ always() }}
-      working-directory: ${{env.UMF_DIR}}
-      run: .github/scripts/get_system_info.sh
+    - 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 a7602d2696..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 doxygen
+        sudo apt-get install -y cmake libhwloc-dev doxygen
 
     # Latest distros do not allow global pip installation
     - name: Install Python requirements in venv
@@ -30,7 +30,6 @@ jobs:
         . .venv/bin/activate
         echo "$PATH" >> $GITHUB_PATH
         python3 -m pip install -r third_party/requirements.txt
-        python3 -m pip install bandit codespell
 
     - name: Configure CMake
       run: >
@@ -58,7 +57,7 @@ jobs:
         ./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
 
diff --git a/.github/workflows/reusable_codeql.yml b/.github/workflows/reusable_codeql.yml
index 252e70eee7..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,33 +31,49 @@ 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: 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 --triplet x64-windows
-        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'
@@ -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
index 523b09e129..621103479c 100644
--- a/.github/workflows/reusable_compatibility.yml
+++ b/.github/workflows/reusable_compatibility.yml
@@ -9,7 +9,10 @@ on:
       tag:
         description: Check backward compatibility with this tag
         type: string
-        default: "v0.11.0-dev1"
+        # 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
@@ -23,18 +26,46 @@ jobs:
     - name: Install apt packages
       run: |
         sudo apt-get update
-        sudo apt-get install -y clang cmake libnuma-dev libtbb-dev
+        sudo apt-get install -y clang cmake hwloc libhwloc-dev libnuma-dev libtbb-dev
 
     - name: Checkout "tag" UMF version
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
         ref: refs/tags/${{inputs.tag}}
         path: ${{github.workspace}}/tag_version
 
-    - name: Install libhwloc
-      working-directory: ${{github.workspace}}/tag_version
-      run: .github/scripts/install_hwloc.sh
+    - 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
@@ -65,57 +96,73 @@ jobs:
       run: |
         LD_LIBRARY_PATH=${{github.workspace}}/tag_version/build/lib/ ctest --output-on-failure
 
-    - name: Checkout latest UMF version
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      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_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
+    - 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: |
-        cmake --build ${{github.workspace}}/latest_version/build -j $(nproc)
+        ctest --verbose -E "test_memoryProvider|test_disjoint_pool"
 
-    - name: Run "tag" UMF tests with latest UMF libs (warnings enabled)
+    - name: Run disabled tests individually with latest UMF libs (warnings enabled)
       working-directory: ${{github.workspace}}/tag_version/build
-      # GTEST_FILTER is used below to skip test that is not compatible
-      run: >
-        UMF_LOG="level:warning;flush:debug;output:stderr;pid:no"
-        LD_LIBRARY_PATH=${{github.workspace}}/latest_version/build/lib/
-        GTEST_FILTER="-*umfIpcTest.GetPoolByOpenedHandle*"
-        ctest --verbose
+      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"
-    runs-on: "windows-2022"
+      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@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      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
@@ -124,10 +171,40 @@ jobs:
 
     # 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
-      shell: pwsh # Specifies PowerShell as the shell for running the script.
 
+    - 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: >
@@ -154,8 +231,84 @@ jobs:
       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@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
         path: ${{github.workspace}}/latest_version
@@ -164,41 +317,30 @@ jobs:
       working-directory: ${{github.workspace}}/latest_version
       run: >
         cmake
-        -B "${{github.workspace}}/latest_version/build"
-        -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
-        -DCMAKE_C_COMPILER=cl
-        -DCMAKE_CXX_COMPILER=cl
+        -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_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
-      run: cmake --build "${{github.workspace}}/latest_version/build" --config Debug -j $Env:NUMBER_OF_PROCESSORS
-
-    - name: Run "tag" UMF tests with latest UMF libs (warnings enabled)
-      working-directory: ${{github.workspace}}/tag_version/build
+      working-directory: ${{github.workspace}}/latest_version
       run: |
-        $env:UMF_LOG="level:warning;flush:debug;output:stderr;pid:no" 
-        $env:GTEST_FILTER="-*umfIpcTest.GetPoolByOpenedHandle*"
-        cp ${{github.workspace}}/latest_version/build/bin/Debug/umf.dll ${{github.workspace}}/tag_version/build/bin/Debug/umf.dll
-        ctest -C Debug --verbose
-
-  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"]
+        cmake --build ${{github.workspace}}/latest_version/build -j $(nproc)
 
-    steps:
+    - 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@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
         ref: refs/tags/${{inputs.tag}}
@@ -217,13 +359,11 @@ jobs:
         -DUMF_BUILD_GPU_TESTS=ON
         -DUMF_BUILD_EXAMPLES=ON
         -DUMF_BUILD_GPU_EXAMPLES=ON
-        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
-        -DUMF_BUILD_CUDA_PROVIDER=OFF
-        -DUMF_BUILD_${{matrix.provider}}_PROVIDER=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_BUILD_LIBUMF_POOL_DISJOINT=ON
         -DUMF_TESTS_FAIL_ON_SKIP=ON
 
     - name: Build "tag" UMF
@@ -235,41 +375,44 @@ jobs:
       working-directory: ${{github.workspace}}/tag_version/build
       run: >
         LD_LIBRARY_PATH=${{github.workspace}}/tag_version/build/lib/
-        GTEST_FILTER="-*umfIpcTest.GetPoolByOpenedHandle*"
         ctest --output-on-failure
 
-    - name: Checkout latest UMF version
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      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_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
+    - 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: |
-        cmake --build ${{github.workspace}}/latest_version/build -j $(nproc)
+        ctest --verbose -E "test_memoryProvider|test_disjoint_pool"
 
-    # NOTE: Once not implemented features may now be implemented - exclude these tests
-    - name: Run "tag" UMF tests with latest UMF libs (warnings enabled)
+    - name: Run disabled tests individually with latest UMF libs (warnings enabled)
       working-directory: ${{github.workspace}}/tag_version/build
-      run: >
-        UMF_LOG="level:warning;flush:debug;output:stderr;pid:no"
-        LD_LIBRARY_PATH=${{github.workspace}}/latest_version/build/lib/
-        GTEST_FILTER="-*umfIpcTest.GetPoolByOpenedHandle*"
-        ctest --verbose -E "not_impl"
+      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 4ea5ddac75..7dacba4e9d 100644
--- a/.github/workflows/reusable_dax.yml
+++ b/.github/workflows/reusable_dax.yml
@@ -28,22 +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: |
@@ -65,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
 
@@ -142,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 9317478bb4..b852e09182 100644
--- a/.github/workflows/reusable_docs_build.yml
+++ b/.github/workflows/reusable_docs_build.yml
@@ -18,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
 
@@ -41,26 +41,43 @@ jobs:
           -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF \
           -DUMF_BUILD_CUDA_PROVIDER=OFF \
           -DUMF_BUILD_TESTS=OFF \
-          -DUMF_BUILD_EXAMPLES=OFF \
-          -DUMF_DISABLE_HWLOC=ON
+          -DUMF_BUILD_EXAMPLES=OFF
         cmake --build build --target docs
 
-    # If we upload HTML docs, we want to include benchmark results as well
-    - name: Download benchmark HTML before uploading 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 }}
-      id: download-bench-html
-      uses: actions/cache/restore@1bd1e32a3bdc45362d1e726936510720a7c30a57 # v4.2.0
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
-        path: umf-repo/build/benchmark_results.html
-        key: benchmark-results-
+        repository: intel/llvm
+        # 30.07.2025
+        # branch: sycl
+        ref: 8f54710553800eec05a6fd9717b14f995a22b137
+        path: sc
+        sparse-checkout: |
+          devops/scripts/benchmarks
 
-    - name: Move benchmark HTML
-      if: ${{ inputs.upload == true && steps.download-bench-html.outputs.cache-hit != '' }}
+    - 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: |
-        mv umf-repo/build/benchmark_results.html ${{github.workspace}}/build/docs_build/generated/html
+        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@0252fc4ba7626f0298f0cf00902a25c6afc77fa8 # v3.0.0
+      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 7b1087ed0a..3bba141312 100644
--- a/.github/workflows/reusable_fast.yml
+++ b/.github/workflows/reusable_fast.yml
@@ -1,79 +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
+          - os: ubuntu-24.04
             build_tests: 'ON'
+            extra_build_options: ' -DUMF_BUILD_BENCHMARKS=ON -DUMF_BUILD_BENCHMARKS_MT=ON'
             simple_cmake: 'OFF'
-          # pure C build (Windows)
-          - os: windows-latest
+          # pure C build
+          - os: ubuntu-24.04
             # Tests' building is off for a pure C build
             build_tests: 'OFF'
+            extra_build_options: '-DUMF_BUILD_BENCHMARKS=ON'
             simple_cmake: 'OFF'
-          - os: ubuntu-latest
+          # simplest CMake on Ubuntu 22.04, 24.04
+          - 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'
-            simple_cmake: 'OFF'
-          # pure C build (Linux)
-          - os: ubuntu-latest
-            # Windows doesn't recognize 'CMAKE_BUILD_TYPE', it uses '--config' param in build command
-            # Tests' building is off for a pure C build
-            build_tests: 'OFF'
-            extra_build_options: '-DCMAKE_BUILD_TYPE=Release -DUMF_BUILD_BENCHMARKS=ON'
-            simple_cmake: 'OFF'
-          # simplest CMake on ubuntu-latest
-          - os: ubuntu-latest
-            build_tests: 'ON'
-            extra_build_options: '-DCMAKE_BUILD_TYPE=Release'
             simple_cmake: 'ON'
-          # simplest CMake ubuntu-22.04
           - 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@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+      with:
+        fetch-depth: 0
+
+    - 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@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      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-fast-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: matrix.os == 'windows-latest'
+      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 (windows-latest)
-      if: matrix.os == 'windows-latest'
-      run: vcpkg install --triplet x64-windows
-      shell: pwsh # Specifies PowerShell as the shell for running the script.
-
     - name: Install dependencies
-      if: matrix.os != 'windows-latest'
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y cmake libhwloc-dev libnuma-dev libtbb-dev
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: vcpkg install --triplet x64-windows
 
     - name: Configure CMake
       if: matrix.simple_cmake == 'OFF'
@@ -91,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'
@@ -99,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
@@ -118,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 6fcd408208..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,49 +44,71 @@ 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: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
-          vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
+          vcpkgDirectory: ${{github.workspace}}/vcpkg
           vcpkgJsonGlob: '**/vcpkg.json'
 
       - name: "[Win] Install dependencies"
-        if: matrix.os == 'Windows'
+        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
       # '-DCMAKE_SUPPRESS_REGENERATION=ON' is the WA for the error: "CUSTOMBUILD : CMake error : Cannot restore timestamp"
-      - name: Configure build
+      - 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
@@ -97,39 +119,85 @@ jobs:
           -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-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: 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: Check coverage
-        if: ${{ matrix.build_type == 'Debug' && matrix.os == 'Ubuntu' }}
-        working-directory: ${{env.BUILD_DIR}}
+      - 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 47a48adb20..86ed771751 100644
--- a/.github/workflows/reusable_multi_numa.yml
+++ b/.github/workflows/reusable_multi_numa.yml
@@ -14,20 +14,19 @@ env:
 
 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, 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
 
@@ -57,12 +56,11 @@ jobs:
         # 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
-        # TODO: add issue for -E test_init_teardown - it is not clear why it fails
       - 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 "test_provider_os_memory_multiple_numa_nodes|test_init_teardown"
+          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"
 
@@ -83,7 +81,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' && matrix.os == 'ubuntu-22.04' }}
         with:
           name: ${{env.COVERAGE_NAME}}-${{matrix.os}}-shared-${{matrix.shared_library}}
diff --git a/.github/workflows/reusable_proxy_lib.yml b/.github/workflows/reusable_proxy_lib.yml
index c519be95b8..c09f18ef02 100644
--- a/.github/workflows/reusable_proxy_lib.yml
+++ b/.github/workflows/reusable_proxy_lib.yml
@@ -8,24 +8,23 @@ 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
 
@@ -88,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 c74448e1d2..a08ce2ccac 100644
--- a/.github/workflows/reusable_sanitizers.yml
+++ b/.github/workflows/reusable_sanitizers.yml
@@ -5,24 +5,24 @@ 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
 
@@ -53,7 +53,7 @@ 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_USE_ASAN=${{matrix.sanitizers.asan}}
         -DUMF_USE_UBSAN=${{matrix.sanitizers.ubsan}}
@@ -74,70 +74,68 @@ jobs:
       run: |
         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: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
-        vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
-        vcpkgJsonGlob: '**/vcpkg.json'
-
-    - name: Install dependencies
-      run: vcpkg install --triplet x64-windows
-      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_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 5999297d6a..cc347e32bf 100644
--- a/.github/workflows/reusable_valgrind.yml
+++ b/.github/workflows/reusable_valgrind.yml
@@ -13,7 +13,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       with:
         fetch-depth: 0
 
@@ -28,7 +28,7 @@ jobs:
         -B ${{github.workspace}}/build
         -DCMAKE_BUILD_TYPE=Debug
         -DUMF_FORMAT_CODE_STYLE=OFF
-        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_DEVELOPER_MODE=OFF
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
         -DUMF_BUILD_CUDA_PROVIDER=OFF
@@ -41,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/CMakeLists.txt b/CMakeLists.txt
index f7e640abcc..2a60a22502 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,7 +2,9 @@
 # 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})
 
@@ -30,7 +32,8 @@ 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 checkout the git tags to get a proper version.")
+            "Please install git and checkout the git tags to get a proper version."
+    )
 endif()
 
 if(PROJECT_VERSION_PATCH GREATER 0)
@@ -71,11 +74,8 @@ 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_GPU_EXAMPLES "Build UMF GPU examples" OFF)
-umf_option(UMF_BUILD_FUZZTESTS "Build UMF fuzz tests" 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 (proxy library will be disabled on Windows+Debug build)"
@@ -204,7 +204,14 @@ else()
         DEPENDS ${jemalloc_targ_SOURCE_DIR}/configure)
 
     if(NOT UMF_QEMU_BUILD)
-        set(MAKE_ARGUMENTS "-j$(nproc)")
+        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(
@@ -225,12 +232,13 @@ else()
         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 OR JEMALLOC_LIBRARIES)
+if(JEMALLOC_FOUND)
     set(UMF_POOL_JEMALLOC_ENABLED TRUE)
     # add PATH to DLL on Windows
     set(DLL_PATH_LIST
@@ -249,16 +257,13 @@ else()
     )
 endif()
 
-if(NOT UMF_DISABLE_HWLOC AND (NOT UMF_LINK_HWLOC_STATICALLY))
+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)
-        if(LIBHWLOC_LIBRARIES)
-            set(LIBHWLOC_AVAILABLE TRUE)
-        endif()
     endif()
 
-    if(LIBHWLOC_AVAILABLE OR LIBHWLOC_FOUND)
+    if(LIBHWLOC_FOUND)
         # add PATH to DLL on Windows
         set(DLL_PATH_LIST
             "${DLL_PATH_LIST};PATH=path_list_append:${LIBHWLOC_DLL_DIRS}")
@@ -267,108 +272,104 @@ if(NOT UMF_DISABLE_HWLOC AND (NOT UMF_LINK_HWLOC_STATICALLY))
     endif()
 endif()
 
-if(UMF_LINK_HWLOC_STATICALLY AND LINUX)
-    find_program(AUTORECONF_EXECUTABLE autoreconf)
-    if(NOT AUTORECONF_EXECUTABLE)
-        message(WARNING "autoreconf is not installed. Disabling hwloc.")
-        set(UMF_DISABLE_HWLOC ON)
-        set(UMF_LINK_HWLOC_STATICALLY OFF)
+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()
-endif()
 
-if(UMF_DISABLE_HWLOC)
-    message(STATUS "hwloc is disabled, hence OS provider, memtargets, "
-                   "topology discovery, examples won't be available!")
-else()
-    if(UMF_LINK_HWLOC_STATICALLY)
-        if(NOT DEFINED UMF_HWLOC_REPO)
-            set(UMF_HWLOC_REPO "https://github.com/open-mpi/hwloc.git")
-        endif()
+    message(
+        STATUS
+            "Will fetch hwloc from ${UMF_HWLOC_REPO} (tag: ${UMF_HWLOC_TAG}) and link it statically"
+    )
 
-        if(NOT DEFINED UMF_HWLOC_TAG)
-            set(UMF_HWLOC_TAG hwloc-2.10.0)
+    if(WINDOWS)
+        set(HWLOC_ENABLE_TESTING OFF)
+        set(HWLOC_SKIP_LSTOPO ON)
+        set(HWLOC_SKIP_TOOLS ON)
+        set(HWLOC_SKIP_INCLUDES ON)
+
+        FetchContent_Declare(
+            hwloc_targ
+            GIT_REPOSITORY ${UMF_HWLOC_REPO}
+            GIT_TAG ${UMF_HWLOC_TAG}
+            SOURCE_SUBDIR contrib/windows-cmake/)
+        FetchContent_MakeAvailable(hwloc_targ)
+
+        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()
-        message(
-            STATUS
-                "Will fetch hwloc from ${UMF_HWLOC_REPO} (tag: ${UMF_HWLOC_TAG})"
-        )
 
-        if(WINDOWS)
-            set(HWLOC_ENABLE_TESTING OFF)
-            set(HWLOC_SKIP_LSTOPO ON)
-            set(HWLOC_SKIP_TOOLS ON)
-            set(HWLOC_SKIP_INCLUDES ON)
-
-            FetchContent_Declare(
-                hwloc_targ
-                GIT_REPOSITORY ${UMF_HWLOC_REPO}
-                GIT_TAG ${UMF_HWLOC_TAG}
-                SOURCE_SUBDIR contrib/windows-cmake/)
-            FetchContent_MakeAvailable(hwloc_targ)
-
-            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)
-        else() # not Windows
-            FetchContent_Declare(
-                hwloc_targ
-                GIT_REPOSITORY ${UMF_HWLOC_REPO}
-                GIT_TAG ${UMF_HWLOC_TAG})
-            FetchContent_MakeAvailable(hwloc_targ)
-
-            add_custom_command(
-                COMMAND ./autogen.sh
-                WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
-                OUTPUT ${hwloc_targ_SOURCE_DIR}/configure)
-            add_custom_command(
-                COMMAND
-                    ./configure --prefix=${hwloc_targ_BINARY_DIR}
-                    --enable-static=yes --enable-shared=no --disable-libxml2
-                    --disable-pci --disable-levelzero --disable-opencl
-                    --disable-cuda --disable-nvml --disable-libudev
-                    --disable-rsmi CFLAGS=-fPIC CXXFLAGS=-fPIC
-                WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
-                OUTPUT ${hwloc_targ_SOURCE_DIR}/Makefile
-                DEPENDS ${hwloc_targ_SOURCE_DIR}/configure)
-            add_custom_command(
-                COMMAND make
-                WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
-                OUTPUT ${hwloc_targ_SOURCE_DIR}/lib/libhwloc.la
-                DEPENDS ${hwloc_targ_SOURCE_DIR}/Makefile)
-            add_custom_command(
-                COMMAND make install
-                WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
-                OUTPUT ${hwloc_targ_BINARY_DIR}/lib/libhwloc.a
-                DEPENDS ${hwloc_targ_SOURCE_DIR}/lib/libhwloc.la)
-
-            add_custom_target(hwloc_prod
-                              DEPENDS ${hwloc_targ_BINARY_DIR}/lib/libhwloc.a)
-            add_library(hwloc INTERFACE)
-            target_link_libraries(
-                hwloc INTERFACE ${hwloc_targ_BINARY_DIR}/lib/libhwloc.a)
-            add_dependencies(hwloc hwloc_prod)
-
-            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)
+        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()
-    endif() # UMF_LINK_HWLOC_STATICALLY
+        FetchContent_Declare(
+            hwloc_targ
+            GIT_REPOSITORY ${UMF_HWLOC_REPO}
+            GIT_TAG ${UMF_HWLOC_TAG})
+        FetchContent_MakeAvailable(hwloc_targ)
 
-    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}")
+        add_custom_command(
+            COMMAND ./autogen.sh
+            WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
+            OUTPUT ${hwloc_targ_SOURCE_DIR}/configure)
+        add_custom_command(
+            COMMAND
+                ./configure --prefix=${hwloc_targ_BINARY_DIR}
+                --enable-static=yes --enable-shared=no --disable-libxml2
+                --disable-pci --disable-levelzero --disable-opencl
+                --disable-cuda --disable-nvml --disable-libudev --disable-rsmi
+                CFLAGS=-fPIC CXXFLAGS=-fPIC
+            WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
+            OUTPUT ${hwloc_targ_SOURCE_DIR}/Makefile
+            DEPENDS ${hwloc_targ_SOURCE_DIR}/configure)
+        add_custom_command(
+            COMMAND make
+            WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
+            OUTPUT ${hwloc_targ_SOURCE_DIR}/lib/libhwloc.la
+            DEPENDS ${hwloc_targ_SOURCE_DIR}/Makefile)
+        add_custom_command(
+            COMMAND make install
+            WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
+            OUTPUT ${hwloc_targ_BINARY_DIR}/lib/libhwloc.a
+            DEPENDS ${hwloc_targ_SOURCE_DIR}/lib/libhwloc.la)
+
+        add_custom_target(hwloc_prod
+                          DEPENDS ${hwloc_targ_BINARY_DIR}/lib/libhwloc.a)
+        add_library(hwloc INTERFACE)
+        target_link_libraries(hwloc
+                              INTERFACE ${hwloc_targ_BINARY_DIR}/lib/libhwloc.a)
+        add_dependencies(hwloc hwloc_prod)
+
+        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_API_VERSION = ${LIBHWLOC_API_VERSION}")
+if(WINDOWS)
+    message(STATUS "    LIBHWLOC_DLL_DIRS = ${LIBHWLOC_DLL_DIRS}")
 endif()
 
 if(hwloc_targ_SOURCE_DIR)
@@ -387,58 +388,118 @@ 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))
-    set(LEVEL_ZERO_LOADER_REPO "https://github.com/oneapi-src/level-zero.git")
-    set(LEVEL_ZERO_LOADER_TAG v1.20.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)
 
-    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")
-    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}")
-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))
-    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 Level Zero loader (${LEVEL_ZERO_LOADER_TAG}) "
+                       "from ${LEVEL_ZERO_LOADER_REPO} ...")
 
-    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_DIRS = ${CUDA_INCLUDE_DIRS}")
-elseif(UMF_BUILD_CUDA_PROVIDER)
-    # Only header is needed to build UMF
-    set(CUDA_INCLUDE_DIRS ${UMF_CUDA_INCLUDE_DIR})
+        # 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()
+
+        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}")
+
+    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()
+
+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()
+
+    # 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}) 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()
+
+        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
@@ -463,7 +524,7 @@ if(WINDOWS AND UMF_USE_DEBUG_POSTFIX)
             -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_DISABLE_HWLOC=${UMF_DISABLE_HWLOC}
+            -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
@@ -564,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)
@@ -579,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
@@ -616,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)
@@ -648,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
@@ -685,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)
@@ -707,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()
 
@@ -876,12 +961,11 @@ if(UMF_FORMAT_CODE_STYLE)
             COMMENT "Format C/C++, CMake, and Python files")
         message(
             STATUS
-                "  Adding convenience targets 'format-check' and 'format-apply'."
-        )
+                "Adding convenience targets 'format-check' and 'format-apply'.")
     else()
         message(
             STATUS
-                "  Convenience targets 'format-check' and 'format-apply' are "
+                "Convenience targets 'format-check' and 'format-apply' are "
                 "not available. Use commands specific for found tools (see the log above)."
         )
     endif()
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 6a050c0ae7..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)
@@ -67,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 
diff --git a/ChangeLog b/ChangeLog
index a7b6137745..0de579ecf8 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,71 @@
+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
diff --git a/README.md b/README.md
index 00d6136df9..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,10 +19,10 @@ 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
 
@@ -39,6 +40,9 @@ For development and contributions:
 - 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`)
 
+> **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
@@ -75,7 +79,7 @@ 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
 managers' section below.
@@ -97,6 +101,20 @@ List of sanitizers available on Windows:
 
 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:
@@ -111,9 +129,9 @@ List of options provided by CMake:
 | 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 |
@@ -123,7 +141,6 @@ List of options provided by CMake:
 | 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 (proxy library will be disabled on Windows+Debug build) | ON/OFF | OFF |
-| UMF_DISABLE_HWLOC | Disable features that requires hwloc (OS provider, memory targets, topology discovery) | ON/OFF | OFF |
 
 ## Architecture: memory pools and providers
 
@@ -315,6 +332,8 @@ Packages required for using this pool and executing tests/benchmarks (not requir
 
 ### 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
@@ -384,6 +403,27 @@ 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 9189d48048..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,47 +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
+- 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 (prior 1.0.0) releases update ABI version in `.map` and `.def` files
+- 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" v$VERSION+1-dev`
-    - for example, when `v0.1.0` is released, the dev tag would be `v0.2.0-dev`
-    - if needed, further in time, an extra dev tag can be introduced, e.g. `v0.2.0-dev1`
+  - `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
 
@@ -70,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 d52fc0857e..1c417af67d 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -2,22 +2,28 @@
 # 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
@@ -60,8 +66,10 @@ 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})
 
@@ -87,16 +95,6 @@ function(add_umf_benchmark)
         set_property(TEST ${BENCH_NAME} PROPERTY ENVIRONMENT_MODIFICATION
                                                  "${DLL_PATH_LIST}")
     endif()
-    if(LINUX)
-        # prepend LD_LIBRARY_PATH with ${CMAKE_BINARY_DIR}/lib it is required
-        # because ${CMAKE_BINARY_DIR}/lib contains libze_loader.so and tests
-        # should use it instead of system one.
-        set_property(
-            TEST ${BENCH_NAME}
-            PROPERTY ENVIRONMENT_MODIFICATION
-                     "LD_LIBRARY_PATH=path_list_prepend:${CMAKE_BINARY_DIR}/lib"
-        )
-    endif()
 
     if(UMF_POOL_JEMALLOC_ENABLED)
         target_compile_definitions(${BENCH_NAME}
@@ -106,19 +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 ${UMF_CMAKE_SOURCE_DIR}/test/common
-                                  ${CUDA_INCLUDE_DIRS})
+        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)
@@ -131,8 +126,9 @@ set(LIB_DIRS ${LIBHWLOC_LIBRARY_DIRS})
 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()
diff --git a/benchmark/benchmark.cpp b/benchmark/benchmark.cpp
index f57c0d5ae4..d4375fe9d1 100644
--- a/benchmark/benchmark.cpp
+++ b/benchmark/benchmark.cpp
@@ -6,10 +6,12 @@
  *
  */
 
-#include <benchmark/benchmark.h>
-
 #include "benchmark.hpp"
 
+#include <iostream>
+
+#include <benchmark/benchmark.h>
+
 #define UMF_BENCHMARK_TEMPLATE_DEFINE(BaseClass, Method, ...)                  \
     BENCHMARK_TEMPLATE_DEFINE_F(BaseClass, Method, __VA_ARGS__)                \
     (benchmark::State & state) {                                               \
@@ -31,10 +33,8 @@
 // Refer to the 'argsName()' function in each component to find detailed descriptions of these arguments.
 
 static void multithreaded(benchmark::internal::Benchmark *benchmark) {
-    benchmark->Threads(12);
-    benchmark->Threads(8);
-    benchmark->Threads(4);
     benchmark->Threads(1);
+    benchmark->Threads(4);
 }
 
 static void singlethreaded(benchmark::internal::Benchmark *benchmark) {
@@ -143,79 +143,123 @@ UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark,
 UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark,
                          proxy_pool_fixedprovider)
     ->Apply(&default_multiple_alloc_fix_size)
-    ->Apply(&singlethreaded);
+    ->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);
+    ->Apply(&singlethreaded)
+    // reduce iterations, to match os_provider benchmark
+    ->Iterations(50000);
 
-UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark,
-                              disjoint_pool_fix_fixedprovider, fixed_alloc_size,
-                              pool_allocator<disjoint_pool<fixed_provider>>);
-UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark,
-                         disjoint_pool_fix_fixedprovider)
+// 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(multiple_malloc_free_benchmark,
-                              disjoint_pool_uniform_fixedprovider,
+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<fixed_provider>>);
-UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark,
-                         disjoint_pool_uniform_fixedprovider)
+                              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(multiple_malloc_free_benchmark,
-                              jemalloc_pool_fixedprovider, fixed_alloc_size,
-                              pool_allocator<jemalloc_pool<fixed_provider>>);
-UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark,
-                         jemalloc_pool_fixedprovider)
+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(multiple_malloc_free_benchmark,
-                              jemalloc_pool_uniform_fixedprovider,
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, jemalloc_pool_uniform,
                               uniform_alloc_size,
-                              pool_allocator<jemalloc_pool<fixed_provider>>);
-UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark,
-                         jemalloc_pool_uniform_fixedprovider)
+                              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
+
+// stacked pool benchmarks
+
 UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark,
-                              scalable_pool_fix_fixedprovider, fixed_alloc_size,
-                              pool_allocator<scalable_pool<fixed_provider>>);
+                              disjoint_pool_stack_fix, fixed_alloc_size,
+                              pool_stacked_allocator<os_provider>);
 
 UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark,
-                         scalable_pool_fix_fixedprovider)
+                         disjoint_pool_stack_fix)
     ->Apply(&default_multiple_alloc_fix_size)
     ->Apply(&multithreaded);
 
 UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark,
-                              scalable_pool_uniform_fixedprovider,
-                              uniform_alloc_size,
-                              pool_allocator<scalable_pool<fixed_provider>>);
-
+                              disjoint_pool_stack_uniform, uniform_alloc_size,
+                              pool_stacked_allocator<os_provider>);
 UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark,
-                         scalable_pool_uniform_fixedprovider)
+                         disjoint_pool_stack_uniform)
     ->Apply(&default_multiple_alloc_uniform_size)
     ->Apply(&multithreaded);
 
-#endif
+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 a960d89bca..201c9e3825 100644
--- a/benchmark/benchmark.hpp
+++ b/benchmark/benchmark.hpp
@@ -70,8 +70,10 @@
  * - Additional benchmarking scenarios can be created by extending `benchmark_interface`.
  */
 
+#include <list>
 #include <malloc.h>
 #include <random>
+#include <stdexcept>
 
 #include <benchmark/benchmark.h>
 #include <umf/memory_pool.h>
@@ -86,6 +88,7 @@ struct alloc_data {
 };
 
 struct next_alloc_data {
+    bool alloc; // true if allocation, false if deallocation
     size_t offset;
     size_t size;
 };
@@ -173,6 +176,14 @@ class provider_allocator : public allocator_interface {
         return argPos;
     }
 
+    void preBench(::benchmark::State &state) override {
+        provider.preBench(state);
+    }
+
+    void postBench(::benchmark::State &state) override {
+        provider.postBench(state);
+    }
+
     void TearDown(::benchmark::State &state) override {
         provider.TearDown(state);
     }
@@ -199,12 +210,22 @@ class provider_allocator : public allocator_interface {
 // 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 argPos) override {
+    virtual unsigned SetUp(::benchmark::State &state,
+                           unsigned argPos) override {
         pool.SetUp(state);
         return argPos;
     }
 
-    void TearDown(::benchmark::State &state) override { pool.TearDown(state); }
+    virtual void preBench(::benchmark::State &state) override {
+        pool.preBench(state);
+    }
+    virtual void postBench(::benchmark::State &state) override {
+        pool.postBench(state);
+    }
+
+    virtual void TearDown(::benchmark::State &state) override {
+        pool.TearDown(state);
+    }
 
     virtual void *benchAlloc(size_t size) override {
         return umfPoolMalloc(pool.pool, size);
@@ -216,10 +237,44 @@ template <typename Pool> class pool_allocator : public allocator_interface {
 
     static std::string name() { return Pool::name(); }
 
-  private:
+  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;
+    }
+
+    void benchFree(void *ptr, [[maybe_unused]] size_t size) override {
+        umfFree(ptr);
+    }
+};
+
 template <typename Size, typename Allocator>
 struct benchmark_interface : public benchmark::Fixture {
     int parseArgs(::benchmark::State &state, int argPos) {
@@ -241,7 +296,7 @@ struct benchmark_interface : public benchmark::Fixture {
         allocator.TearDown(state);
     }
 
-    virtual void bench(::benchmark::State &state) = 0;
+    void bench([[maybe_unused]] ::benchmark::State &state){};
 
     virtual std::vector<std::string> argsName() {
         auto s = Size::argsName();
@@ -260,6 +315,9 @@ struct benchmark_interface : public benchmark::Fixture {
         benchmark->ArgNames(bench->argsName())->Name(bench->name());
     }
 
+    void custom_counters(::benchmark::State &state) {
+        allocator.custom_counters(state);
+    }
     std::vector<Size> alloc_sizes;
     Allocator allocator;
 };
@@ -272,20 +330,22 @@ template <
     typename =
         std::enable_if_t<std::is_base_of<allocator_interface, Alloc>::value>>
 class multiple_malloc_free_benchmark : public benchmark_interface<Size, Alloc> {
-    using distribution = std::uniform_int_distribution<size_t>;
+  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;
-    std::vector<unsigned> iters;
-
     vector2d<next_alloc_data> next;
-    std::vector<std::vector<next_alloc_data>::const_iterator> next_iter;
+    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:
     void SetUp(::benchmark::State &state) override {
@@ -323,13 +383,38 @@ class multiple_malloc_free_benchmark : public benchmark_interface<Size, Alloc> {
         waitForAllThreads(state);
         // prepare workload for actual benchmark.
         freeAllocs(state);
+
         prealloc(state);
         prepareWorkload(state);
+        waitForAllThreads(state);
+        base::allocator.preBench(state);
     }
 
     void TearDown(::benchmark::State &state) override {
+        base::allocator.postBench(state);
         auto tid = state.thread_index();
+        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");
+            }
+        }
+
+        waitForAllThreads(state);
         freeAllocs(state);
         waitForAllThreads(state);
         if (tid == 0) {
@@ -337,24 +422,28 @@ class multiple_malloc_free_benchmark : public benchmark_interface<Size, Alloc> {
             next.clear();
             next_iter.clear();
             allocations.clear();
-            iters.clear();
         }
         base::TearDown(state);
     }
 
-    void bench(benchmark::State &state) override {
+    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 = *next_iter[tid]++;
+            auto &n = *(*iter)++;
             auto &alloc = allocation[n.offset];
-            base::allocator.benchFree(alloc.ptr, alloc.size);
-
-            alloc.size = n.size;
-            alloc.ptr = base::allocator.benchAlloc(alloc.size);
-
-            if (alloc.ptr == NULL) {
-                state.SkipWithError("allocation failed");
+            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;
             }
         }
     }
@@ -372,12 +461,14 @@ class multiple_malloc_free_benchmark : public benchmark_interface<Size, Alloc> {
     }
 
   private:
-    void prealloc(benchmark::State &state) {
+    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];
-        for (size_t j = 0; j < max_allocs; j++) {
+
+        // 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) {
@@ -400,20 +491,173 @@ class multiple_malloc_free_benchmark : public benchmark_interface<Size, Alloc> {
         }
     }
 
-    void prepareWorkload(benchmark::State &state) {
+    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;
+        distribution dist_offset(0, max_allocs - 1);
+        distribution dist_opt_type(0, 1);
         generator.seed(0);
-        dist.param(distribution::param_type(0, max_allocs - 1));
+
         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++);
+        }
 
         n.clear();
         for (int64_t j = 0; j < state.max_iterations * allocsPerIterations;
              j++) {
-            n.push_back({dist(generator), sizeGenerator.nextSize()});
+            // 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] = n.cbegin();
+
+        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>;
+
+  public:
+    peak_alloc_benchmark() : base(false) {}
+
+    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);
+        }
+
+        // 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());
+    }
+
+    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:
+    // 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_umf.hpp b/benchmark/benchmark_umf.hpp
index cfc9982d2c..d2d41b84b4 100644
--- a/benchmark/benchmark_umf.hpp
+++ b/benchmark/benchmark_umf.hpp
@@ -9,10 +9,9 @@
 #include <thread>
 
 #include <benchmark/benchmark.h>
+#include <umf/experimental/ctl.h>
 #include <umf/memory_pool.h>
 #include <umf/memory_provider.h>
-
-#include <benchmark/benchmark.h>
 #include <umf/pools/pool_disjoint.h>
 #include <umf/pools/pool_proxy.h>
 
@@ -30,7 +29,7 @@ struct provider_interface {
     using params_ptr = std::unique_ptr<void, void (*)(void *)>;
 
     umf_memory_provider_handle_t provider = NULL;
-    virtual void SetUp(::benchmark::State &state) {
+    void SetUp(::benchmark::State &state) {
         if (state.thread_index() != 0) {
             return;
         }
@@ -42,7 +41,29 @@ struct provider_interface {
         }
     }
 
-    virtual void TearDown([[maybe_unused]] ::benchmark::State &state) {
+    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;
         }
@@ -52,10 +73,8 @@ struct provider_interface {
         }
     }
 
-    virtual umf_memory_provider_ops_t *
-    getOps([[maybe_unused]] ::benchmark::State &state) {
-        return nullptr;
-    }
+    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 *) {}};
@@ -68,7 +87,7 @@ template <typename T,
 struct pool_interface {
     using params_ptr = std::unique_ptr<void, void (*)(void *)>;
 
-    virtual void SetUp(::benchmark::State &state) {
+    void SetUp(::benchmark::State &state) {
         provider.SetUp(state);
         if (state.thread_index() != 0) {
             return;
@@ -80,7 +99,22 @@ struct pool_interface {
             state.SkipWithError("umfPoolCreate() failed");
         }
     }
-    virtual void TearDown([[maybe_unused]] ::benchmark::State &state) {
+
+    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;
         }
@@ -93,15 +127,17 @@ struct pool_interface {
         if (pool) {
             umfPoolDestroy(pool);
         }
+
+        provider.TearDown(state);
     };
 
-    virtual umf_memory_pool_ops_t *
-    getOps([[maybe_unused]] ::benchmark::State &state) {
-        return nullptr;
-    }
+    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;
 };
@@ -110,6 +146,8 @@ 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;
@@ -121,7 +159,9 @@ struct glibc_malloc : public allocator_interface {
                    unsigned argPos) override {
         return argPos;
     }
-    void TearDown([[maybe_unused]] ::benchmark::State &state) override{};
+    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);
@@ -151,7 +191,7 @@ struct os_provider : public provider_interface {
                 deleter};
     }
 
-    umf_memory_provider_ops_t *
+    const umf_memory_provider_ops_t *
     getOps([[maybe_unused]] ::benchmark::State &state) override {
         return umfOsMemoryProviderOps();
     }
@@ -163,7 +203,7 @@ struct fixed_provider : public provider_interface {
     char *mem = NULL;
     const size_t size = 1024 * 1024 * 1024; // 1GB
   public:
-    virtual void SetUp(::benchmark::State &state) override {
+    void SetUp(::benchmark::State &state) {
         if (state.thread_index() != 0) {
             return;
         }
@@ -175,7 +215,7 @@ struct fixed_provider : public provider_interface {
         provider_interface::SetUp(state);
     }
 
-    virtual void TearDown(::benchmark::State &state) override {
+    void TearDown(::benchmark::State &state) {
         if (state.thread_index() != 0) {
             return;
         }
@@ -189,7 +229,7 @@ struct fixed_provider : public provider_interface {
     provider_interface::params_ptr
     getParams(::benchmark::State &state) override {
         umf_fixed_memory_provider_params_handle_t raw_params = nullptr;
-        umfFixedMemoryProviderParamsCreate(&raw_params, mem, size);
+        umfFixedMemoryProviderParamsCreate(mem, size, &raw_params);
         if (!raw_params) {
             state.SkipWithError("Failed to create fixed provider params");
             return {nullptr, [](void *) {}};
@@ -207,7 +247,7 @@ struct fixed_provider : public provider_interface {
                 deleter};
     }
 
-    umf_memory_provider_ops_t *
+    const umf_memory_provider_ops_t *
     getOps([[maybe_unused]] ::benchmark::State &state) override {
         return umfFixedMemoryProviderOps();
     }
@@ -216,7 +256,7 @@ struct fixed_provider : public provider_interface {
 
 template <typename Provider>
 struct proxy_pool : public pool_interface<Provider> {
-    umf_memory_pool_ops_t *
+    const umf_memory_pool_ops_t *
     getOps([[maybe_unused]] ::benchmark::State &state) override {
         return umfProxyPoolOps();
     }
@@ -226,7 +266,7 @@ struct proxy_pool : public pool_interface<Provider> {
 
 template <typename Provider>
 struct disjoint_pool : public pool_interface<Provider> {
-    umf_memory_pool_ops_t *
+    const umf_memory_pool_ops_t *
     getOps([[maybe_unused]] ::benchmark::State &state) override {
         return umfDisjointPoolOps();
     }
@@ -278,10 +318,146 @@ struct disjoint_pool : public pool_interface<Provider> {
     }
 };
 
+// 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> {
-    umf_memory_pool_ops_t *
+    const umf_memory_pool_ops_t *
     getOps([[maybe_unused]] ::benchmark::State &state) override {
         return umfJemallocPoolOps();
     }
@@ -295,7 +471,7 @@ struct jemalloc_pool : public pool_interface<Provider> {
 #ifdef UMF_POOL_SCALABLE_ENABLED
 template <typename Provider>
 struct scalable_pool : public pool_interface<Provider> {
-    virtual umf_memory_pool_ops_t *
+    const umf_memory_pool_ops_t *
     getOps([[maybe_unused]] ::benchmark::State &state) override {
         return umfScalablePoolOps();
     }
diff --git a/benchmark/multithread.cpp b/benchmark/multithread.cpp
index d00ffba907..fac2d063a3 100644
--- a/benchmark/multithread.cpp
+++ b/benchmark/multithread.cpp
@@ -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;
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 2dab1f3833..524191dcac 100644
--- a/cmake/FindJEMALLOC.cmake
+++ b/cmake/FindJEMALLOC.cmake
@@ -23,7 +23,7 @@ else()
     if(JEMALLOC_FIND_REQUIRED)
         message(FATAL_ERROR ${MSG_NOT_FOUND})
     else()
-        message(WARNING ${MSG_NOT_FOUND})
+        message(STATUS ${MSG_NOT_FOUND})
     endif()
 endif()
 
@@ -34,6 +34,7 @@ if(WINDOWS)
 endif()
 
 if(JEMALLOC_LIBRARY)
+    set(JEMALLOC_FOUND TRUE)
     message(STATUS "  Found jemalloc using find_library()")
 else()
     set(MSG_NOT_FOUND
@@ -41,6 +42,6 @@ else()
     if(JEMALLOC_FIND_REQUIRED)
         message(FATAL_ERROR ${MSG_NOT_FOUND})
     else()
-        message(WARNING ${MSG_NOT_FOUND})
+        message(STATUS ${MSG_NOT_FOUND})
     endif()
 endif()
diff --git a/cmake/FindLIBHWLOC.cmake b/cmake/FindLIBHWLOC.cmake
index 2efd072d4d..f9d1dfe389 100644
--- a/cmake/FindLIBHWLOC.cmake
+++ b/cmake/FindLIBHWLOC.cmake
@@ -55,6 +55,7 @@ if(WINDOWS)
 endif()
 
 if(LIBHWLOC_LIBRARY)
+    set(LIBHWLOC_FOUND TRUE)
     message(STATUS "  Found libhwloc: ${LIBHWLOC_LIBRARY}")
 
     if(LIBHWLOC_FIND_VERSION)
@@ -76,6 +77,6 @@ else()
     if(LIBHWLOC_FIND_REQUIRED)
         message(FATAL_ERROR ${MSG_NOT_FOUND})
     else()
-        message(WARNING ${MSG_NOT_FOUND})
+        message(STATUS ${MSG_NOT_FOUND})
     endif()
 endif()
diff --git a/cmake/FindLIBNUMA.cmake b/cmake/FindLIBNUMA.cmake
index 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 02aaf5c71e..8ee14bd377 100644
--- a/cmake/helpers.cmake
+++ b/cmake/helpers.cmake
@@ -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"
@@ -225,7 +243,8 @@ endfunction()
 
 function(add_umf_target_compile_options name)
     check_add_target_compile_options(${name} "-Wno-covered-switch-default")
-
+    target_compile_definitions(${name}
+                               PRIVATE ${UMF_COMMON_COMPILE_DEFINITIONS})
     if(NOT MSVC)
         target_compile_options(
             ${name}
@@ -260,6 +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,6 +409,7 @@ function(add_umf_library)
     target_include_directories(
         ${ARG_NAME}
         PRIVATE ${UMF_CMAKE_SOURCE_DIR}/include
+                ${UMF_CMAKE_SOURCE_DIR}/src
                 ${UMF_CMAKE_SOURCE_DIR}/src/utils
                 ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc
                 ${UMF_CMAKE_SOURCE_DIR}/src/coarse)
diff --git a/docs/config/Doxyfile b/docs/config/Doxyfile
index 6309463745..9c520d46ce 100644
--- a/docs/config/Doxyfile
+++ b/docs/config/Doxyfile
@@ -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.
diff --git a/docs/config/api.rst b/docs/config/api.rst
index 97e664d97f..609ffc147c 100644
--- a/docs/config/api.rst
+++ b/docs/config/api.rst
@@ -136,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             
@@ -146,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
@@ -156,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
 ==========================================
 
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/docs/config/examples.rst b/docs/config/examples.rst
index 4eeea6aa95..28b6ab02e7 100644
--- a/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.
@@ -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/docs/config/index.rst b/docs/config/index.rst
index 3bd20828ff..4447dcd74b 100644
--- a/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/docs/config/spelling_exceptions.txt b/docs/config/spelling_exceptions.txt
index d4e40a3ec8..f329b7c6f3 100644
--- a/docs/config/spelling_exceptions.txt
+++ b/docs/config/spelling_exceptions.txt
@@ -3,22 +3,24 @@ allocatable
 allocator
 allocators
 calloc
-CXL
 copyable
+CUcontext
+CUdevice
 customizable
+CXL
 daxX
-deallocation
 deallocating
+deallocation
 deallocations
-Devdax
 dev
+Devdax
 Globals
+highPtr
 hMemtarget
 hPool
 hProvider
-highPtr
-io
 interprocess
+io
 ipc
 jemalloc
 lowPtr
@@ -35,6 +37,7 @@ Memtarget
 memtarget
 memtargets
 middleware
+minBytesToKeep
 multithreading
 Nodemask
 nodemask
@@ -47,21 +50,29 @@ partList
 pid
 poolable
 preallocated
-providerIpcData
+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
@@ -71,4 +82,8 @@ umfPoolMallocUsableSize
 umfPoolRealloc
 umfMemspaceUserFilter
 umfMemspaceMemtargetAdd
-unfreed
\ No newline at end of file
+unfreed
+usm
+wildcarded
+zA
+ze
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 8bb3527876..c79e950ed2 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -41,7 +41,7 @@ if(UMF_POOL_SCALABLE_ENABLED)
     endif()
 endif()
 
-if(UMF_BUILD_GPU_EXAMPLES 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(
@@ -56,7 +56,8 @@ if(UMF_BUILD_GPU_EXAMPLES AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
                 ${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}
@@ -70,25 +71,13 @@ if(UMF_BUILD_GPU_EXAMPLES AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
         set_property(TEST ${EXAMPLE_NAME} PROPERTY ENVIRONMENT_MODIFICATION
                                                    "${DLL_PATH_LIST}")
     endif()
-    if(LINUX)
-        # prepend LD_LIBRARY_PATH with ${CMAKE_BINARY_DIR}/lib it is required
-        # because ${CMAKE_BINARY_DIR}/lib contains libze_loader.so and tests
-        # should use it instead of system one.
-        set_property(
-            TEST ${EXAMPLE_NAME}
-            PROPERTY ENVIRONMENT_MODIFICATION
-                     "LD_LIBRARY_PATH=path_list_prepend:${CMAKE_BINARY_DIR}/lib"
-        )
-    endif()
 else()
     message(STATUS "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_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(
@@ -127,7 +116,7 @@ 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_LEVEL_ZERO_PROVIDER
+   AND UMF_LEVEL_ZERO_ENABLED
    AND LINUX)
     set(EXAMPLE_NAME umf_example_ipc_level_zero)
 
@@ -143,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}
@@ -157,16 +147,6 @@ if(UMF_BUILD_GPU_EXAMPLES
         set_property(TEST ${EXAMPLE_NAME} PROPERTY ENVIRONMENT_MODIFICATION
                                                    "${DLL_PATH_LIST}")
     endif()
-    if(LINUX)
-        # prepend LD_LIBRARY_PATH with ${CMAKE_BINARY_DIR}/lib it is required
-        # because ${CMAKE_BINARY_DIR}/lib contains libze_loader.so and tests
-        # should use it instead of system one.
-        set_property(
-            TEST ${EXAMPLE_NAME}
-            PROPERTY ENVIRONMENT_MODIFICATION
-                     "LD_LIBRARY_PATH=path_list_prepend:${CMAKE_BINARY_DIR}/lib"
-        )
-    endif()
 else()
     message(
         STATUS
@@ -293,6 +273,42 @@ 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)
 
diff --git a/examples/README.md b/examples/README.md
index 70d114a63a..4f16e19067 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -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 e6db190d4a..6cd1ffedea 100644
--- a/examples/cmake/FindJEMALLOC.cmake
+++ b/examples/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
 
@@ -36,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 0e57ec6077..d6aa60dad8 100644
--- a/examples/cuda_shared_memory/CMakeLists.txt
+++ b/examples/cuda_shared_memory/CMakeLists.txt
@@ -21,42 +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++ ${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(
@@ -68,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 a442fca6ad..1ba934a589 100644
--- a/examples/custom_file_provider/custom_file_provider.c
+++ b/examples/custom_file_provider/custom_file_provider.c
@@ -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;
 
@@ -104,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
@@ -200,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
@@ -224,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;
@@ -291,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;
@@ -318,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/dram_and_fsdax.c b/examples/dram_and_fsdax/dram_and_fsdax.c
index 970242e109..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;
@@ -97,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_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 9082302ac9..a5c7918512 100644
--- a/examples/ipc_ipcapi/ipc_ipcapi_producer.c
+++ b/examples/ipc_ipcapi/ipc_ipcapi_producer.c
@@ -125,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;
     }
 
diff --git a/examples/ipc_level_zero/CMakeLists.txt b/examples/ipc_level_zero/CMakeLists.txt
index 2aa391d655..726ced3f12 100644
--- a/examples/ipc_level_zero/CMakeLists.txt
+++ b/examples/ipc_level_zero/CMakeLists.txt
@@ -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.20.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++ 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_prepend:${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 87dbbd0226..df0f26c45d 100644
--- a/examples/ipc_level_zero/ipc_level_zero.c
+++ b/examples/ipc_level_zero/ipc_level_zero.c
@@ -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,
diff --git a/examples/level_zero_shared_memory/CMakeLists.txt b/examples/level_zero_shared_memory/CMakeLists.txt
index b7c990145b..3fd8da5ab6 100644
--- a/examples/level_zero_shared_memory/CMakeLists.txt
+++ b/examples/level_zero_shared_memory/CMakeLists.txt
@@ -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.20.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++ 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_prepend:${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 7cfe89366c..605f239f85 100644
--- a/examples/level_zero_shared_memory/level_zero_shared_memory.c
+++ b/examples/level_zero_shared_memory/level_zero_shared_memory.c
@@ -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;
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 57bebef8a9..5fe18b8d9a 100644
--- a/include/umf.h
+++ b/include/umf.h
@@ -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 12e99aa2bb..11d7b723b4 100644
--- a/include/umf/base.h
+++ b/include/umf/base.h
@@ -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, 11)
+#define UMF_VERSION_CURRENT UMF_MAKE_VERSION(1, 0)
 
 /// @brief Operation results
 typedef enum umf_result_t {
@@ -48,9 +48,53 @@ typedef enum umf_result_t {
     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_UNKNOWN = 0x7ffffffe  ///< Unknown error
+    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 100%
rename from include/umf/memtarget.h
rename to include/umf/experimental/memtarget.h
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 ed3d1eb0dc..5662684fa7 100644
--- a/include/umf/memory_pool.h
+++ b/include/umf/memory_pool.h
@@ -10,6 +10,8 @@
 #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>
@@ -41,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
@@ -104,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
@@ -151,20 +155,30 @@ 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
@@ -181,6 +195,24 @@ umf_result_t umfPoolSetTag(umf_memory_pool_handle_t hPool, void *tag,
 /// @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 657f40aeaa..8a16e8fc69 100644
--- a/include/umf/memory_pool_ops.h
+++ b/include/umf/memory_pool_ops.h
@@ -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>
 
@@ -20,7 +22,7 @@ extern "C" {
 /// @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(0, 11)
+#define UMF_POOL_OPS_VERSION_CURRENT UMF_MAKE_VERSION(1, 1)
 
 ///
 /// @brief This structure comprises function pointers used by corresponding umfPool*
@@ -34,21 +36,20 @@ typedef struct umf_memory_pool_ops_t {
 
     ///
     /// @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
@@ -92,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
@@ -104,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
@@ -125,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 aaddd503b7..80fb28860d 100644
--- a/include/umf/memory_provider_ops.h
+++ b/include/umf/memory_provider_ops.h
@@ -10,6 +10,8 @@
 #ifndef UMF_MEMORY_PROVIDER_OPS_H
 #define UMF_MEMORY_PROVIDER_OPS_H 1
 
+#include <stdarg.h>
+
 #include <umf/base.h>
 
 #ifdef __cplusplus
@@ -19,14 +21,127 @@ extern "C" {
 /// @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(0, 11)
+#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
+    /// @param ptr pointer to the allocated memory to free
+    /// @param size size of the allocation
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure
+    ///
+    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.
@@ -37,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.
@@ -49,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
@@ -64,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
@@ -80,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.
@@ -107,149 +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_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)(void *params, void **provider);
+    umf_result_t (*ext_close_ipc_handle)(void *provider, void *ptr,
+                                         size_t size);
 
     ///
-    /// @brief Finalizes memory provider.
-    /// @param provider provider to finalize
-    ///
-    void (*finalize)(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 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);
+    // The following operations were added in ops version 1.1
 
     ///
-    /// @brief Frees the memory space pointed by \p ptr from the memory \p provider
+    /// @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 ptr pointer to the allocated memory to free
-    /// @param size size of the allocation
+    /// @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 (*free)(void *provider, void *ptr, size_t size);
+    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.
-    /// @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.
+    ///     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 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 a1558b85bf..1758fee894 100644
--- a/include/umf/pools/pool_disjoint.h
+++ b/include/umf/pools/pool_disjoint.h
@@ -7,7 +7,9 @@
  *
  */
 
-#pragma once
+#ifndef UMF_DISJOINT_MEMORY_POOL_H
+#define UMF_DISJOINT_MEMORY_POOL_H 1
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -29,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.
@@ -51,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.
@@ -59,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.
@@ -67,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.
@@ -75,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.
@@ -83,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.
@@ -100,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. Name longer than 64 characters will be truncated.
+/// @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 5974e6440a..f7c881b6cb 100644
--- a/include/umf/pools/pool_jemalloc.h
+++ b/include/umf/pools/pool_jemalloc.h
@@ -16,7 +16,45 @@ extern "C" {
 
 #include <umf/memory_pool_ops.h>
 
-umf_memory_pool_ops_t *umfJemallocPoolOps(void);
+struct umf_jemalloc_pool_params_t;
+
+/// @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 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.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfJemallocPoolParamsDestroy(umf_jemalloc_pool_params_handle_t hParams);
+
+/// @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
+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);
+
+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 1915ad0b7a..749cd8a398 100644
--- a/include/umf/pools/pool_scalable.h
+++ b/include/umf/pools/pool_scalable.h
@@ -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_cuda.h b/include/umf/providers/provider_cuda.h
index 95f2634fbc..dbed42219d 100644
--- a/include/umf/providers/provider_cuda.h
+++ b/include/umf/providers/provider_cuda.h
@@ -5,8 +5,8 @@
  * 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>
 
@@ -61,10 +61,20 @@ umf_result_t umfCUDAMemoryProviderParamsSetMemoryType(
 umf_result_t umfCUDAMemoryProviderParamsSetAllocFlags(
     umf_cuda_memory_provider_params_handle_t hParams, unsigned int flags);
 
-umf_memory_provider_ops_t *umfCUDAMemoryProviderOps(void);
+/// @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
index 2351faf312..fcedd5c005 100644
--- a/include/umf/providers/provider_fixed_memory.h
+++ b/include/umf/providers/provider_fixed_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_FIXED_MEMORY_PROVIDER_H
 #define UMF_FIXED_MEMORY_PROVIDER_H
 
-#include <umf/providers/provider_os_memory.h>
+#include <umf/memory_provider.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -24,12 +24,12 @@ 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  hParams [out] handle to the newly created parameters struct.
 /// @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(
-    umf_fixed_memory_provider_params_handle_t *hParams, void *ptr, size_t size);
+    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
@@ -49,7 +49,17 @@ umf_result_t umfFixedMemoryProviderParamsDestroy(
 
 /// @brief Retrieve the operations structure for the Fixed Memory Provider.
 /// @return Pointer to the umf_memory_provider_ops_t structure.
-umf_memory_provider_ops_t *umfFixedMemoryProviderOps(void);
+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 {
diff --git a/include/umf/providers/provider_level_zero.h b/include/umf/providers/provider_level_zero.h
index b20fb40d59..22c3513351 100644
--- a/include/umf/providers/provider_level_zero.h
+++ b/include/umf/providers/provider_level_zero.h
@@ -5,8 +5,10 @@
  * 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>
 
@@ -91,10 +93,31 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(
     umf_level_zero_memory_provider_params_handle_t hParams,
     uint32_t deviceOrdinal);
 
-umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void);
+/// @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 90455cad19..93a20173cf 100644
--- a/include/umf/providers/provider_os_memory.h
+++ b/include/umf/providers/provider_os_memory.h
@@ -10,7 +10,7 @@
 #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" {
@@ -134,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
@@ -146,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/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/src/CMakeLists.txt b/src/CMakeLists.txt
index 24beb1e0ae..45046fdc6d 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -30,45 +30,24 @@ set(UMF_COMMON_COMPILE_DEFINITIONS
     ${UMF_COMMON_COMPILE_DEFINITIONS} UMF_VERSION=${UMF_VERSION}
     UMF_ALL_CMAKE_VARIABLES="${UMF_ALL_CMAKE_VARIABLES}")
 
-set(BA_SOURCES
-    ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_linear.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_global.c)
-
 add_subdirectory(utils)
+add_subdirectory(base_alloc)
 add_subdirectory(coarse)
 
-set(UMF_LIBS $<BUILD_INTERFACE:umf_utils> $<BUILD_INTERFACE:coarse>)
-
-set(CTL_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/ctl/ctl.c)
-
-if(LINUX)
-    set(BA_SOURCES ${BA_SOURCES}
-                   ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_linux.c)
-elseif(WINDOWS)
-    set(BA_SOURCES ${BA_SOURCES}
-                   ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_windows.c)
-elseif(MACOSX)
-    set(BA_SOURCES ${BA_SOURCES}
-                   ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_linux.c)
-endif()
-
-set(BA_SOURCES
-    ${BA_SOURCES}
-    PARENT_SCOPE)
-
-set(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_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
@@ -88,7 +67,8 @@ set(UMF_SOURCES
     pool/pool_disjoint.c
     pool/pool_jemalloc.c
     pool/pool_proxy.c
-    pool/pool_scalable.c)
+    pool/pool_scalable.c
+    topology.c)
 
 if(UMF_POOL_JEMALLOC_ENABLED)
     set(UMF_LIBS ${UMF_LIBS} ${JEMALLOC_LIBRARIES})
@@ -100,35 +80,29 @@ if(UMF_POOL_JEMALLOC_ENABLED)
                                        "UMF_POOL_JEMALLOC_ENABLED=1")
 endif()
 
-if(NOT UMF_DISABLE_HWLOC)
-    set(UMF_SOURCES ${UMF_SOURCES} ${HWLOC_DEPENDENT_SOURCES}
-                    memtargets/memtarget_numa.c)
-    set(UMF_LIBS ${UMF_LIBS} $<BUILD_INTERFACE:${UMF_HWLOC_NAME}>)
-    set(UMF_PRIVATE_LIBRARY_DIRS ${UMF_PRIVATE_LIBRARY_DIRS}
-                                 ${LIBHWLOC_LIBRARY_DIRS})
-else()
-    set(UMF_COMMON_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS}
-                                       "UMF_NO_HWLOC=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)
@@ -176,7 +150,7 @@ target_include_directories(umf PRIVATE ${UMF_PRIVATE_INCLUDE_DIRS})
 target_link_directories(umf PRIVATE ${UMF_PRIVATE_LIBRARY_DIRS})
 target_compile_definitions(umf PRIVATE ${UMF_COMMON_COMPILE_DEFINITIONS})
 
-add_dependencies(umf coarse)
+add_dependencies(umf umf_ba umf_coarse umf_utils)
 
 if(UMF_LINK_HWLOC_STATICALLY)
     add_dependencies(umf ${UMF_HWLOC_NAME})
@@ -198,24 +172,6 @@ if(NOT WINDOWS AND UMF_POOL_JEMALLOC_ENABLED)
     add_dependencies(umf jemalloc)
 endif()
 
-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_COMPILE_DEFINITIONS ${UMF_COMPILE_DEFINITIONS}
-                                "UMF_BUILD_LEVEL_ZERO_PROVIDER=1")
-endif()
-
-if(UMF_BUILD_CUDA_PROVIDER)
-    set(UMF_COMPILE_DEFINITIONS ${UMF_COMPILE_DEFINITIONS}
-                                "UMF_BUILD_CUDA_PROVIDER=1")
-endif()
-
 add_library(${PROJECT_NAME}::umf ALIAS umf)
 
 if(LIBHWLOC_INCLUDE_DIRS)
@@ -244,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 00e58078e6..9f254e6758 100644
--- a/src/base_alloc/base_alloc.c
+++ b/src/base_alloc/base_alloc.c
@@ -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);
 }
 
@@ -304,12 +311,14 @@ void umf_ba_destroy(umf_ba_pool_t *pool) {
 #ifndef NDEBUG
     ba_debug_checks(pool);
     if (pool->metadata.n_allocs) {
-        LOG_ERR("number of base allocator memory leaks: %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 ecec3367c9..c7c4e22758 100644
--- a/src/base_alloc/base_alloc_global.c
+++ b/src/base_alloc/base_alloc_global.c
@@ -41,6 +41,7 @@ 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++) {
@@ -73,7 +74,8 @@ static void umf_ba_create_global(void) {
     size_t smallestSize = BASE_ALLOC.ac_sizes[0];
     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
@@ -130,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);
 
@@ -184,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,
@@ -218,12 +234,18 @@ void umf_ba_global_free(void *ptr) {
 
     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;
     }
@@ -233,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;
     }
@@ -243,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 bd55d352ff..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
@@ -20,8 +20,9 @@ void *umf_ba_global_alloc(size_t size);
 void umf_ba_global_free(void *ptr);
 void umf_ba_destroy_global(void);
 bool umf_ba_global_is_destroyed(void);
-size_t umf_ba_global_malloc_usable_size(void *ptr);
+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/coarse/CMakeLists.txt b/src/coarse/CMakeLists.txt
index c211f9a7bf..32465b4e4f 100644
--- a/src/coarse/CMakeLists.txt
+++ b/src/coarse/CMakeLists.txt
@@ -4,23 +4,21 @@
 
 include(${UMF_CMAKE_SOURCE_DIR}/cmake/helpers.cmake)
 
-set(COARSE_SOURCES coarse.c ../ravl/ravl.c)
-
-if(UMF_BUILD_SHARED_LIBRARY AND (NOT WINDOWS))
-    set(COARSE_EXTRA_SRCS ${BA_SOURCES})
-    set(COARSE_EXTRA_LIBS $<BUILD_INTERFACE:umf_utils>)
-endif()
+set(UMF_COARSE_SOURCES coarse.c ${UMF_CMAKE_SOURCE_DIR}/src/ravl/ravl.c)
+set(UMF_COARSE_LIBS umf_utils umf_ba)
 
 add_umf_library(
-    NAME coarse
+    NAME umf_coarse
     TYPE STATIC
-    SRCS ${COARSE_SOURCES} ${COARSE_EXTRA_SRCS}
-    LIBS ${COARSE_EXTRA_LIBS})
+    SRCS ${UMF_COARSE_SOURCES}
+    LIBS ${UMF_COARSE_LIBS})
 
 target_include_directories(
-    coarse
-    PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
-            $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>
-            $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src/ravl>)
+    umf_coarse
+    PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/coarse
+            ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc
+            ${UMF_CMAKE_SOURCE_DIR}/src/ravl)
 
-add_library(${PROJECT_NAME}::coarse ALIAS coarse)
+if(NOT UMF_BUILD_SHARED_LIBRARY)
+    install(TARGETS umf_coarse EXPORT ${PROJECT_NAME}-targets)
+endif()
diff --git a/src/coarse/coarse.c b/src/coarse/coarse.c
index 19798466e1..a161ea5753 100644
--- a/src/coarse/coarse.c
+++ b/src/coarse/coarse.c
@@ -130,7 +130,7 @@ static inline ravl_node_t *get_node_next(ravl_node_t *node) {
     return ravl_node_successor(node);
 }
 
-#ifndef NDEBUG
+#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) {
@@ -148,7 +148,7 @@ static block_t *get_block_next(ravl_node_t *node) {
 
     return get_node_block(ravl_next);
 }
-#endif /* NDEBUG */
+#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.
@@ -442,10 +442,10 @@ static umf_result_t user_block_merge(coarse_t *coarse, ravl_node_t *node1,
     assert(block1->data < block2->data);
 
     bool same_used = ((block1->used == used) && (block2->used == used));
-    bool contignous_data = (block1->data + block1->size == block2->data);
+    bool contiguous_data = (block1->data + block1->size == block2->data);
 
     // check if blocks can be merged
-    if (!same_used || !contignous_data) {
+    if (!same_used || !contiguous_data) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
@@ -528,6 +528,7 @@ static ravl_node_t *free_block_merge_with_next(coarse_t *coarse,
 }
 
 #ifndef NDEBUG // begin of DEBUG code
+#ifdef UMF_DEVELOPER_MODE
 
 typedef struct debug_cb_args_t {
     coarse_t *provider;
@@ -606,6 +607,12 @@ static bool debug_check(coarse_t *provider) {
 
     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,
@@ -623,6 +630,24 @@ static umf_result_t coarse_add_used_block(coarse_t *coarse, void *addr,
     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);
@@ -1053,88 +1078,108 @@ umf_result_t coarse_alloc(coarse_t *coarse, size_t size, size_t alignment,
 
     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 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, size, alignment, &curr);
-            if (umf_result != UMF_RESULT_SUCCESS) {
-                (void)free_blocks_re_add(coarse, curr);
-                goto err_unlock;
-            }
+    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;
         }
 
-        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;
-            }
+        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;
+        }
 
-            curr->size = size;
+        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;
+        }
 
-            LOG_DEBUG("coarse_ALLOC (split_block) %zu used %zu alloc %zu", size,
-                      coarse->used_size, coarse->alloc_size);
+        ASSERT_IS_ALIGNED(((uintptr_t)(*resultPtr)), alignment);
 
-        } else { // action == ACTION_USE
-            LOG_DEBUG("coarse_ALLOC (same_block) %zu used %zu alloc %zu", size,
-                      coarse->used_size, coarse->alloc_size);
+        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;
         }
 
-        curr->used = true;
-        *resultPtr = curr->data;
-        coarse->used_size += size;
+        LOG_DEBUG("coarse_ALLOC (memory_provider) %zu used %zu alloc %zu",
+                  size_aligned, coarse->used_size, coarse->alloc_size);
 
-        assert(debug_check(coarse));
-        utils_mutex_unlock(&coarse->lock);
-
-        return UMF_RESULT_SUCCESS;
+        curr = new_free_block;
     }
 
-    // no suitable block found - try to get more memory from the upstream provider
-    umf_result = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-
-    *resultPtr = NULL;
+    // 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 (!coarse->cb.alloc) {
+    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;
     }
 
-    umf_result = coarse->cb.alloc(coarse->provider, size, alignment, resultPtr);
-    if (umf_result != UMF_RESULT_SUCCESS) {
-        LOG_ERR("coarse_alloc_cb() failed: out of memory");
-        goto err_unlock;
-    }
+    // ACTION_SPLIT or ACTION_USE
+    assert(curr->used == false);
 
-    ASSERT_IS_ALIGNED(((uintptr_t)(*resultPtr)), alignment);
+    // 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;
+        }
+    }
 
-    umf_result = coarse_add_used_block(coarse, *resultPtr, size);
-    if (umf_result != UMF_RESULT_SUCCESS) {
-        if (coarse->cb.free) {
-            coarse->cb.free(coarse->provider, *resultPtr, size);
+    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;
         }
-        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);
     }
 
-    LOG_DEBUG("coarse_ALLOC (memory_provider) %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;
 
diff --git a/src/critnib/critnib.c b/src/critnib/critnib.c
index 7db9dd3dca..8ff5796684 100644
--- a/src/critnib/critnib.c
+++ b/src/critnib/critnib.c
@@ -89,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 {
     /*
@@ -116,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;
@@ -161,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;
@@ -175,6 +201,8 @@ struct critnib *critnib_new(void) {
         goto err_free_critnib;
     }
 
+    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));
 
@@ -189,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++) {
@@ -218,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]);
     }
 
@@ -266,6 +312,20 @@ static struct critnib_node *alloc_node(struct critnib *__restrict c) {
     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.
  *
@@ -277,21 +337,42 @@ static void free_leaf(struct critnib *__restrict c,
         return;
     }
 
-    utils_atomic_store_release_ptr((void **)&k->value, c->deleted_leaf);
-    utils_atomic_store_release_ptr((void **)&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_aligned_alloc(sizeof(struct critnib_leaf), 8);
-    }
+    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;
     utils_annotate_memory_new(k, sizeof(*k));
 
     return k;
@@ -319,8 +400,18 @@ int critnib_insert(struct critnib *c, word key, void *value, int update) {
 
     utils_annotate_memory_no_check(k, sizeof(struct critnib_leaf));
 
+    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((void **)&k->value, value);
+    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);
 
@@ -350,11 +441,22 @@ int critnib_insert(struct critnib *c, word key, void *value, int update) {
         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) {
@@ -372,12 +474,15 @@ int critnib_insert(struct critnib *c, word key, void *value, int update) {
 
     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;
     }
+
     utils_annotate_memory_no_check(m, sizeof(struct critnib_node));
 
     for (int i = 0; i < SLNODES; i++) {
@@ -386,8 +491,8 @@ int critnib_insert(struct critnib *c, word key, void *value, int update) {
 
     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);
-    m->shift = sh;
-    utils_atomic_store_release_u64((void *)&m->path, key & path_mask(sh));
+    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);
 
@@ -398,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);
 
@@ -412,6 +530,7 @@ void *critnib_remove(struct critnib *c, word key) {
 
     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;
@@ -419,7 +538,8 @@ void *critnib_remove(struct critnib *c, word key) {
 
     if (is_leaf(n)) {
         k = to_leaf(n);
-        if (k->key == key) {
+        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;
         }
@@ -446,7 +566,8 @@ 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;
     }
 
@@ -472,6 +593,11 @@ void *critnib_remove(struct critnib *c, word key) {
 
 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:
@@ -479,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
  *
@@ -488,14 +709,28 @@ 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;
+    }
 
+    do {
         utils_atomic_load_acquire_u64(&c->remove_count, &wrs1);
         utils_atomic_load_acquire_ptr((void **)&c->root, (void **)&n);
 
@@ -505,16 +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)) {
+            utils_atomic_load_acquire_u8(&n->shift, &shift);
             utils_atomic_load_acquire_ptr(
-                (void **)&n->child[slice_index(key, n->shift)], (void **)&n);
+                (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;
+        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;
 }
 
@@ -554,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;
     }
 
     /*
@@ -571,7 +825,8 @@ static struct critnib_leaf *find_le(struct critnib_node *__restrict n,
 	 * needs to be masked away as well.
 	 */
     word path;
-    sh_t shift = n->shift;
+    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) {
         /*
@@ -589,7 +844,7 @@ 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;
@@ -625,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 {
         utils_atomic_load_acquire_u64(&c->remove_count, &wrs1);
         struct critnib_node *n; /* avoid a subtle TOCTOU */
         utils_atomic_load_acquire_ptr((void **)&c->root, (void **)&n);
-        struct critnib_leaf *k = n ? find_le(n, key) : NULL;
-        res = k ? k->value : NULL;
+        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;
 }
 
@@ -677,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) {
@@ -722,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) {
@@ -759,8 +1054,11 @@ int critnib_find(struct critnib *c, uintptr_t key, enum find_dir_t dir,
                     (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) {
             utils_atomic_load_acquire_u64((uint64_t *)&k->key,
@@ -771,6 +1069,14 @@ int critnib_find(struct critnib *c, uintptr_t key, enum find_dir_t dir,
     } 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;
         }
@@ -788,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;
     }
@@ -819,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
index 4db11ac21f..2edca576a0 100644
--- a/src/ctl/ctl.c
+++ b/src/ctl/ctl.c
@@ -16,53 +16,57 @@
  *    the library's internal state
  */
 
-#include "ctl.h"
-
 #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 "utlist.h"
+#include "utils_log.h"
 
 #ifdef _WIN32
 #define strtok_r strtok_s
-#else
-#include <stdio.h>
 #endif
 
-#define CTL_MAX_ENTRIES 100
-
 #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 struct ctl_node CTL_NODE(global)[CTL_MAX_ENTRIES];
+static umf_ctl_node_t CTL_NODE(global)[CTL_MAX_ENTRIES];
 
-/*
- * 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 {
-    struct ctl_node root[CTL_MAX_ENTRIES];
-    int first_free;
-};
+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 = umf_ba_global_alloc(sz);
+    void *ptr = ctl_malloc_fn(sz);
     if (ptr) {
         memset(ptr, 0, sz);
     }
@@ -71,106 +75,101 @@ void *Zalloc(size_t sz) {
 
 char *Strdup(const char *s) {
     size_t len = strlen(s) + 1;
-    char *p = umf_ba_global_alloc(len);
+    char *p = ctl_malloc_fn(len);
     if (p) {
         memcpy(p, s, len);
     }
     return p;
 }
 
-/*
- * ctl_find_node -- (internal) searches for a matching entry point in the
- *    provided nodes
- *
- * The caller is responsible for freeing all of the allocated indexes,
- * regardless of the return value.
- */
-static const struct ctl_node *ctl_find_node(const struct ctl_node *nodes,
-                                            const char *name,
-                                            struct ctl_index_utlist *indexes) {
-    const struct ctl_node *n = NULL;
-    char *sptr = NULL;
-    char *parse_str = Strdup(name);
-    if (parse_str == NULL) {
-        return NULL;
-    }
-
-    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 *endptr;
-        /*
-         * Ignore errno from strtol: FreeBSD returns EINVAL if no
-         * conversion is performed. Linux does not, but endptr
-         * check is valid in both cases.
-         */
-        int tmp_errno = errno;
-        long index_value = strtol(node_name, &endptr, 0);
-        errno = tmp_errno;
-        struct ctl_index_utlist *index_entry = NULL;
-        if (endptr != node_name) { /* a valid index */
-            index_entry = umf_ba_global_alloc(sizeof(*index_entry));
-            if (index_entry == NULL) {
-                goto error;
-            }
-            index_entry->value = index_value;
-            LL_PREPEND(indexes, index_entry);
-        }
-
-        for (n = &nodes[0]; n->name != NULL; ++n) {
-            if (index_entry && n->type == CTL_NODE_INDEXED) {
-                break;
-            } else if (strcmp(n->name, node_name) == 0) {
-                break;
-            }
-        }
-        if (n->name == NULL) {
-            goto error;
-        }
-
-        if (index_entry) {
-            index_entry->name = n->name;
-        }
-
-        nodes = n->children;
-        node_name = strtok_r(NULL, CTL_QUERY_NODE_SEPARATOR, &sptr);
-    }
-
-    umf_ba_global_free(parse_str);
-    return n;
-
-error:
-    umf_ba_global_free(parse_str);
-    return NULL;
-}
+// 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(struct ctl_index_utlist *indexes) {
+static void ctl_delete_indexes(umf_ctl_index_utlist_t *indexes) {
     if (!indexes) {
         return;
     }
-    struct ctl_index_utlist *elem, *tmp;
+    umf_ctl_index_utlist_t *elem, *tmp;
     LL_FOREACH_SAFE(indexes, elem, tmp) {
         LL_DELETE(indexes, elem);
         if (elem) {
-            umf_ba_global_free(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 = umf_ba_global_alloc(arg_proto->dest_size);
+    char *dest_arg = ctl_malloc_fn(arg_proto->dest_size);
     if (dest_arg == NULL) {
         return NULL;
     }
@@ -179,9 +178,6 @@ static void *ctl_parse_args(const struct ctl_argument *arg_proto, char *arg) {
     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 (arg_sep == NULL) {
-            goto error_parsing;
-        }
 
         if (p->parser(arg_sep, dest_arg + p->dest_offset, p->dest_size) != 0) {
             goto error_parsing;
@@ -193,7 +189,7 @@ static void *ctl_parse_args(const struct ctl_argument *arg_proto, char *arg) {
     return dest_arg;
 
 error_parsing:
-    umf_ba_global_free(dest_arg);
+    ctl_free_fn(dest_arg);
     return NULL;
 }
 
@@ -201,12 +197,14 @@ static void *ctl_parse_args(const struct ctl_argument *arg_proto, char *arg) {
  * 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 struct ctl_node *n, void *write_arg,
-                                     enum ctl_query_source source) {
+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;
@@ -219,57 +217,48 @@ static void *ctl_query_get_real_args(const struct ctl_node *n, void *write_arg,
 }
 
 /*
- * ctl_query_cleanup_real_args -- (internal) cleanups relevant argument
- *    structures allocated as a result of the get_real_args call
+ * ctl_exec_query_read -- (internal) calls the read callback of a node
  */
-static void ctl_query_cleanup_real_args(const struct ctl_node *n,
-                                        void *real_arg,
-                                        enum ctl_query_source source) {
-    /* suppress unused-parameter errors */
-    (void)n;
+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);
 
-    switch (source) {
-    case CTL_QUERY_CONFIG_INPUT:
-        umf_ba_global_free(real_arg);
-        break;
-    case CTL_QUERY_PROGRAMMATIC:
-        break;
-    default:
-        break;
+    if (n->read_cb == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
-}
 
-/*
- * ctl_exec_query_read -- (internal) calls the read callback of a node
- */
-static int ctl_exec_query_read(void *ctx, const struct ctl_node *n,
-                               enum ctl_query_source source, void *arg,
-                               struct ctl_index_utlist *indexes) {
     if (arg == NULL) {
-        errno = EINVAL;
-        return -1;
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    return n->cb[CTL_QUERY_READ](ctx, source, arg, indexes);
+    return n->read_cb(ctx, source, arg, size, indexes);
 }
 
 /*
  * ctl_exec_query_write -- (internal) calls the write callback of a node
  */
-static int ctl_exec_query_write(void *ctx, const struct ctl_node *n,
-                                enum ctl_query_source source, void *arg,
-                                struct ctl_index_utlist *indexes) {
+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) {
-        errno = EINVAL;
-        return -1;
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    void *real_arg = ctl_query_get_real_args(n, arg, source);
+    void *real_arg = ctl_query_get_real_args(n, arg, source, &size);
     if (real_arg == NULL) {
-        return -1;
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    int ret = n->cb[CTL_QUERY_WRITE](ctx, source, real_arg, indexes);
+    umf_result_t ret = n->write_cb(ctx, source, real_arg, size, indexes);
     ctl_query_cleanup_real_args(n, real_arg, source);
 
     return ret;
@@ -278,73 +267,304 @@ static int ctl_exec_query_write(void *ctx, const struct ctl_node *n,
 /*
  * ctl_exec_query_runnable -- (internal) calls the run callback of a node
  */
-static int ctl_exec_query_runnable(void *ctx, const struct ctl_node *n,
-                                   enum ctl_query_source source, void *arg,
-                                   struct ctl_index_utlist *indexes) {
-    return n->cb[CTL_QUERY_RUNNABLE](ctx, source, arg, indexes);
+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 int (*ctl_exec_query[MAX_CTL_QUERY_TYPE])(
-    void *ctx, const struct ctl_node *n, enum ctl_query_source source,
-    void *arg, struct ctl_index_utlist *indexes) = {
-    ctl_exec_query_read,
-    ctl_exec_query_write,
-    ctl_exec_query_runnable,
-};
+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_query -- (internal) parses the name and calls the appropriate methods
- *    from the ctl tree
+ * 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.
  */
-int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
-              const char *name, enum ctl_query_type type, void *arg) {
-    if (name == NULL) {
-        errno = EINVAL;
-        return -1;
+
+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;
     }
 
-    /*
-     * All of the indexes are put on this list so that the handlers can
-     * easily retrieve the index values. The list is cleared once the ctl
-     * query has been handled.
-     */
-    struct ctl_index_utlist *indexes = NULL;
-    indexes = Zalloc(sizeof(*indexes));
+    umf_ctl_index_utlist_t *indexes = Zalloc(sizeof(*indexes));
     if (!indexes) {
-        return -1;
+        ret.value = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        return ret;
     }
+    char *node_name = strtok_r(parse_str, CTL_QUERY_NODE_SEPARATOR, &sptr);
 
-    int ret = -1;
+    /*
+     * 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;
+        }
 
-    const struct ctl_node *n = ctl_find_node(CTL_NODE(global), name, indexes);
+        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 (n == NULL && ctl) {
-        ctl_delete_indexes(indexes);
-        indexes = NULL;
-        n = ctl_find_node(ctl->root, name, indexes);
+        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 (n == NULL || n->type != CTL_NODE_LEAF || n->cb[type] == NULL) {
-        errno = EINVAL;
+    // 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;
     }
 
-    ret = ctl_exec_query[type](ctx, n, source, arg, indexes);
-
+    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,
-                              struct ctl_node *n) {
-    struct ctl_node *nnode = c == NULL
-                                 ? &CTL_NODE(global)[ctl_global_first_free++]
-                                 : &c->root[c->first_free++];
+                              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;
@@ -353,16 +573,16 @@ void ctl_register_module_node(struct ctl *c, const char *name,
 
 /*
  * ctl_parse_query -- (internal) splits an entire query string
- *    into name and value
+ *    into path and value
  */
-static int ctl_parse_query(char *qbuf, char **name, char **value) {
+static int ctl_parse_query(char *qbuf, char **path, char **value) {
     if (qbuf == NULL) {
         return -1;
     }
 
     char *sptr = NULL;
-    *name = strtok_r(qbuf, CTL_NAME_VALUE_SEPARATOR, &sptr);
-    if (*name == NULL) {
+    *path = strtok_r(qbuf, CTL_NAME_VALUE_SEPARATOR, &sptr);
+    if (*path == NULL) {
         return -1;
     }
 
@@ -381,47 +601,61 @@ static int ctl_parse_query(char *qbuf, char **name, char **value) {
 }
 
 /*
- * ctl_load_config -- executes the entire query collection from a provider
+ * ctl_load_config_helper -- windows do not allow to use uninitialized va_list,
+ * so this function allows us to initialize empty one
  */
-static int ctl_load_config(struct ctl *ctl, void *ctx, char *buf) {
-    int r = 0;
+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 *name;
+    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) {
-        r = ctl_parse_query(qbuf, &name, &value);
-        if (r != 0) {
-            return -1;
+        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);
 
-        r = ctl_query(ctl, ctx, CTL_QUERY_CONFIG_INPUT, name, CTL_QUERY_WRITE,
-                      value);
-
-        if (r < 0 && ctx != NULL) {
-            return -1;
+        if (ret != UMF_RESULT_SUCCESS && ctx != NULL) {
+            goto end;
         }
 
         qbuf = strtok_r(NULL, CTL_STRING_QUERY_SEPARATOR, &sptr);
     }
 
-    return 0;
+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
  */
-int ctl_load_config_from_string(struct ctl *ctl, void *ctx,
-                                const char *cfg_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 -1;
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    int ret = ctl_load_config(ctl, ctx, buf);
+    umf_result_t ret = ctl_load_config(ctl, ctx, buf);
 
-    umf_ba_global_free(buf);
+    ctl_free_fn(buf);
     return ret;
 }
 
@@ -431,10 +665,9 @@ int ctl_load_config_from_string(struct ctl *ctl, void *ctx,
  * 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.
  */
-#ifndef _WIN32 // TODO: implement for Windows
-int ctl_load_config_from_file(struct ctl *ctl, void *ctx,
-                              const char *cfg_file) {
-    int ret = -1;
+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;
 
@@ -483,32 +716,29 @@ int ctl_load_config_from_file(struct ctl *ctl, void *ctx,
 
     ret = ctl_load_config(ctl, ctx, buf);
 
-    umf_ba_global_free(buf);
+    ctl_free_fn(buf);
 
 error_file_parse:
     (void)fclose(fp);
     return ret;
 }
-#endif
 
 /*
- * ctl_new -- allocates and initializes ctl data structures
+ * ctl_parse_ull -- (internal) parses and returns an unsigned long long
  */
-struct ctl *ctl_new(void) {
-    struct ctl *c = Zalloc(sizeof(struct ctl));
-    if (c == NULL) {
-        return NULL;
+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;
 
-    c->first_free = 0;
-    return c;
+    return val;
 }
 
-/*
- * ctl_delete -- deletes ctl
- */
-void ctl_delete(struct ctl *c) { umf_ba_global_free(c); }
-
 /*
  * ctl_parse_ll -- (internal) parses and returns a long long signed integer
  */
@@ -532,6 +762,9 @@ static long long ctl_parse_ll(const char *str) {
 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];
@@ -547,10 +780,49 @@ int ctl_arg_boolean(const void *arg, void *dest, size_t dest_size) {
     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;
@@ -566,14 +838,7 @@ int ctl_arg_integer(const void *arg, void *dest, size_t dest_size) {
     case sizeof(long long):
         *(long long *)dest = val;
         break;
-    case sizeof(uint8_t):
-        if (val > UINT8_MAX || val < 0) {
-            return -1;
-        }
-        *(uint8_t *)dest = (uint8_t)val;
-        break;
     default:
-        errno = EINVAL;
         return -1;
     }
 
@@ -585,6 +850,10 @@ int ctl_arg_integer(const void *arg, void *dest, size_t dest_size) {
  *    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;
diff --git a/src/ctl/ctl.h b/src/ctl/ctl.h
deleted file mode 100644
index 9327b01afe..0000000000
--- a/src/ctl/ctl.h
+++ /dev/null
@@ -1,216 +0,0 @@
-/*
- *
- * Copyright (C) 2016-2024 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.h -- internal declaration of statistics and control related structures
- */
-
-#ifndef UMF_CTL_H
-#define UMF_CTL_H 1
-
-#include <errno.h>
-#include <stddef.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct ctl;
-
-struct ctl_index_utlist {
-    const char *name;
-    long value;
-    struct ctl_index_utlist *next;
-};
-
-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,
-
-    MAX_CTL_QUERY_SOURCE
-};
-
-enum ctl_query_type {
-    CTL_QUERY_READ,
-    CTL_QUERY_WRITE,
-    CTL_QUERY_RUNNABLE,
-
-    MAX_CTL_QUERY_TYPE
-};
-
-typedef int (*node_callback)(void *ctx, enum ctl_query_source type, void *arg,
-                             struct ctl_index_utlist *indexes);
-
-enum ctl_node_type {
-    CTL_NODE_UNKNOWN,
-    CTL_NODE_NAMED,
-    CTL_NODE_LEAF,
-    CTL_NODE_INDEXED,
-
-    MAX_CTL_NODE
-};
-
-typedef int (*ctl_arg_parser)(const void *arg, void *dest, size_t dest_size);
-
-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_parser parser;
-};
-
-struct ctl_argument {
-    size_t dest_size;                     /* size of the entire argument */
-    struct ctl_argument_parser parsers[]; /* array of 'fields' in arg */
-};
-
-#define sizeof_member(t, m) sizeof(((t *)0)->m)
-
-#define CTL_ARG_PARSER(t, p)                                                   \
-    { 0, sizeof(t), p }
-
-#define CTL_ARG_PARSER_STRUCT(t, m, p)                                         \
-    { offsetof(t, m), sizeof_member(t, m), p }
-
-#define CTL_ARG_PARSER_END                                                     \
-    { 0, 0, NULL }
-
-/*
- * CTL Tree node structure, do not use directly. All the necessary functionality
- * is provided by the included macros.
- */
-struct ctl_node {
-    const char *name;
-    enum ctl_node_type type;
-
-    node_callback cb[MAX_CTL_QUERY_TYPE];
-    const struct ctl_argument *arg;
-
-    const struct ctl_node *children;
-};
-
-struct ctl *ctl_new(void);
-void ctl_delete(struct ctl *stats);
-
-int ctl_load_config_from_string(struct ctl *ctl, void *ctx,
-                                const char *cfg_string);
-int 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);
-#define CTL_ARG_BOOLEAN                                                        \
-    {sizeof(int), {{0, sizeof(int), ctl_arg_boolean}, CTL_ARG_PARSER_END}};
-
-int ctl_arg_integer(const void *arg, void *dest, size_t dest_size);
-#define CTL_ARG_INT                                                            \
-    {sizeof(int), {{0, sizeof(int), ctl_arg_integer}, CTL_ARG_PARSER_END}};
-
-#define CTL_ARG_LONG_LONG                                                      \
-    {                                                                          \
-        sizeof(long long), {                                                   \
-            {0, sizeof(long long), ctl_arg_integer}, CTL_ARG_PARSER_END        \
-        }                                                                      \
-    }
-
-int ctl_arg_string(const void *arg, void *dest, size_t dest_size);
-#define CTL_ARG_STRING(len)                                                    \
-    {len, {{0, len, ctl_arg_string}, CTL_ARG_PARSER_END}};
-
-#define CTL_STR(name) #name
-
-#define CTL_NODE_END                                                           \
-    { NULL, CTL_NODE_UNKNOWN, {NULL, NULL, NULL}, NULL, NULL }
-
-#define CTL_NODE(name, ...) ctl_node_##__VA_ARGS__##_##name
-
-int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
-              const char *name, enum ctl_query_type type, void *arg);
-
-/* Declaration of a new child node */
-#define CTL_CHILD(name, ...)                                                   \
-    {                                                                          \
-        CTL_STR(name), CTL_NODE_NAMED, {NULL, NULL, NULL}, NULL,               \
-            (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,             \
-            (struct ctl_node *)CTL_NODE(name, __VA_ARGS__)                     \
-    }
-
-#define CTL_READ_HANDLER(name, ...) ctl_##__VA_ARGS__##_##name##_read
-
-#define CTL_WRITE_HANDLER(name, ...) ctl_##__VA_ARGS__##_##name##_write
-
-#define CTL_RUNNABLE_HANDLER(name, ...) ctl_##__VA_ARGS__##_##name##_runnable
-
-#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      \
-    }
-
-/*
- * 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},                \
-            &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  \
-    }
-
-/*
- * 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},           \
-            &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
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 d4e5cc8066..29ed5bac20 100644
--- a/src/ipc.c
+++ b/src/ipc.c
@@ -58,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;
@@ -79,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.");
@@ -92,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;
diff --git a/src/libumf.c b/src/libumf.c
index e357b2583a..ab6be8704a 100644
--- a/src/libumf.c
+++ b/src/libumf.c
@@ -7,55 +7,116 @@
  *
  */
 
+#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 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_add_u64(&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_sub_u64(&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();
@@ -78,6 +139,9 @@ void umfTearDown(void) {
         umfMemoryTrackerDestroy(t);
         LOG_DEBUG("UMF tracker destroyed");
 
+        umfProviderCtlDefaultsDestroy();
+        umfPoolCtlDefaultsDestroy();
+
         umf_ba_destroy_global();
         LOG_DEBUG("UMF base allocator destroyed");
 
@@ -87,6 +151,58 @@ void umfTearDown(void) {
         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 ce8820a8fa..c4093292e5 100644
--- a/src/libumf.def
+++ b/src/libumf.def
@@ -6,13 +6,12 @@
 
 LIBRARY UMF
 
-VERSION 0.11
+VERSION 1.1
 
 EXPORTS
     DllMain
     umfInit
     umfTearDown
-    umfGetCurrentVersion
     umfCloseIPCHandle
     umfCUDAMemoryProviderOps
     umfCUDAMemoryProviderParamsCreate
@@ -32,6 +31,7 @@ EXPORTS
     umfFileMemoryProviderParamsSetProtection
     umfFileMemoryProviderParamsSetVisibility
     umfFree
+    umfGetCurrentVersion
     umfGetIPCHandle
     umfGetLastFailedMemoryProvider
     umfJemallocPoolOps
@@ -60,7 +60,6 @@ EXPORTS
     umfMemoryProviderPurgeForce
     umfMemoryProviderPurgeLazy
     umfMemoryProviderPutIPCHandle
-    umfMemoryTrackerGetAllocInfo
     umfMempolicyCreate
     umfMempolicyDestroy
     umfMempolicySetCustomSplitPartitions
@@ -87,13 +86,13 @@ EXPORTS
     umfOsMemoryProviderOps
     umfOsMemoryProviderParamsCreate
     umfOsMemoryProviderParamsDestroy
-    umfOsMemoryProviderParamsSetProtection
-    umfOsMemoryProviderParamsSetVisibility
-    umfOsMemoryProviderParamsSetShmName
     umfOsMemoryProviderParamsSetNumaList
     umfOsMemoryProviderParamsSetNumaMode
-    umfOsMemoryProviderParamsSetPartSize
     umfOsMemoryProviderParamsSetPartitions
+    umfOsMemoryProviderParamsSetPartSize
+    umfOsMemoryProviderParamsSetProtection
+    umfOsMemoryProviderParamsSetShmName
+    umfOsMemoryProviderParamsSetVisibility
     umfPoolAlignedMalloc
     umfPoolByPtr
     umfPoolCalloc
@@ -134,5 +133,28 @@ EXPORTS
     umfFixedMemoryProviderOps
     umfFixedMemoryProviderParamsCreate
     umfFixedMemoryProviderParamsDestroy
-    umfLevelZeroMemoryProviderParamsSetFreePolicy
+    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 6582fd0f8d..d23c6a2e02 100644
--- a/src/libumf.map
+++ b/src/libumf.map
@@ -2,11 +2,10 @@
 # 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;
         umfCUDAMemoryProviderOps;
         umfCUDAMemoryProviderParamsCreate;
@@ -26,6 +25,7 @@ UMF_0.10 {
         umfFileMemoryProviderParamsSetProtection;
         umfFileMemoryProviderParamsSetVisibility;
         umfFree;
+        umfGetCurrentVersion;
         umfGetIPCHandle;
         umfGetLastFailedMemoryProvider;
         umfJemallocPoolOps;
@@ -54,7 +54,6 @@ UMF_0.10 {
         umfMemoryProviderPurgeForce;
         umfMemoryProviderPurgeLazy;
         umfMemoryProviderPutIPCHandle;
-        umfMemoryTrackerGetAllocInfo;
         umfMempolicyCreate;
         umfMempolicyDestroy;
         umfMempolicySetCustomSplitPartitions;
@@ -83,8 +82,8 @@ UMF_0.10 {
         umfOsMemoryProviderParamsDestroy;
         umfOsMemoryProviderParamsSetNumaList;
         umfOsMemoryProviderParamsSetNumaMode;
-        umfOsMemoryProviderParamsSetPartSize;
         umfOsMemoryProviderParamsSetPartitions;
+        umfOsMemoryProviderParamsSetPartSize;
         umfOsMemoryProviderParamsSetProtection;
         umfOsMemoryProviderParamsSetShmName;
         umfOsMemoryProviderParamsSetVisibility;
@@ -111,11 +110,7 @@ UMF_0.10 {
         umfScalablePoolParamsDestroy;
         umfScalablePoolParamsSetGranularity;
         umfScalablePoolParamsSetKeepAllMemory;
-    local:
-        *;
-};
-
-UMF_0.11 {
+# Added in UMF_0.11
         umfCUDAMemoryProviderParamsSetAllocFlags;
         umfDisjointPoolOps;
         umfDisjointPoolParamsCreate;
@@ -132,6 +127,33 @@ UMF_0.11 {
         umfFixedMemoryProviderOps;
         umfFixedMemoryProviderParamsCreate;
         umfFixedMemoryProviderParamsDestroy;
-        umfLevelZeroMemoryProviderParamsSetFreePolicy;
+        umfFixedMemoryProviderParamsSetMemory;
         umfLevelZeroMemoryProviderParamsSetDeviceOrdinal;
-} UMF_0.10;
+        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_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 eb00545228..2161d5d45c 100644
--- a/src/memory_pool.c
+++ b/src/memory_pool.c
@@ -7,41 +7,430 @@
  *
  */
 
-#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_handle_t pool =
-        umf_ba_global_alloc(sizeof(umf_memory_pool_t));
-    if (!pool) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
+    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;
     }
 
     if (!(flags & UMF_POOL_CREATE_FLAG_DISABLE_TRACKING)) {
@@ -54,9 +443,20 @@ 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;
+    }
 
     if (NULL == utils_mutex_init(&pool->lock)) {
         LOG_ERR("Failed to initialize mutex for pool");
@@ -64,12 +464,30 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
         goto err_lock_init;
     }
 
-    ret = ops->initialize(pool->provider, params, &pool->pool_priv);
+    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;
 
@@ -84,20 +502,34 @@ 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);
@@ -106,27 +538,39 @@ void umfPoolDestroy(umf_memory_pool_handle_t 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;
@@ -138,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();
 
@@ -156,33 +606,66 @@ 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) {
@@ -210,3 +693,15 @@ umf_result_t umfPoolGetTag(umf_memory_pool_handle_t hPool, void **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 ab3378163d..8c66cd4e78 100644
--- a/src/memory_pool_internal.h
+++ b/src/memory_pool_internal.h
@@ -22,11 +22,15 @@ 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.
@@ -34,8 +38,17 @@ typedef struct umf_memory_pool_t {
 
     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 ce6a10a207..413de848fc 100644
--- a/src/memory_provider.c
+++ b/src/memory_provider.c
@@ -8,17 +8,65 @@
  */
 
 #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"
+
+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;
+
+    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) {
@@ -93,79 +141,197 @@ 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.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->free && 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 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;
     }
 
     umf_memory_provider_handle_t provider =
@@ -188,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
@@ -212,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;
 }
@@ -221,21 +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.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;
 }
 
@@ -244,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;
 }
@@ -280,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
@@ -300,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;
 }
@@ -318,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;
 }
@@ -329,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
@@ -339,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
@@ -349,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
@@ -359,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
@@ -368,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_internal.h b/src/memory_provider_internal.h
index dd1111a236..b486377acd 100644
--- a/src/memory_provider_internal.h
+++ b/src/memory_provider_internal.h
@@ -14,17 +14,23 @@
 
 #include <umf/memory_provider.h>
 
+#include "ctl/ctl_internal.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 typedef struct umf_memory_provider_t {
-    umf_memory_provider_ops_t ops;
     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);
+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 83e65fc291..421d50fafa 100644
--- a/src/memspaces/memspace_numa.c
+++ b/src/memspaces/memspace_numa.c
@@ -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 8eb6e4e8cb..b0fa316cb2 100644
--- a/src/memtarget.c
+++ b/src/memtarget.c
@@ -20,9 +20,8 @@
 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));
@@ -93,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);
@@ -104,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 85ec99b8e6..f2eef4f3d0 100644
--- a/src/memtarget_internal.h
+++ b/src/memtarget_internal.h
@@ -11,7 +11,7 @@
 #define UMF_MEMTARGET_INTERNAL_H 1
 
 #include <umf/base.h>
-#include <umf/memtarget.h>
+#include <umf/experimental/memtarget.h>
 #ifdef __cplusplus
 extern "C" {
 #endif
diff --git a/src/memtarget_ops.h b/src/memtarget_ops.h
index 4bd9bb8997..1abb473894 100644
--- a/src/memtarget_ops.h
+++ b/src/memtarget_ops.h
@@ -11,8 +11,8 @@
 #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" {
diff --git a/src/memtargets/memtarget_numa.c b/src/memtargets/memtarget_numa.c
index 88d8ac2a42..d6431ef9ff 100644
--- a/src/memtargets/memtarget_numa.c
+++ b/src/memtargets/memtarget_numa.c
@@ -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;
     }
 
diff --git a/src/memtargets/memtarget_numa.h b/src/memtargets/memtarget_numa.h
index 6659d045ef..188ac4ce73 100644
--- a/src/memtargets/memtarget_numa.h
+++ b/src/memtargets/memtarget_numa.h
@@ -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 22aeab7833..0000000000
--- a/src/pool/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-# Copyright (C) 2023-2025 Intel Corporation
-# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-if(UMF_BUILD_SHARED_LIBRARY)
-    set(POOL_EXTRA_SRCS ${BA_SOURCES})
-    set(POOL_EXTRA_LIBS $<BUILD_INTERFACE:umf_utils>)
-endif()
-
-set(POOL_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS})
diff --git a/src/pool/pool_disjoint.c b/src/pool/pool_disjoint.c
index ca4d2fab78..e059bba455 100644
--- a/src/pool/pool_disjoint.c
+++ b/src/pool/pool_disjoint.c
@@ -7,16 +7,17 @@
 
 #include <assert.h>
 #include <ctype.h>
-#include <errno.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"
@@ -25,6 +26,540 @@
 #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
@@ -140,8 +675,6 @@ static void destroy_slab(slab_t *slab) {
     if (res != UMF_RESULT_SUCCESS) {
         LOG_ERR("deallocation of slab data failed!");
     }
-
-    umf_ba_global_free(slab);
 }
 
 static size_t slab_find_first_available_chunk_idx(const slab_t *slab) {
@@ -233,7 +766,7 @@ static umf_result_t pool_unregister_slab(disjoint_pool_t *pool, slab_t *slab) {
     // TODO ASSERT_IS_ALIGNED((uintptr_t)slab_addr, bucket->size);
     LOG_DEBUG("slab: %p, start: %p", (void *)slab, slab_addr);
 
-    critnib_remove(slabs, (uintptr_t)slab_addr);
+    critnib_remove_release(slabs, (uintptr_t)slab_addr);
 
     return UMF_RESULT_SUCCESS;
 }
@@ -570,21 +1103,41 @@ static void *disjoint_pool_allocate(disjoint_pool_t *pool, size_t 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,
-                                      void *params, void **ppPool) {
-    // TODO set defaults when user pass the NULL as params
-    if (!provider || !params || !ppPool) {
+                                      const void *params, void **ppPool) {
+    if (!provider || !ppPool) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    umf_disjoint_pool_params_t *dp_params =
-        (umf_disjoint_pool_params_t *)params;
+    const umf_disjoint_pool_params_t *dp_params;
 
-    // min_bucket_size parameter must be a power of 2 for bucket sizes
-    // to generate correctly.
-    if (!dp_params->min_bucket_size ||
-        !IS_POWER_OF_2(dp_params->min_bucket_size)) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    // If params is NULL, use default values
+    if (!params) {
+        dp_params = &default_params;
+    } else {
+        dp_params = params;
     }
 
     disjoint_pool_t *disjoint_pool =
@@ -597,8 +1150,43 @@ umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
 
     disjoint_pool->provider = provider;
     disjoint_pool->params = *dp_params;
+    disjoint_pool->post_initialized = false;
+    disjoint_pool->params_overridden = 0;
 
-    disjoint_pool->known_slabs = critnib_new();
+    *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;
     }
@@ -615,9 +1203,9 @@ umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
 
     // Calculate the exponent for min_bucket_size used for finding buckets.
     disjoint_pool->min_bucket_size_exp = (size_t)utils_msb64(Size1);
-    disjoint_pool->default_shared_limits =
-        umfDisjointPoolSharedLimitsCreate(SIZE_MAX);
-    if (disjoint_pool->default_shared_limits == NULL) {
+    if (umfDisjointPoolSharedLimitsCreate(
+            SIZE_MAX, &disjoint_pool->default_shared_limits) !=
+        UMF_RESULT_SUCCESS) {
         goto err_free_known_slabs;
     }
 
@@ -656,13 +1244,11 @@ umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
     }
 
     umf_result_t ret = umfMemoryProviderGetMinPageSize(
-        provider, NULL, &disjoint_pool->provider_min_page_size);
+        disjoint_pool->provider, NULL, &disjoint_pool->provider_min_page_size);
     if (ret != UMF_RESULT_SUCCESS) {
         disjoint_pool->provider_min_page_size = 0;
     }
 
-    *ppPool = (void *)disjoint_pool;
-
     return UMF_RESULT_SUCCESS;
 
 err_free_buckets:
@@ -681,7 +1267,6 @@ umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
 
 err_free_disjoint_pool:
     umf_ba_global_free(disjoint_pool);
-
     return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
 }
 
@@ -793,7 +1378,7 @@ void *disjoint_pool_aligned_malloc(void *pool, size_t size, size_t alignment) {
     return aligned_ptr;
 }
 
-static size_t get_chunk_idx(void *ptr, slab_t *slab) {
+static size_t get_chunk_idx(const void *ptr, slab_t *slab) {
     return (((uintptr_t)ptr - (uintptr_t)slab->mem_ptr) / slab->bucket->size);
 }
 
@@ -801,25 +1386,43 @@ static void *get_unaligned_ptr(size_t chunk_idx, slab_t *slab) {
     return (void *)((uintptr_t)slab->mem_ptr + chunk_idx * slab->bucket->size);
 }
 
-size_t disjoint_pool_malloc_usable_size(void *pool, void *ptr) {
+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) {
-        return 0;
+        *size = 0;
+        return UMF_RESULT_SUCCESS;
     }
 
     // check if given pointer is allocated inside any Disjoint Pool slab
-    slab_t *slab =
-        (slab_t *)critnib_find_le(disjoint_pool->known_slabs, (uintptr_t)ptr);
+    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
-        umf_alloc_info_t allocInfo = {NULL, 0, NULL};
-        umf_result_t ret = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
-        if (ret != UMF_RESULT_SUCCESS) {
-            return 0;
+        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;
         }
 
-        return allocInfo.baseSize;
+        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);
@@ -827,7 +1430,12 @@ size_t disjoint_pool_malloc_usable_size(void *pool, void *ptr) {
 
     ptrdiff_t diff = (ptrdiff_t)ptr - (ptrdiff_t)unaligned_ptr;
 
-    return slab->bucket->size - diff;
+    *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) {
@@ -837,21 +1445,31 @@ umf_result_t disjoint_pool_free(void *pool, void *ptr) {
     }
 
     // check if given pointer is allocated inside any Disjoint Pool slab
-    slab_t *slab =
-        (slab_t *)critnib_find_le(disjoint_pool->known_slabs, (uintptr_t)ptr);
+    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
-        umf_alloc_info_t allocInfo = {NULL, 0, NULL};
-        umf_result_t ret = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
+        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;
         }
 
-        size_t size = allocInfo.baseSize;
+        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) {
@@ -885,6 +1503,9 @@ umf_result_t disjoint_pool_free(void *pool, void *ptr) {
     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++;
     }
@@ -910,9 +1531,9 @@ umf_result_t disjoint_pool_get_last_allocation_error(void *pool) {
 }
 
 // Define destructor for use with unique_ptr
-void disjoint_pool_finalize(void *pool) {
+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);
     }
@@ -921,16 +1542,76 @@ void disjoint_pool_finalize(void *pool) {
         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");
+    }
 
-    umfDisjointPoolSharedLimitsDestroy(hPool->default_shared_limits);
     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_VERSION_CURRENT,
+    .version = UMF_POOL_OPS_VERSION_CURRENT,
     .initialize = disjoint_pool_initialize,
     .finalize = disjoint_pool_finalize,
     .malloc = disjoint_pool_malloc,
@@ -940,33 +1621,40 @@ static umf_memory_pool_ops_t UMF_DISJOINT_POOL_OPS = {
     .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,
 };
 
-umf_memory_pool_ops_t *umfDisjointPoolOps(void) {
+const umf_memory_pool_ops_t *umfDisjointPoolOps(void) {
     return &UMF_DISJOINT_POOL_OPS;
 }
 
-umf_disjoint_pool_shared_limits_t *
-umfDisjointPoolSharedLimitsCreate(size_t max_size) {
+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 NULL;
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
     ptr->max_size = max_size;
     ptr->total_size = 0;
-    return ptr;
+    *hSharedLimits = ptr;
+    return UMF_RESULT_SUCCESS;
 }
 
-void umfDisjointPoolSharedLimitsDestroy(
-    umf_disjoint_pool_shared_limits_t *limits) {
+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) {
-    static char *DEFAULT_NAME = "disjoint_pool";
-
     if (!hParams) {
         LOG_ERR("disjoint pool params handle is NULL");
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
@@ -979,19 +1667,9 @@ umfDisjointPoolParamsCreate(umf_disjoint_pool_params_handle_t *hParams) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    *params = (umf_disjoint_pool_params_t){
-        .slab_min_size = 0,
-        .max_poolable_size = 0,
-        .capacity = 0,
-        .min_bucket_size = UMF_DISJOINT_POOL_MIN_BUCKET_DEFAULT_SIZE,
-        .cur_pool_size = 0,
-        .pool_trace = 0,
-        .shared_limits = NULL,
-        .name = {*DEFAULT_NAME},
-    };
+    *params = default_params;
 
     *hParams = params;
-
     return UMF_RESULT_SUCCESS;
 }
 
@@ -1091,5 +1769,6 @@ umfDisjointPoolParamsSetName(umf_disjoint_pool_params_handle_t hParams,
     }
 
     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_internal.h b/src/pool/pool_disjoint_internal.h
index 7a63dd72ac..4d934479e0 100644
--- a/src/pool/pool_disjoint_internal.h
+++ b/src/pool/pool_disjoint_internal.h
@@ -110,23 +110,23 @@ typedef struct 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;
+    size_t slab_min_size; // Default: 64KB
 
     // Allocations up to this limit will be subject to chunking/pooling
-    size_t max_poolable_size;
+    size_t max_poolable_size; // Default: 2MB
 
     // When pooling, each bucket will hold a max of 'capacity' unfreed slabs
-    size_t capacity;
+    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;
+    size_t min_bucket_size; // Default: 8
 
     // Holds size of the pool managed by the allocator.
-    size_t cur_pool_size;
+    size_t cur_pool_size; // Default: 0
 
     // Whether to print pool usage statistics
-    int pool_trace;
+    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'
@@ -159,6 +159,12 @@ typedef struct disjoint_pool_t {
 
     // 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) {
diff --git a/src/pool/pool_jemalloc.c b/src/pool/pool_jemalloc.c
index 10e00dea51..50a245e05d 100644
--- a/src/pool/pool_jemalloc.c
+++ b/src/pool/pool_jemalloc.c
@@ -6,11 +6,15 @@
 */
 
 #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"
@@ -22,23 +26,62 @@
 
 #ifndef UMF_POOL_JEMALLOC_ENABLED
 
-umf_memory_pool_ops_t *umfJemallocPoolOps(void) { return NULL; }
+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
+    umf_jemalloc_pool_params_t params;
+    size_t n_arenas;
+    char name[64];
+    unsigned int *arena_index;
 } jemalloc_memory_pool_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
@@ -47,6 +90,14 @@ static jemalloc_memory_pool_t *get_pool_by_arena_index(unsigned arena_ind) {
     return pool_by_arena_index[arena_ind];
 }
 
+// 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
 // success returns a pointer to size bytes of mapped memory on behalf of arena arena_ind such that
 // the extent's base address is a multiple of alignment, as well as setting *zero to indicate
@@ -82,7 +133,7 @@ static void *arena_extent_alloc(extent_hooks_t *extent_hooks, void *new_addr,
 
 #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
 
@@ -239,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
@@ -285,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;
@@ -343,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;
@@ -364,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 =
@@ -380,72 +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) {
-    (void)params; // unused
+                                  const void *params, void **out_pool) {
     assert(provider);
     assert(out_pool);
 
-    extent_hooks_t *pHooks = &arena_extent_hooks;
-    size_t unsigned_size = sizeof(unsigned);
-    int err;
+    // 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(jemalloc_memory_pool_t));
+    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;
+}
 
-    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;
+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;
+
+    size_t n_arenas = 0;
+    if (jemalloc_params) {
+        n_arenas = jemalloc_params->n_arenas;
+        n_arenas_set_from_params = 1;
     }
 
-    // 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);
-        (void)je_mallctl(cmd, NULL, 0, NULL, 0);
-        LOG_ERR("Could not setup extent_hooks for newly created arena.");
-        goto err_free_pool;
+    if (n_arenas == 0) {
+        n_arenas = utils_get_num_cores() * 4;
+        n_arenas = utils_min(n_arenas, (size_t)MALLOCX_ARENA_MAX);
+    }
+
+    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;
     }
 
-    pool->arena_index = arena_index;
-    pool_by_arena_index[arena_index] = 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;
+    }
 
-    *out_pool = (umf_memory_pool_handle_t)pool;
+    memset(je_pool->arena_index, 0, n_arenas * sizeof(*je_pool->arena_index));
 
-    VALGRIND_DO_CREATE_MEMPOOL(pool, 0, 0);
+    const char *pool_name = DEFAULT_NAME;
+    if (jemalloc_params) {
+        pool_name = jemalloc_params->name;
+    }
+
+    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;
+        }
+
+        pool_by_arena_index[arena_index] = je_pool;
+
+        // 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);
-    (void)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) {
@@ -453,6 +686,41 @@ 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_POOL_OPS_VERSION_CURRENT,
     .initialize = op_initialize,
@@ -464,9 +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 eedddb0acb..6e256c4918 100644
--- a/src/pool/pool_proxy.c
+++ b/src/pool/pool_proxy.c
@@ -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,6 +141,12 @@ 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_POOL_OPS_VERSION_CURRENT,
     .initialize = proxy_pool_initialize,
@@ -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 8a9fd88c11..b5211615b8 100644
--- a/src/pool/pool_scalable.c
+++ b/src/pool/pool_scalable.c
@@ -19,7 +19,9 @@
 #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"
@@ -34,6 +36,7 @@ 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;
@@ -46,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 {
@@ -67,7 +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;
+    char name[64];
 } tbb_memory_pool_t;
 
 typedef enum tbb_enums_t {
@@ -114,6 +120,10 @@ static const char *tbb_symbol[TBB_POOL_SYMBOLS_MAX] = {
 #endif
 };
 
+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);
@@ -210,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;
 
@@ -259,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,
@@ -269,19 +327,17 @@ 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;
+
+    snprintf(pool_data->name, sizeof(pool_data->name), "%s", pool_name);
 
     umf_result_t res = UMF_RESULT_SUCCESS;
     int ret = init_tbb_callbacks();
@@ -291,7 +347,6 @@ static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
         goto err_tbb_init;
     }
 
-    pool_data->mem_provider = provider;
     ret = tbb_callbacks.pool_create_v1((intptr_t)pool_data, &policy,
                                        &(pool_data->tbb_pool));
     if (ret != 0 /* TBBMALLOC_OK */) {
@@ -299,8 +354,6 @@ static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
         goto err_tbb_init;
     }
 
-    *pool = (void *)pool_data;
-
     return res;
 
 err_tbb_init:
@@ -308,10 +361,15 @@ static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
     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;
-    tbb_callbacks.pool_destroy(pool_data->tbb_pool);
+    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) {
@@ -395,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 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) {
@@ -405,6 +469,49 @@ 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_POOL_OPS_VERSION_CURRENT,
     .initialize = tbb_pool_initialize,
@@ -415,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
index cfdc668fc6..752cda8a40 100644
--- a/src/pool/pool_scalable_internal.h
+++ b/src/pool/pool_scalable_internal.h
@@ -7,4 +7,9 @@
  *
  */
 
+#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_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 dd12d91847..304452f2c1 100644
--- a/src/provider/provider_cuda.c
+++ b/src/provider/provider_cuda.c
@@ -12,6 +12,8 @@
 #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"
@@ -25,62 +27,7 @@ void fini_cu_global_state(void) {
     }
 }
 
-#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;
-}
-
-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_memory_provider_ops_t *umfCUDAMemoryProviderOps(void) {
-    // not supported
-    LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
-    return 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)
@@ -108,8 +55,13 @@ typedef struct cu_memory_provider_t {
     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 {
     // Handle to the CUDA context
@@ -123,6 +75,7 @@ typedef struct umf_cuda_memory_provider_params_t {
 
     // Allocation flags for cuMemHostAlloc/cuMemAllocManaged
     unsigned int alloc_flags;
+    char name[64];
 } umf_cuda_memory_provider_params_t;
 
 typedef struct cu_ops_t {
@@ -153,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];
@@ -188,11 +158,20 @@ static umf_result_t cu2umf_result(CUresult result) {
     }
 }
 
+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
     // The CUDA shared library should be already loaded by the user
     // of the CUDA provider. UMF just want to reuse it
@@ -291,6 +270,8 @@ umf_result_t umfCUDAMemoryProviderParamsCreate(
 
     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;
 
@@ -353,14 +334,31 @@ umf_result_t umfCUDAMemoryProviderParamsSetAllocFlags(
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t cu_memory_provider_initialize(void *params,
+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) {
@@ -390,13 +388,36 @@ 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;
     CUmemAllocationProp allocProps = {0};
     allocProps.location.type = CU_MEM_LOCATION_TYPE_DEVICE;
     allocProps.type = CU_MEM_ALLOCATION_TYPE_PINNED;
-    allocProps.location.id = cu_params->cuda_device_handle;
+    allocProps.location.id = cu_provider->device;
     CUresult cu_result = g_cu_ops.cuMemGetAllocationGranularity(
         &min_alignment, &allocProps, CU_MEM_ALLOC_GRANULARITY_MINIMUM);
     if (cu_result != CUDA_SUCCESS) {
@@ -404,31 +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;
 
     // 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_params->memory_type == UMF_MEMORY_TYPE_SHARED &&
-        cu_params->alloc_flags == 0) {
+    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;
-    } else {
-        cu_provider->alloc_flags = cu_params->alloc_flags;
     }
-
-    *provider = cu_provider;
-
     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
@@ -515,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;
 }
 
@@ -559,20 +570,25 @@ static umf_result_t cu_memory_provider_free(void *provider, void *ptr,
         LOG_ERR("Failed to restore CUDA context, ret = %d", umf_result);
     }
 
-    return cu2umf_result(cu_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;
     }
 
     CUresult result;
+    umf_result_t ret = UMF_RESULT_SUCCESS;
     size_t buf_size = 0;
     const char *error_name = NULL;
     const char *error_string = NULL;
@@ -585,9 +601,12 @@ static void cu_memory_provider_get_last_native_error(void *provider,
     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);
@@ -606,14 +625,16 @@ static void cu_memory_provider_get_last_native_error(void *provider,
     } 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;
 
@@ -648,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,
@@ -732,6 +762,69 @@ cu_memory_provider_close_ipc_handle(void *provider, void *ptr, size_t size) {
     return UMF_RESULT_SUCCESS;
 }
 
+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,
@@ -744,20 +837,88 @@ static umf_memory_provider_ops_t UMF_CUDA_MEMORY_PROVIDER_OPS = {
     .get_name = cu_memory_provider_get_name,
     // 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
index bc3d79d4aa..92e7d98a37 100644
--- a/src/provider/provider_cuda_internal.h
+++ b/src/provider/provider_cuda_internal.h
@@ -7,4 +7,9 @@
  *
  */
 
+#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 8e81971905..6addea3502 100644
--- a/src/provider/provider_devdax_memory.c
+++ b/src/provider/provider_devdax_memory.c
@@ -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,11 +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"
@@ -75,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
@@ -83,13 +94,19 @@ typedef struct devdax_memory_provider_t {
     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 {
@@ -112,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",
@@ -127,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;
 
@@ -148,15 +172,14 @@ static umf_result_t devdax_allocation_split_cb(void *provider, void *ptr,
 static umf_result_t devdax_allocation_merge_cb(void *provider, void *lowPtr,
                                                void *highPtr, size_t totalSize);
 
-static umf_result_t devdax_initialize(void *params, void **provider) {
+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");
@@ -175,6 +198,8 @@ 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;
@@ -266,34 +291,46 @@ static umf_result_t devdax_initialize(void *params, void **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);
+    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;
+    }
+
     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) {
     devdax_memory_provider_t *devdax_provider =
         (devdax_memory_provider_t *)provider;
-    return coarse_alloc(devdax_provider->coarse, size, alignment, resultPtr);
+    umf_result_t ret =
+        coarse_alloc(devdax_provider->coarse, size, alignment, resultPtr);
+    if (ret == UMF_RESULT_SUCCESS) {
+        provider_ctl_stats_alloc(devdax_provider, size);
+    }
+    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;
@@ -314,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,
@@ -327,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
 
@@ -356,9 +394,18 @@ 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,
@@ -418,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 =
@@ -523,10 +570,23 @@ 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;
-    return coarse_free(devdax_provider->coarse, ptr, size);
+    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 = {
@@ -539,23 +599,25 @@ static umf_memory_provider_ops_t UMF_DEVDAX_MEMORY_PROVIDER_OPS = {
     .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");
@@ -575,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;
@@ -659,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 12a9233229..d666a2fd71 100644
--- a/src/provider/provider_file_memory.c
+++ b/src/provider/provider_file_memory.c
@@ -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,12 +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"
@@ -82,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)
 
@@ -112,13 +123,20 @@ typedef struct file_memory_provider_t {
     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 {
@@ -139,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",
@@ -152,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;
 
@@ -185,15 +228,14 @@ static umf_result_t file_allocation_split_cb(void *provider, void *ptr,
 static umf_result_t file_allocation_merge_cb(void *provider, void *lowPtr,
                                              void *highPtr, size_t totalSize);
 
-static umf_result_t file_initialize(void *params, void **provider) {
+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");
@@ -207,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) {
@@ -269,28 +313,42 @@ static umf_result_t file_initialize(void *params, void **provider) {
 
     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_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:
@@ -299,32 +357,39 @@ static umf_result_t file_initialize(void *params, void **provider) {
     utils_mutex_destroy_not_free(&file_provider->lock);
 err_coarse_delete:
     coarse_delete(file_provider->coarse);
-err_close_fd:
-    utils_close_fd(file_provider->fd);
-err_free_file_provider:
+    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,
@@ -490,7 +555,12 @@ 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;
-    return coarse_alloc(file_provider->coarse, size, alignment, resultPtr);
+    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,
@@ -548,19 +618,19 @@ static umf_result_t file_alloc_cb(void *provider, size_t size, size_t alignment,
     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;
@@ -581,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,
@@ -594,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
 
@@ -624,9 +695,17 @@ 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;
 }
 
 static umf_result_t file_allocation_split(void *provider, void *ptr,
@@ -645,7 +724,8 @@ static umf_result_t file_allocation_split_cb(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("getting a value from the file descriptor offset map failed "
                 "(addr=%p)",
@@ -692,7 +772,7 @@ static umf_result_t file_allocation_merge_cb(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("removing a value from the file descriptor offset map failed "
                 "(addr=%p)",
@@ -735,7 +815,8 @@ 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("getting a value from the IPC cache failed (addr=%p)", ptr);
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
@@ -744,7 +825,7 @@ static umf_result_t file_get_ipc_handle(void *provider, const void *ptr,
     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;
@@ -849,9 +930,22 @@ 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;
-    return coarse_free(file_provider->coarse, ptr, size);
+    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 = {
@@ -864,22 +958,24 @@ static umf_memory_provider_ops_t UMF_FILE_MEMORY_PROVIDER_OPS = {
     .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");
@@ -901,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) {
@@ -982,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
index eeeb8b7025..4e8f22e4fb 100644
--- a/src/provider/provider_fixed_memory.c
+++ b/src/provider/provider_fixed_memory.c
@@ -20,22 +20,29 @@
 #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 {
@@ -52,6 +59,34 @@ static __TLS fixed_last_native_error_t TLS_last_native_error;
 #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"};
@@ -81,15 +116,14 @@ static umf_result_t fixed_allocation_merge_cb(void *provider, void *lowPtr,
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t fixed_initialize(void *params, void **provider) {
+static umf_result_t fixed_initialize(const void *params, void **provider) {
     umf_result_t ret;
 
     if (params == NULL) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    umf_fixed_memory_provider_params_t *in_params =
-        (umf_fixed_memory_provider_params_t *)params;
+    const umf_fixed_memory_provider_params_t *in_params = params;
 
     fixed_memory_provider_t *fixed_provider =
         umf_ba_global_alloc(sizeof(*fixed_provider));
@@ -98,6 +132,8 @@ static umf_result_t fixed_initialize(void *params, void **provider) {
     }
 
     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;
@@ -123,29 +159,20 @@ static umf_result_t fixed_initialize(void *params, void **provider) {
     fixed_provider->base = in_params->ptr;
     fixed_provider->size = in_params->size;
 
-    // add the entire memory as a single block
-    ret = coarse_add_memory_fixed(coarse, fixed_provider->base,
-                                  fixed_provider->size);
-    if (ret != UMF_RESULT_SUCCESS) {
-        LOG_ERR("adding memory block failed");
-        goto err_coarse_delete;
-    }
-
     *provider = fixed_provider;
 
     return UMF_RESULT_SUCCESS;
 
-err_coarse_delete:
-    coarse_delete(fixed_provider->coarse);
 err_free_fixed_provider:
     umf_ba_global_free(fixed_provider);
     return ret;
 }
 
-static void fixed_finalize(void *provider) {
+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,
@@ -153,22 +180,30 @@ static umf_result_t fixed_alloc(void *provider, size_t size, size_t alignment,
     fixed_memory_provider_t *fixed_provider =
         (fixed_memory_provider_t *)provider;
 
-    return coarse_alloc(fixed_provider->coarse, size, alignment, resultPtr);
+    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 void fixed_get_last_native_error(void *provider, const char **ppMessage,
-                                        int32_t *pError) {
+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;
+        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;
+        return UMF_RESULT_SUCCESS;
     }
 
     const char *msg;
@@ -189,6 +224,7 @@ static void fixed_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 fixed_get_recommended_page_size(void *provider, size_t size,
@@ -201,7 +237,7 @@ static umf_result_t fixed_get_recommended_page_size(void *provider, size_t size,
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t fixed_get_min_page_size(void *provider, void *ptr,
+static umf_result_t fixed_get_min_page_size(void *provider, const void *ptr,
                                             size_t *page_size) {
     (void)ptr; // unused
 
@@ -228,9 +264,18 @@ static umf_result_t fixed_purge_force(void *provider, void *ptr, size_t size) {
     return UMF_RESULT_SUCCESS;
 }
 
-static const char *fixed_get_name(void *provider) {
-    (void)provider; // unused
-    return "FIXED";
+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,
@@ -250,7 +295,39 @@ static umf_result_t fixed_allocation_merge(void *provider, void *lowPtr,
 static umf_result_t fixed_free(void *provider, void *ptr, size_t size) {
     fixed_memory_provider_t *fixed_provider =
         (fixed_memory_provider_t *)provider;
-    return coarse_free(fixed_provider->coarse, ptr, size);
+
+    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 = {
@@ -263,23 +340,25 @@ static umf_memory_provider_ops_t UMF_FIXED_MEMORY_PROVIDER_OPS = {
     .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,
-    .ipc.get_ipc_handle_size = NULL,
-    .ipc.get_ipc_handle = NULL,
-    .ipc.put_ipc_handle = NULL,
-    .ipc.open_ipc_handle = NULL,
-    .ipc.close_ipc_handle = NULL};
-
-umf_memory_provider_ops_t *umfFixedMemoryProviderOps(void) {
+    .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(
-    umf_fixed_memory_provider_params_handle_t *hParams, void *ptr,
-    size_t size) {
+    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");
@@ -293,6 +372,9 @@ umf_result_t umfFixedMemoryProviderParamsCreate(
         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);
@@ -335,3 +417,21 @@ umf_result_t umfFixedMemoryProviderParamsSetMemory(
     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 af81e84bc0..7e9f322316 100644
--- a/src/provider/provider_level_zero.c
+++ b/src/provider/provider_level_zero.c
@@ -14,7 +14,10 @@
 #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"
 
@@ -27,92 +30,11 @@ void fini_ze_global_state(void) {
     }
 }
 
-#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;
-}
-
-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_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void) {
-    // not supported
-    LOG_ERR("L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is "
-            "OFF)");
-    return 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"
@@ -122,22 +44,29 @@ umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void) {
 
 // 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;
 
-    umf_level_zero_memory_provider_free_policy_t
-        freePolicy; ///< Memory free policy
+    // 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 {
@@ -145,29 +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 *);
@@ -179,6 +116,8 @@ 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,
@@ -192,11 +131,71 @@ 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:
@@ -211,12 +210,45 @@ 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
+        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.
@@ -246,6 +278,8 @@ static void init_ze_global_state(void) {
         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(lib_handle, "zeDeviceGetProperties", lib_name);
     *(void **)&g_ze_ops.zeMemFreeExt =
@@ -258,7 +292,8 @@ static void init_ze_global_state(void) {
         !g_ze_ops.zeMemGetIpcHandle || !g_ze_ops.zeMemOpenIpcHandle ||
         !g_ze_ops.zeMemCloseIpcHandle ||
         !g_ze_ops.zeContextMakeMemoryResident ||
-        !g_ze_ops.zeDeviceGetProperties || !g_ze_ops.zeMemGetAllocProperties) {
+        !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_FATAL("Required Level Zero symbols not found.");
@@ -291,7 +326,10 @@ umf_result_t umfLevelZeroMemoryProviderParamsCreate(
     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;
 
@@ -361,6 +399,24 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(
     return UMF_RESULT_SUCCESS;
 }
 
+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;
+    }
+
+    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;
+}
+
 umf_result_t umfLevelZeroMemoryProviderParamsSetResidentDevices(
     umf_level_zero_memory_provider_params_handle_t hParams,
     ze_device_handle_t *hDevices, uint32_t deviceCount) {
@@ -368,12 +424,22 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetResidentDevices(
         LOG_ERR("Level Zero memory provider params handle is NULL");
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
-
-    if (deviceCount && !hDevices) {
+    if (deviceCount > 0 && hDevices == NULL) {
         LOG_ERR("Resident devices array is NULL, but deviceCount is not zero");
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
+    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;
+            }
+        }
+    }
+
     hParams->resident_device_handles = hDevices;
     hParams->resident_device_count = deviceCount;
 
@@ -414,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,
@@ -438,11 +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 = 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);
@@ -473,52 +590,59 @@ 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);
-}
-
-static umf_result_t ze_memory_provider_free(void *provider, void *ptr,
-                                            size_t bytes) {
-    (void)bytes;
-
-    if (ptr == NULL) {
-        return UMF_RESULT_SUCCESS;
-    }
-
-    ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)provider;
-
-    if (ze_provider->freePolicyFlags == 0) {
-        return ze2umf_result(g_ze_ops.zeMemFree(ze_provider->context, ptr));
+    if (update_stats) {
+        provider_ctl_stats_alloc(ze_provider, size);
     }
+    return UMF_RESULT_SUCCESS;
+}
 
-    ze_memory_free_ext_desc_t desc = {
-        .stype = ZE_STRUCTURE_TYPE_MEMORY_FREE_EXT_DESC,
-        .pNext = NULL,
-        .freePolicy = ze_provider->freePolicyFlags};
-
-    return ze2umf_result(
-        g_ze_ops.zeMemFreeExt(ze_provider->context, &desc, ptr));
+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);
 }
 
 static umf_result_t query_min_page_size(ze_memory_provider_t *ze_provider,
                                         size_t *min_page_size) {
     assert(min_page_size);
 
-    LOG_DEBUG("Querying minimum page size");
-
     void *ptr;
-    umf_result_t result = ze_memory_provider_alloc(ze_provider, 1, 0, &ptr);
+    umf_result_t result =
+        ze_memory_provider_alloc_helper(ze_provider, 1, 0, 0, &ptr);
     if (result != UMF_RESULT_SUCCESS) {
         return result;
     }
@@ -529,27 +653,30 @@ static umf_result_t query_min_page_size(ze_memory_provider_t *ze_provider,
         ze_provider->context, ptr, &properties, NULL);
 
     *min_page_size = properties.pageSize;
+    LOG_DEBUG("Querying minimum page size, got: %lu", properties.pageSize);
 
-    ze_memory_provider_free(ze_provider, ptr, 1);
+    ze_memory_provider_free_helper(ze_provider, ptr, 1, 0);
 
     return ze2umf_result(ze_result);
 }
 
-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);
-
+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_initialize(void *params,
+static umf_result_t ze_memory_provider_initialize(const void *params,
                                                   void **provider) {
     if (params == 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;
+    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");
@@ -563,10 +690,11 @@ static umf_result_t ze_memory_provider_initialize(void *params,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    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");
+    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;
     }
 
@@ -582,12 +710,17 @@ static umf_result_t ze_memory_provider_initialize(void *params,
         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 = (ze_memory_type_t)ze_params->memory_type;
+    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;
 
@@ -606,27 +739,36 @@ static umf_result_t ze_memory_provider_initialize(void *params,
         }
     }
 
-    if (ze_params->resident_device_count) {
+    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) {
+        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;
         }
 
-        ze_provider->resident_device_count = ze_params->resident_device_count;
+        memcpy(ze_provider->resident_device_handles,
+               ze_params->resident_device_handles,
+               sizeof(ze_device_handle_t) * ze_params->resident_device_count);
 
-        for (uint32_t i = 0; i < ze_provider->resident_device_count; i++) {
-            ze_provider->resident_device_handles[i] =
-                ze_params->resident_device_handles[i];
-        }
+        LOG_INFO("L0 memory provider: %p have %d resident device(s)",
+                 (void *)ze_provider, ze_params->resident_device_count);
     } else {
-        ze_provider->resident_device_handles = NULL;
-        ze_provider->resident_device_count = 0;
+        LOG_INFO("L0 memory provider has no resident devices");
     }
 
-    umf_result_t result =
+    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);
@@ -638,23 +780,24 @@ static umf_result_t ze_memory_provider_initialize(void *params,
     return UMF_RESULT_SUCCESS;
 }
 
-static void ze_memory_provider_get_last_native_error(void *provider,
-                                                     const char **ppMessage,
-                                                     int32_t *pError) {
+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) {
-        ASSERT(0);
-        return;
+        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,
-                                                         void *ptr,
+                                                         const void *ptr,
                                                          size_t *pageSize) {
-    ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)provider;
+    ze_memory_provider_t *ze_provider = provider;
 
     if (!ptr) {
         *pageSize = ze_provider->min_page_size;
@@ -701,9 +844,18 @@ ze_memory_provider_get_recommended_page_size(void *provider, size_t size,
     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,
@@ -734,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;
 
@@ -749,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;
@@ -813,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;
@@ -843,6 +1049,232 @@ ze_memory_provider_close_ipc_handle(void *provider, void *ptr, size_t size) {
     return UMF_RESULT_SUCCESS;
 }
 
+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,
@@ -853,19 +1285,124 @@ static umf_memory_provider_ops_t UMF_LEVEL_ZERO_MEMORY_PROVIDER_OPS = {
     .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.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
index 7da299ffdf..58f130f0cf 100644
--- a/src/provider/provider_level_zero_internal.h
+++ b/src/provider/provider_level_zero_internal.h
@@ -7,4 +7,9 @@
  *
  */
 
+#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 f0cd3abaed..edaf315dc4 100644
--- a/src/provider/provider_os_memory.c
+++ b/src/provider/provider_os_memory.c
@@ -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
@@ -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,7 +1255,7 @@ 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("getting a value from the IPC cache failed (addr=%p)", ptr);
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
@@ -1371,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;
     }
 
@@ -1401,6 +1373,15 @@ 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_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = os_initialize,
@@ -1411,17 +1392,19 @@ static umf_memory_provider_ops_t UMF_OS_MEMORY_PROVIDER_OPS = {
     .get_recommended_page_size = os_get_recommended_page_size,
     .get_min_page_size = os_get_min_page_size,
     .get_name = os_get_name,
-    .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;
 }
 
@@ -1449,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;
 
@@ -1605,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 4a603b1dad..3648d4a88f 100644
--- a/src/provider/provider_os_memory_internal.h
+++ b/src/provider/provider_os_memory_internal.h
@@ -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
@@ -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 c5a4b5f1f4..573e9bb357 100644
--- a/src/provider/provider_tracking.c
+++ b/src/provider/provider_tracking.c
@@ -15,6 +15,7 @@
 
 #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"
@@ -22,6 +23,8 @@
 #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"
@@ -32,6 +35,8 @@
 
 uint64_t IPC_HANDLE_ID = 0;
 
+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
@@ -43,16 +48,8 @@ struct umf_memory_tracker_t {
     critnib *ipc_segments_map;
 };
 
-typedef struct tracker_alloc_info_t {
-    umf_memory_pool_handle_t pool;
-    size_t size;
-    // number of overlapping memory regions
-    // in the next level of map
-    // falling within the current range
-    size_t n_children;
-} tracker_alloc_info_t;
-
 typedef struct tracker_ipc_info_t {
+    umf_memory_properties_t props;
     size_t size;
     umf_memory_provider_handle_t provider;
     ipc_opened_cache_value_t *ipc_cache_value;
@@ -65,45 +62,93 @@ typedef struct tracker_ipc_info_t {
 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,
-    int no_children) {
+    void **_ref_value, void **_ref_parent_value, int no_children) {
+
     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);
-        if (!found || !rvalue) {
+                         FIND_LE, (void *)&rkey, (void **)&rvalue, &ref_value);
+        if (!found) {
+            assert(ref_value == NULL);
             break;
         }
 
-        utils_atomic_load_acquire_u64((uint64_t *)&rvalue->size, &rsize);
+        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;
+        }
 
-        if (found && (uintptr_t)ptr < rkey + rsize) {
-            if (rvalue->n_children) {
-                if (level == MAX_LEVELS_OF_ALLOC_SEGMENT_MAP - 1) {
-                    break;
-                }
-                level++;
+        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) && rvalue->n_children);
+    } while (found && ((uintptr_t)ptr < rkey + rsize) && n_children);
 
     if (!rvalue || rkey != (uintptr_t)ptr) {
         return NULL;
     }
 
-    if (no_children && (rvalue->n_children > 0)) {
+    if (no_children && (n_children > 0)) {
         return NULL;
     }
 
@@ -114,10 +159,13 @@ static tracker_alloc_info_t *get_most_nested_alloc_segment(
         *_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;
 }
@@ -126,7 +174,8 @@ 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) {
+                           tracker_alloc_info_t *parent_value,
+                           void *ref_parent_value) {
     assert(ptr);
 
     umf_result_t umf_result = UMF_RESULT_ERROR_UNKNOWN;
@@ -138,9 +187,30 @@ umfMemoryTrackerAddAtLevel(umf_memory_tracker_handle_t hTracker, int level,
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    value->pool = pool;
-    utils_atomic_store_release_u64(&value->size, size);
+    // get provider
+    umf_memory_provider_handle_t provider = NULL;
+    umfPoolGetMemoryProvider(pool, &provider);
+
+    // 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],
@@ -151,13 +221,17 @@ umfMemoryTrackerAddAtLevel(umf_memory_tracker_handle_t hTracker, int level,
                   (void *)hTracker, level, (void *)pool, ptr, size);
 
         if (parent_value) {
-            parent_value->n_children++;
+            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",
-                parent_value->n_children, (void *)hTracker, level - 1,
-                (void *)parent_value->pool, (void *)parent_key,
-                parent_value->size);
+                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;
     }
@@ -179,27 +253,54 @@ static umf_result_t umfMemoryTrackerAdd(umf_memory_tracker_handle_t hTracker,
                                         const void *ptr, size_t size) {
     assert(ptr);
 
-    umf_result_t umf_result = UMF_RESULT_ERROR_UNKNOWN;
     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);
-        if (!found || !rvalue) {
+                         FIND_LE, (void *)&rkey, (void **)&rvalue, &ref_value);
+        if (!found) {
+            assert(ref_value == NULL);
             break;
         }
 
-        utils_atomic_load_acquire_u64((uint64_t *)&rvalue->size, &rsize);
+        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) {
@@ -213,23 +314,30 @@ static umf_result_t umfMemoryTrackerAdd(umf_memory_tracker_handle_t hTracker,
                     "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->pool, (void *)rkey,
-                    (size_t)rsize);
+                    (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++;
         }
-    } while (found && ((uintptr_t)ptr < rkey + rsize) && rvalue->n_children);
+        utils_atomic_load_acquire_size_t(&rvalue->n_children, &n_children);
+    } while (found && ((uintptr_t)ptr < rkey + rsize) && n_children);
 
-    umf_result = umfMemoryTrackerAddAtLevel(hTracker, level, pool, ptr, size,
-                                            parent_key, parent_value);
-    if (umf_result != UMF_RESULT_SUCCESS) {
-        return umf_result;
+    if (ref_value && ref_value != ref_parent_value) {
+        critnib_release(hTracker->alloc_segments_map[level], ref_value);
     }
 
-    return UMF_RESULT_SUCCESS;
+    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,
@@ -247,31 +355,51 @@ static umf_result_t umfMemoryTrackerRemove(umf_memory_tracker_handle_t hTracker,
 
     // 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, 1 /* no_children */);
+        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 alloc_segments_map", ptr);
         return UMF_RESULT_ERROR_UNKNOWN;
     }
 
     assert(level < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP);
-    value = critnib_remove(hTracker->alloc_segments_map[level], (uintptr_t)ptr);
+
+    // 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);
+
+    value = critnib_remove(hTracker->alloc_segments_map[level], (uintptr_t)ptr,
+                           &ref_value);
     assert(value);
 
     LOG_DEBUG("memory region removed: tracker=%p, level=%i, pool=%p, ptr=%p, "
               "size=%zu",
-              (void *)hTracker, level, value->pool, ptr, value->size);
+              (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",
-            parent_value->n_children, (void *)hTracker, level - 1,
-            (void *)parent_value->pool, (void *)parent_key, parent_value->size);
-        parent_value->n_children--;
-    }
+            n_children, (void *)hTracker, level - 1,
+            (void *)parent_value->props.pool, (void *)parent_key,
+            parent_value->props.base_size);
 
-    umf_ba_free(hTracker->alloc_info_allocator, value);
+        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;
 }
@@ -293,22 +421,39 @@ umfMemoryTrackerAddIpcSegment(umf_memory_tracker_handle_t hTracker,
         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, provider, cache_entry);
+                  (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, provider, cache_entry);
+            ret, ptr, size, (void *)provider, (void *)cache_entry);
 
     umf_ba_free(hTracker->ipc_info_allocator, value);
 
@@ -324,8 +469,9 @@ umfMemoryTrackerRemoveIpcSegment(umf_memory_tracker_handle_t hTracker,
                                  const void *ptr) {
     assert(ptr);
 
-    void *value = critnib_remove(hTracker->ipc_segments_map, (uintptr_t)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;
@@ -335,73 +481,104 @@ umfMemoryTrackerRemoveIpcSegment(umf_memory_tracker_handle_t hTracker,
 
     LOG_DEBUG("IPC memory region removed: tracker=%p, ptr=%p, size=%zu, "
               "provider=%p, cache_entry=%p",
-              (void *)hTracker, ptr, v->size, v->provider, v->ipc_cache_value);
+              (void *)hTracker, ptr, v->size, (void *)v->provider,
+              (void *)v->ipc_cache_value);
 
-    umf_ba_free(hTracker->ipc_info_allocator, value);
+    assert(ref_value);
+    critnib_release(hTracker->ipc_segments_map, ref_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;
-    }
-
-    return allocInfo.pool;
-}
-
 umf_result_t umfMemoryTrackerGetAllocInfo(const void *ptr,
-                                          umf_alloc_info_t *pAllocInfo) {
-    assert(pAllocInfo);
+                                          tracker_alloc_info_t **info) {
+    assert(info);
 
-    if (ptr == NULL) {
+    if (UNLIKELY(ptr == NULL)) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    if (TRACKER == NULL) {
+    if (UNLIKELY(TRACKER == NULL)) {
         LOG_ERR("tracker does not exist");
         return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
 
-    if (TRACKER->alloc_segments_map[0] == NULL) {
+    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 top_most_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_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);
-        if (found && (uintptr_t)ptr < rkey + rvalue->size) {
-            top_most_key = rkey;
+        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 (rvalue->n_children == 0 ||
+            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 + rvalue->size &&
-             rvalue->n_children);
+    } 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;
     }
 
-    pAllocInfo->base = (void *)top_most_key;
-    pAllocInfo->baseSize = top_most_value->size;
-    pAllocInfo->pool = top_most_value->pool;
+    *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;
 }
@@ -424,13 +601,19 @@ umf_result_t umfMemoryTrackerGetIpcInfo(const void *ptr,
         return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
 
-    uintptr_t rkey;
+    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);
-    if (!found || (uintptr_t)ptr >= rkey + rvalue->size) {
+                             (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;
     }
 
@@ -438,6 +621,12 @@ umf_result_t umfMemoryTrackerGetIpcInfo(const void *ptr,
     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;
 }
 
@@ -504,36 +693,28 @@ static umf_result_t trackingAllocationSplit(void *hProvider, void *ptr,
     tracker_alloc_info_t *parent_value = NULL;
     uintptr_t parent_key = 0;
 
-    tracker_alloc_info_t *splitValue =
-        umf_ba_alloc(provider->hTracker->alloc_info_allocator);
-    if (!splitValue) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    splitValue->pool = provider->pool;
-    splitValue->size = firstSize;
-    splitValue->n_children = 0;
-
     int r = utils_mutex_lock(&provider->hTracker->splitMergeMutex);
     if (r) {
         goto err_lock;
     }
 
     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,
-        1 /* no_children */);
+        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) {
+    if (value->props.base_size != totalSize) {
         LOG_ERR("tracked size=%zu does not match requested size to split: %zu",
-                value->size, totalSize);
+                value->props.base_size, totalSize);
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
         goto err;
     }
@@ -545,41 +726,36 @@ static umf_result_t trackingAllocationSplit(void *hProvider, void *ptr,
         goto err;
     }
 
-    assert(level < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP);
-    int cret =
-        critnib_insert(provider->hTracker->alloc_segments_map[level],
-                       (uintptr_t)ptr, (void *)splitValue, 1 /* update */);
-    // this cannot fail since we know the element exists (nothing to allocate)
-    assert(cret == 0);
-    (void)cret;
-
     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 = umfMemoryTrackerAddAtLevel(provider->hTracker, level, provider->pool,
                                      highPtr, secondSize, parent_key,
-                                     parent_value);
+                                     parent_value, ref_parent_value);
     if (ret != UMF_RESULT_SUCCESS) {
         LOG_ERR("failed to add the split region to the tracker, ptr=%p, "
                 "size=%zu, ret=%d",
                 highPtr, secondSize, ret);
+
         // revert the split
-        assert(level < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP);
-        cret = critnib_insert(provider->hTracker->alloc_segments_map[level],
-                              (uintptr_t)ptr, (void *)value, 1 /* update */);
-        // this cannot fail since we know the element exists (nothing to allocate)
-        assert(cret == 0);
-        (void)cret;
+        (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;
     }
 
-    // free the original value
-    umf_ba_free(provider->hTracker->alloc_info_allocator, value);
+    // 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);
+
     utils_mutex_unlock(&provider->hTracker->splitMergeMutex);
 
     LOG_DEBUG(
@@ -590,9 +766,8 @@ static umf_result_t trackingAllocationSplit(void *hProvider, void *ptr,
 
 err:
     utils_mutex_unlock(&provider->hTracker->splitMergeMutex);
-err_lock:
-    umf_ba_free(provider->hTracker->alloc_info_allocator, splitValue);
 
+err_lock:
     LOG_ERR(
         "failed to split memory region: ptr=%p, totalSize=%zu, firstSize=%zu",
         ptr, totalSize, firstSize);
@@ -606,17 +781,6 @@ static umf_result_t trackingAllocationMerge(void *hProvider, void *lowPtr,
     umf_tracking_memory_provider_t *provider =
         (umf_tracking_memory_provider_t *)hProvider;
 
-    tracker_alloc_info_t *mergedValue =
-        umf_ba_alloc(provider->hTracker->alloc_info_allocator);
-
-    if (!mergedValue) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    mergedValue->pool = provider->pool;
-    mergedValue->size = totalSize;
-    mergedValue->n_children = 0;
-
     // any different negative values
     int lowLevel = -2;
     int highLevel = -1;
@@ -626,88 +790,93 @@ static umf_result_t trackingAllocationMerge(void *hProvider, void *lowPtr,
         goto err_lock;
     }
 
+    void *ref_lowValue = NULL;
+    void *ref_highValue = NULL;
+
     tracker_alloc_info_t *lowValue = get_most_nested_alloc_segment(
-        provider->hTracker, lowPtr, &lowLevel, NULL, NULL,
-        0 /* no_children */); // can have children
+        provider->hTracker, lowPtr, &lowLevel, NULL, NULL, &ref_lowValue, NULL,
+        0 /* no_children */);
     if (!lowValue) {
         LOG_FATAL("no left value");
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_assert;
+        goto err_fatal;
     }
+    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,
-        0 /* no_children */); // can have children
+        provider->hTracker, highPtr, &highLevel, NULL, NULL, &ref_highValue,
+        NULL, 0 /* no_children */);
     if (!highValue) {
         LOG_FATAL("no right value");
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_assert;
+        goto err_fatal;
     }
+    if (highValue->n_children) {
+        LOG_FATAL("right value is used (has children)");
+        ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        goto err_fatal;
+    }
+
     if (lowLevel != highLevel) {
         LOG_FATAL("tracker level mismatch");
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_assert;
+        goto err_fatal;
     }
-    if (lowValue->pool != highValue->pool) {
+    if (lowValue->props.pool != highValue->props.pool) {
         LOG_FATAL("pool mismatch");
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_assert;
+        goto err_fatal;
     }
-    if (lowValue->size + highValue->size != totalSize) {
+    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_assert;
+        goto err_fatal;
     }
 
-    mergedValue->n_children = lowValue->n_children + highValue->n_children;
-
     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;
     }
 
-    size_t lno = lowValue->n_children;
-    size_t hno = highValue->n_children;
+    // we only need to update the size of the first part
+    utils_atomic_store_release_u64((uint64_t *)&lowValue->props.base_size,
+                                   totalSize);
 
-    // 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->alloc_segments_map[lowLevel],
-                       (uintptr_t)lowPtr, (void *)mergedValue, 1 /* update */);
-    // this cannot fail since we know the element exists (nothing to allocate)
-    assert(cret == 0);
-    (void)cret;
+    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->alloc_info_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->alloc_segments_map[highLevel], (uintptr_t)highPtr);
-    assert(erasedhighValue == highValue);
-
-    umf_ba_free(provider->hTracker->alloc_info_allocator, erasedhighValue);
-
-    utils_mutex_unlock(&provider->hTracker->splitMergeMutex);
+    critnib_remove_release(provider->hTracker->alloc_segments_map[highLevel],
+                           (uintptr_t)highPtr);
 
     LOG_DEBUG("merged memory regions (level=%i): lowPtr=%p (child=%zu), "
               "highPtr=%p (child=%zu), totalSize=%zu",
-              lowLevel, lowPtr, lno, highPtr, hno, totalSize);
+              lowLevel, lowPtr, low_children, highPtr, high_children,
+              totalSize);
+
+    utils_mutex_unlock(&provider->hTracker->splitMergeMutex);
 
     return UMF_RESULT_SUCCESS;
 
-err_assert:
+err_fatal:
     LOG_FATAL("failed to merge memory regions: lowPtr=%p (level=%i), "
               "highPtr=%p (level=%i), totalSize=%zu",
               lowPtr, lowLevel, highPtr, highLevel, totalSize);
-    assert(0);
 
-not_merged:
+cannot_merge:
     utils_mutex_unlock(&provider->hTracker->splitMergeMutex);
 
 err_lock:
-    umf_ba_free(provider->hTracker->alloc_info_allocator, mergedValue);
-
     LOG_ERR("failed to merge memory regions: lowPtr=%p (level=%i), highPtr=%p "
             "(level=%i), totalSize=%zu",
             lowPtr, lowLevel, highPtr, highLevel, totalSize);
@@ -736,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,
@@ -746,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);
@@ -760,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;
     }
@@ -770,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;
@@ -796,11 +968,21 @@ static void check_if_tracker_is_empty(umf_memory_tracker_handle_t hTracker,
         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)) {
-            if (rvalue->pool == pool || pool == NULL) {
+                                 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);
+            }
+
+            if (ref_value) {
+                critnib_release(hTracker->alloc_segments_map[i], ref_value);
             }
 
             last_key = rkey;
@@ -829,7 +1011,7 @@ static void check_if_tracker_is_empty(umf_memory_tracker_handle_t hTracker,
 }
 #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;
 
@@ -838,13 +1020,14 @@ static void trackingFinalize(void *provider) {
     critnib_delete(p->ipcCache);
 
     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,
@@ -855,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;
@@ -874,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) {
@@ -900,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 "
@@ -965,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;
 }
 
@@ -1105,26 +1303,42 @@ static umf_result_t trackingOpenIpcHandle(void *provider, void *providerIpcData,
     return ret;
 }
 
-static tracker_ipc_info_t *getTrackerIpcInfo(const void *ptr) {
-    assert(ptr);
-
-    uintptr_t key = (uintptr_t)ptr;
-    tracker_ipc_info_t *value = critnib_get(TRACKER->ipc_segments_map, key);
-
-    return value;
-}
-
 static umf_result_t trackingCloseIpcHandle(void *provider, void *ptr,
                                            size_t size) {
     (void)provider;
-    tracker_ipc_info_t *trackerIpcInfo = getTrackerIpcInfo(ptr);
-
+    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;
     }
 
-    return umfIpcHandleMappedCacheRelease(trackerIpcInfo->ipc_cache_value);
+    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 = {
@@ -1137,15 +1351,25 @@ umf_memory_provider_ops_t UMF_TRACKING_MEMORY_PROVIDER_OPS = {
     .get_min_page_size = trackingGetMinPageSize,
     .get_recommended_page_size = trackingGetRecommendedPageSize,
     .get_name = trackingName,
-    .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,
@@ -1159,7 +1383,7 @@ umf_result_t umfTrackingMemoryProviderCreate(
         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;
@@ -1187,18 +1411,36 @@ 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 *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;
     }
 
@@ -1206,13 +1448,16 @@ umf_memory_tracker_handle_t umfMemoryTrackerCreate(void) {
 
     void *mutex_ptr = utils_mutex_init(&handle->splitMergeMutex);
     if (!mutex_ptr) {
+        ret = UMF_RESULT_ERROR_UNKNOWN;
         goto err_destroy_alloc_info_allocator;
     }
 
     int i;
     for (i = 0; i < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP; i++) {
-        handle->alloc_segments_map[i] = critnib_new();
+        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;
         }
     }
@@ -1220,18 +1465,21 @@ umf_memory_tracker_handle_t umfMemoryTrackerCreate(void) {
     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();
+    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;
     }
 
     LOG_DEBUG("tracker created, handle=%p, alloc_segments_map=%p",
               (void *)handle, (void *)handle->alloc_segments_map);
-
-    return handle;
+    *handle_out = handle;
+    return ret;
 
 err_destroy_ipc_info_allocator:
     umf_ba_destroy(handle->ipc_info_allocator);
@@ -1246,7 +1494,7 @@ umf_memory_tracker_handle_t umfMemoryTrackerCreate(void) {
     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) {
@@ -1283,3 +1531,26 @@ void umfMemoryTrackerDestroy(umf_memory_tracker_handle_t handle) {
     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 842449be5c..254bbf6786 100644
--- a/src/provider/provider_tracking.h
+++ b/src/provider/provider_tracking.h
@@ -20,6 +20,7 @@
 
 #include "base_alloc.h"
 #include "critnib.h"
+#include "memory_properties_internal.h"
 #include "utils_concurrency.h"
 
 #ifdef __cplusplus
@@ -31,21 +32,26 @@ 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;
 
-typedef struct umf_alloc_info_t {
-    void *base;
-    size_t baseSize;
-    umf_memory_pool_handle_t pool;
-} umf_alloc_info_t;
+    // 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,
-                                          umf_alloc_info_t *pAllocInfo);
+                                          tracker_alloc_info_t **info);
 
 typedef struct umf_ipc_info_t {
+    umf_memory_properties_handle_t props;
+
     void *base;
     size_t baseSize;
     umf_memory_provider_handle_t provider;
@@ -64,6 +70,10 @@ 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 ccb60f8aba..690cdb63fa 100644
--- a/src/proxy_lib/proxy_lib.c
+++ b/src/proxy_lib/proxy_lib.c
@@ -391,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");
         }
@@ -425,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;
@@ -474,10 +478,13 @@ 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 (Proxy_pool && (umfPoolByPtr(ptr) == Proxy_pool)) {
+    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;
         return size;
     }
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 976a2cb626..e26017e79d 100644
--- a/src/utils/CMakeLists.txt
+++ b/src/utils/CMakeLists.txt
@@ -5,33 +5,14 @@
 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_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)
 
-if(UMF_USE_VALGRIND)
-    if(UMF_USE_ASAN
-       OR UMF_USE_TSAN
-       OR UMF_USE_UBSAN
-       OR UMF_USE_MSAN)
-        message(FATAL_ERROR "Cannot use valgrind and sanitizers together")
-    endif()
-
-    if(PkgConfig_FOUND)
-        pkg_check_modules(VALGRIND valgrind)
-    endif()
-    if(NOT VALGRIND_FOUND)
-        find_package(VALGRIND REQUIRED valgrind)
-    endif()
-endif()
-
 if(LINUX OR MACOSX)
     set(UMF_UTILS_SOURCES ${UMF_UTILS_SOURCES_COMMON}
                           ${UMF_UTILS_SOURCES_POSIX})
@@ -48,24 +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.h b/src/utils/utils_common.h
index fff44f390c..17dd006ad6 100644
--- a/src/utils/utils_common.h
+++ b/src/utils/utils_common.h
@@ -57,11 +57,17 @@ typedef enum umf_purge_advise_t {
 
 #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);
@@ -115,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);
 
diff --git a/src/utils/utils_concurrency.h b/src/utils/utils_concurrency.h
index 31e5793b96..74c7fc8ae1 100644
--- a/src/utils/utils_concurrency.h
+++ b/src/utils/utils_concurrency.h
@@ -40,6 +40,7 @@ using std::memory_order_release;
 
 #endif /* !_WIN32 */
 
+#include "utils_assert.h"
 #include "utils_common.h"
 #include "utils_sanitizers.h"
 
@@ -70,12 +71,12 @@ typedef struct utils_rwlock_t {
 #endif
 } utils_rwlock_t;
 
-utils_rwlock_t *utils_rwlock_init(utils_rwlock_t *ptr);
+int utils_rwlock_init(utils_rwlock_t *ptr);
 void utils_rwlock_destroy_not_free(utils_rwlock_t *rwlock);
-int utils_read_lock(utils_rwlock_t *rwlock);
-int utils_write_lock(utils_rwlock_t *rwlock);
-int utils_read_unlock(utils_rwlock_t *rwlock);
-int utils_write_unlock(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
@@ -102,12 +103,30 @@ static inline void utils_atomic_load_acquire_u64(uint64_t *ptr, uint64_t *out) {
     *out = *(uint64_t *)&ret;
 }
 
+// There is no good way to do atomic_load on windows...
+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;
+}
+
 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);
@@ -152,15 +171,17 @@ static inline bool utils_compare_exchange_u64(uint64_t *ptr, uint64_t *expected,
     return false;
 }
 
-static inline void utils_atomic_store_release_u64(void *ptr, uint64_t val) {
-    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
-    LONG64 out;
-    LONG64 desired = (LONG64)val;
-    LONG64 expected = 0;
-    while (expected != (out = InterlockedCompareExchange64(
-                            (LONG64 volatile *)ptr, desired, expected))) {
-        expected = out;
+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)
@@ -172,6 +193,11 @@ static inline void utils_atomic_load_acquire_u64(uint64_t *ptr, uint64_t *out) {
     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);
@@ -179,9 +205,15 @@ static inline void utils_atomic_load_acquire_ptr(void **ptr, void **out) {
     utils_annotate_acquire(ptr);
 }
 
-static inline void utils_atomic_store_release_u64(void *ptr, uint64_t val) {
+static inline void utils_atomic_store_release_u64(uint64_t *ptr, uint64_t val) {
     ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
-    __atomic_store_n((uintptr_t *)ptr, (uintptr_t)val, memory_order_release);
+    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) {
@@ -222,8 +254,52 @@ static inline bool utils_compare_exchange_u64(uint64_t *ptr, uint64_t *expected,
                                      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
 }
 #endif
diff --git a/src/utils/utils_level_zero.cpp b/src/utils/utils_level_zero.cpp
index f5a42b0fae..ee7aa85eae 100644
--- a/src/utils/utils_level_zero.cpp
+++ b/src/utils/utils_level_zero.cpp
@@ -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);
@@ -141,7 +139,7 @@ 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
 #if OPEN_ZE_LIBRARY_GLOBAL
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_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 613b8ea41d..da051695b2 100644
--- a/src/utils/utils_posix_common.c
+++ b/src/utils/utils_posix_common.c
@@ -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) {
diff --git a/src/utils/utils_posix_concurrency.c b/src/utils/utils_posix_concurrency.c
index 44a3173611..0149263df3 100644
--- a/src/utils/utils_posix_concurrency.c
+++ b/src/utils/utils_posix_concurrency.c
@@ -38,35 +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);
 }
 
-utils_rwlock_t *utils_rwlock_init(utils_rwlock_t *ptr) {
+int utils_rwlock_init(utils_rwlock_t *ptr) {
     pthread_rwlock_t *rwlock = (pthread_rwlock_t *)ptr;
-    int ret = pthread_rwlock_init(rwlock, NULL);
-    return ret == 0 ? ((utils_rwlock_t *)rwlock) : NULL;
+    return pthread_rwlock_init(rwlock, NULL);
 }
 
 void utils_rwlock_destroy_not_free(utils_rwlock_t *ptr) {
     pthread_rwlock_t *rwlock = (pthread_rwlock_t *)ptr;
-    int ret = pthread_rwlock_destroy(rwlock);
-    if (ret) {
-        LOG_ERR("pthread_rwlock_destroy failed");
+    if (pthread_rwlock_destroy(rwlock) != 0) {
+        LOG_FATAL("pthread_rwlock_destroy failed");
+        abort();
     }
 }
 
-int utils_read_lock(utils_rwlock_t *rwlock) {
-    return pthread_rwlock_rdlock((pthread_rwlock_t *)rwlock);
+void utils_read_lock(utils_rwlock_t *rwlock) {
+    if (pthread_rwlock_rdlock((pthread_rwlock_t *)rwlock) != 0) {
+        LOG_FATAL("pthread_rwlock_rdlock failed");
+        abort();
+    }
 }
 
-int utils_write_lock(utils_rwlock_t *rwlock) {
-    return pthread_rwlock_wrlock((pthread_rwlock_t *)rwlock);
+void utils_write_lock(utils_rwlock_t *rwlock) {
+    if (pthread_rwlock_wrlock((pthread_rwlock_t *)rwlock) != 0) {
+        LOG_FATAL("pthread_rwlock_wrlock failed");
+        abort();
+    }
 }
 
-int utils_read_unlock(utils_rwlock_t *rwlock) {
-    return pthread_rwlock_unlock((pthread_rwlock_t *)rwlock);
+void utils_read_unlock(utils_rwlock_t *rwlock) {
+    if (pthread_rwlock_unlock((pthread_rwlock_t *)rwlock) != 0) {
+        LOG_FATAL("pthread_rwlock_unlock failed");
+        abort();
+    }
 }
 
-int utils_write_unlock(utils_rwlock_t *rwlock) {
-    return pthread_rwlock_unlock((pthread_rwlock_t *)rwlock);
+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_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 faa302be36..645d87b106 100644
--- a/src/utils/utils_windows_concurrency.c
+++ b/src/utils/utils_windows_concurrency.c
@@ -36,7 +36,7 @@ int utils_mutex_unlock(utils_mutex_t *mutex) {
     return 0;
 }
 
-utils_rwlock_t *utils_rwlock_init(utils_rwlock_t *rwlock) {
+int utils_rwlock_init(utils_rwlock_t *rwlock) {
     InitializeSRWLock(&rwlock->lock);
     return 0; // never fails
 }
@@ -46,24 +46,20 @@ void utils_rwlock_destroy_not_free(utils_rwlock_t *rwlock) {
     (void)rwlock;
 }
 
-int utils_read_lock(utils_rwlock_t *rwlock) {
-    AcquireSRWLockShared(&rwlock->lock);
-    return 0; // never fails
+void utils_read_lock(utils_rwlock_t *rwlock) {
+    AcquireSRWLockShared(&rwlock->lock); // never fails
 }
 
-int utils_write_lock(utils_rwlock_t *rwlock) {
-    AcquireSRWLockExclusive(&rwlock->lock);
-    return 0; // never fails
+void utils_write_lock(utils_rwlock_t *rwlock) {
+    AcquireSRWLockExclusive(&rwlock->lock); // never fails
 }
 
-int utils_read_unlock(utils_rwlock_t *rwlock) {
-    ReleaseSRWLockShared(&rwlock->lock);
-    return 0; // never fails
+void utils_read_unlock(utils_rwlock_t *rwlock) {
+    ReleaseSRWLockShared(&rwlock->lock); // never fails
 }
 
-int utils_write_unlock(utils_rwlock_t *rwlock) {
-    ReleaseSRWLockExclusive(&rwlock->lock);
-    return 0; // never fails
+void utils_write_unlock(utils_rwlock_t *rwlock) {
+    ReleaseSRWLockExclusive(&rwlock->lock); // never fails
 }
 
 static BOOL CALLBACK initOnceCb(PINIT_ONCE InitOnce, PVOID Parameter,
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 20f982c65e..b6493b8582 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -11,24 +11,33 @@ if(CMAKE_C_COMPILER_ID STREQUAL "IntelLLVM")
     add_link_options(-static-intel)
 endif()
 
-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)
+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:
@@ -49,18 +58,16 @@ function(build_umf_test)
     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_CUDA_PROVIDER)
+    if(UMF_CUDA_ENABLED)
         set(INC_DIRS ${INC_DIRS} ${CUDA_INCLUDE_DIRS})
         set(LIB_DIRS ${LIB_DIRS} ${CUDA_LIBRARY_DIRS})
     endif()
 
-    if(UMF_BUILD_LEVEL_ZERO_PROVIDER)
+    if(UMF_LEVEL_ZERO_ENABLED)
         set(INC_DIRS ${INC_DIRS} ${LEVEL_ZERO_INCLUDE_DIRS})
-    endif()
-
-    if(NOT UMF_DISABLE_HWLOC)
-        set(INC_DIRS ${INC_DIRS} ${LIBHWLOC_INCLUDE_DIRS})
+        set(LIB_DIRS ${LIB_DIRS} ${ZE_LOADER_LIBRARY_DIRS})
     endif()
 
     if(UMF_POOL_JEMALLOC_ENABLED)
@@ -71,12 +78,7 @@ function(build_umf_test)
         set(CPL_DEFS ${CPL_DEFS} UMF_POOL_SCALABLE_ENABLED=1)
     endif()
 
-    set(TEST_LIBS
-        umf_test_common
-        ${ARG_LIBS}
-        GTest::gtest_main
-        ${LIBS_OPTIONAL}
-        umf)
+    set(TEST_LIBS umf_test_common ${ARG_LIBS} GTest::gtest_main umf)
 
     add_umf_executable(
         NAME ${TEST_TARGET_NAME}
@@ -147,30 +149,41 @@ function(add_umf_test)
     if(WINDOWS)
         # 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>/"
-        )
+            "${DLL_PATH_LIST};"
+            "PATH=path_list_append:${CMAKE_BINARY_DIR}/bin/;"
+            "PATH=path_list_append:${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
 
-        # append PATH to DLLs
+        # 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()
-    if(LINUX)
-        # prepend LD_LIBRARY_PATH with ${CMAKE_BINARY_DIR}/lib it is required
-        # because ${CMAKE_BINARY_DIR}/lib contains libze_loader.so and tests
-        # should use it instead of system one.
-        set_property(
-            TEST ${TEST_NAME}
-            PROPERTY ENVIRONMENT_MODIFICATION
-                     "LD_LIBRARY_PATH=path_list_prepend:${CMAKE_BINARY_DIR}/lib"
-        )
-    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
@@ -192,29 +205,34 @@ if(UMF_BUILD_SHARED_LIBRARY)
     endif()
 endif()
 
-if(UMF_BUILD_SHARED_LIBRARY)
-    # if build as shared library, ba symbols won't be visible in tests
-    set(BA_SOURCES_FOR_TEST ${BA_SOURCES})
-endif()
-
 add_umf_test(NAME base SRCS base.cpp)
+
 add_umf_test(
     NAME memoryPool
-    SRCS memoryPoolAPI.cpp malloc_compliance_tests.cpp ${BA_SOURCES_FOR_TEST}
-    LIBS ${UMF_UTILS_FOR_TEST})
+    SRCS memoryPoolAPI.cpp malloc_compliance_tests.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+
 add_umf_test(
     NAME memoryProvider
-    SRCS memoryProviderAPI.cpp ${BA_SOURCES_FOR_TEST}
-    LIBS ${UMF_UTILS_FOR_TEST})
+    SRCS memoryProviderAPI.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+
+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
-    SRCS ctl/test.cpp ctl/ctl_debug.c ../src/ctl/ctl.c ${BA_SOURCES_FOR_TEST}
-    LIBS ${UMF_UTILS_FOR_TEST})
+    NAME ctl_api
+    SRCS ctl/ctl_api.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 
 add_umf_test(
     NAME utils_common
@@ -228,54 +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 ctl_env_driver
+    SRCS ctl/ctl_env_driver.cpp
+    LIBS ${UMF_UTILS_FOR_TEST})
+
+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 ${BA_SOURCES_FOR_TEST}
-    LIBS ${UMF_UTILS_FOR_TEST} coarse)
+    SRCS coarse_lib.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} umf_coarse)
 
 add_umf_test(
     NAME disjoint_pool
     SRCS pools/disjoint_pool.cpp malloc_compliance_tests.cpp
+    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 ${BA_SOURCES_FOR_TEST}
+    SRCS c_api/disjoint_pool.c
     LIBS ${UMF_UTILS_FOR_TEST})
 
-if(LINUX AND (NOT UMF_DISABLE_HWLOC))
+if(LINUX)
     # this test uses the file provider
     add_umf_test(
         NAME disjoint_pool_file_prov
-        SRCS disjoint_pool_file_prov.cpp ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        SRCS disjoint_pool_file_prov.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 endif()
 
-if(UMF_POOL_JEMALLOC_ENABLED
-   AND UMF_POOL_SCALABLE_ENABLED
-   AND (NOT UMF_DISABLE_HWLOC))
+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
-             ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 endif()
 
-if(UMF_POOL_SCALABLE_ENABLED AND (NOT UMF_DISABLE_HWLOC))
+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()
@@ -285,40 +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})
+        SRCS provider_os_memory.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_os_memory_multiple_numa_nodes
         SRCS provider_os_memory_multiple_numa_nodes.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES})
     add_umf_test(
         NAME memspace_numa
         SRCS memspaces/memspace_numa.cpp
-        LIBS ${LIBNUMA_LIBRARIES} ${UMF_HWLOC_NAME})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME provider_os_memory_config
         SRCS provider_os_memory_config.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES} ${UMF_HWLOC_NAME})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME memspace_host_all
         SRCS memspaces/memspace_host_all.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES} ${UMF_HWLOC_NAME})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME memspace_highest_capacity
         SRCS memspaces/memspace_highest_capacity.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES} ${UMF_HWLOC_NAME})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME memspace_highest_bandwidth
         SRCS memspaces/memspace_highest_bandwidth.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES} ${UMF_HWLOC_NAME})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME memspace_lowest_latency
         SRCS memspaces/memspace_lowest_latency.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES} ${UMF_HWLOC_NAME})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME mempolicy
         SRCS memspaces/mempolicy.cpp
-        LIBS ${LIBNUMA_LIBRARIES})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES})
     add_umf_test(
         NAME memspace
         SRCS memspaces/memspace.cpp
@@ -330,45 +382,46 @@ if(LINUX AND (NOT UMF_DISABLE_HWLOC)) # OS-specific functions are implemented
     add_umf_test(
         NAME provider_devdax_memory
         SRCS provider_devdax_memory.cpp
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_devdax_memory_ipc
-        SRCS provider_devdax_memory_ipc.cpp ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        SRCS provider_devdax_memory_ipc.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_file_memory
         SRCS provider_file_memory.cpp
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_file_memory_ipc
-        SRCS provider_file_memory_ipc.cpp ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        SRCS provider_file_memory_ipc.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_fixed_memory
         SRCS provider_fixed_memory.cpp
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_tracking
         SRCS provider_tracking.cpp
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_tracking_fixture_tests
         SRCS provider_tracking_fixture_tests.cpp malloc_compliance_tests.cpp
-             ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+    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
-                 ${BA_SOURCES_FOR_TEST}
-            LIBS ${UMF_UTILS_FOR_TEST})
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
         add_umf_test(
             NAME jemalloc_coarse_devdax
             SRCS pools/jemalloc_coarse_devdax.cpp malloc_compliance_tests.cpp
-                 ${BA_SOURCES_FOR_TEST}
-            LIBS ${UMF_UTILS_FOR_TEST})
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     endif()
 
     # This test requires Linux-only file memory provider
@@ -376,61 +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)
+             ${UMF_UTILS_DIR}/utils_level_zero.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ze_loader)
 
     add_umf_test(
         NAME provider_level_zero_dlopen_global
         SRCS providers/provider_level_zero.cpp
-             ${UMF_UTILS_DIR}/utils_level_zero.cpp ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+             ${UMF_UTILS_DIR}/utils_level_zero.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     target_compile_definitions(test_provider_level_zero_dlopen_global
                                PUBLIC USE_DLOPEN=1 OPEN_ZE_LIBRARY_GLOBAL=1)
 
     add_umf_test(
         NAME provider_level_zero_dlopen_local
         SRCS providers/provider_level_zero.cpp
-             ${UMF_UTILS_DIR}/utils_level_zero.cpp ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+             ${UMF_UTILS_DIR}/utils_level_zero.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     target_compile_definitions(test_provider_level_zero_dlopen_local
                                PUBLIC USE_DLOPEN=1 OPEN_ZE_LIBRARY_GLOBAL=0)
+
+    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)
@@ -448,28 +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)
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} cuda)
 
         add_umf_test(
             NAME provider_cuda_dlopen_global
             SRCS providers/provider_cuda.cpp providers/cuda_helpers.cpp
-                 ${BA_SOURCES_FOR_TEST}
-            LIBS ${UMF_UTILS_FOR_TEST})
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
         target_compile_definitions(test_provider_cuda_dlopen_global
                                    PUBLIC USE_DLOPEN=1 OPEN_CU_LIBRARY_GLOBAL=1)
 
         add_umf_test(
             NAME provider_cuda_dlopen_local
             SRCS providers/provider_cuda.cpp providers/cuda_helpers.cpp
-                 ${BA_SOURCES_FOR_TEST}
-            LIBS ${UMF_UTILS_FOR_TEST})
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
         target_compile_definitions(test_provider_cuda_dlopen_local
                                    PUBLIC USE_DLOPEN=1 OPEN_CU_LIBRARY_GLOBAL=0)
+
+        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()
@@ -483,31 +542,30 @@ endif()
 
 add_umf_test(
     NAME base_alloc
-    SRCS ${BA_SOURCES_FOR_TEST} test_base_alloc.cpp
-    LIBS ${UMF_UTILS_FOR_TEST})
+    SRCS test_base_alloc.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 add_umf_test(
     NAME base_alloc_linear
-    SRCS ${BA_SOURCES_FOR_TEST} test_base_alloc_linear.cpp
-    LIBS ${UMF_UTILS_FOR_TEST})
+    SRCS test_base_alloc_linear.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 
 add_umf_test(
     NAME base_alloc_global
-    SRCS ${BA_SOURCES_FOR_TEST} pools/pool_base_alloc.cpp
-         malloc_compliance_tests.cpp
-    LIBS ${UMF_UTILS_FOR_TEST})
+    SRCS pools/pool_base_alloc.cpp malloc_compliance_tests.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 
 # tests for the proxy library
 if(UMF_PROXY_LIB_ENABLED AND UMF_BUILD_SHARED_LIBRARY)
     add_umf_test(
         NAME proxy_lib_basic
-        SRCS ${BA_SOURCES_FOR_TEST} test_proxy_lib.cpp
+        SRCS test_proxy_lib.cpp
         LIBS ${UMF_UTILS_FOR_TEST} umf_proxy)
 
     # TODO enable this test on Windows
     if(LINUX)
         add_umf_test(
             NAME proxy_lib_size_threshold
-            SRCS ${BA_SOURCES_FOR_TEST} test_proxy_lib_size_threshold.cpp
+            SRCS test_proxy_lib_size_threshold.cpp
             LIBS ${UMF_UTILS_FOR_TEST} umf_proxy)
         set_property(TEST test_proxy_lib_size_threshold
                      PROPERTY ENVIRONMENT UMF_PROXY="size.threshold=64")
@@ -516,22 +574,21 @@ if(UMF_PROXY_LIB_ENABLED AND UMF_BUILD_SHARED_LIBRARY)
     # the memoryPool test run with the proxy library
     add_umf_test(
         NAME proxy_lib_memoryPool
-        SRCS ${BA_SOURCES_FOR_TEST} memoryPoolAPI.cpp
-             malloc_compliance_tests.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} umf_proxy)
+        SRCS memoryPoolAPI.cpp malloc_compliance_tests.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} umf_proxy)
     target_compile_definitions(test_proxy_lib_memoryPool
                                PUBLIC UMF_PROXY_LIB_ENABLED=1)
 endif()
 
 add_umf_test(
     NAME ipc
-    SRCS ipcAPI.cpp ${BA_SOURCES_FOR_TEST}
-    LIBS ${UMF_UTILS_FOR_TEST})
+    SRCS ipcAPI.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 
 add_umf_test(
     NAME ipc_max_opened_limit
-    SRCS ipcAPI.cpp ${BA_SOURCES_FOR_TEST}
-    LIBS ${UMF_UTILS_FOR_TEST}
+    SRCS ipcAPI.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST}
     ENVS "UMF_MAX_OPENED_IPC_HANDLES=10")
 
 add_umf_test(NAME ipc_negative SRCS ipc_negative.cpp)
@@ -557,32 +614,83 @@ 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)
     if(NOT UMF_TESTS_FAIL_ON_SKIP)
         set_tests_properties(${TEST_NAME} PROPERTIES SKIP_RETURN_CODE 125)
     endif()
-    if(LINUX)
-        # prepend LD_LIBRARY_PATH with ${CMAKE_BINARY_DIR}/lib it is required
-        # because ${CMAKE_BINARY_DIR}/lib contains libze_loader.so and tests
-        # should use it instead of system one.
-        set_property(
-            TEST ${TEST_NAME}
-            PROPERTY ENVIRONMENT_MODIFICATION
-                     "LD_LIBRARY_PATH=path_list_prepend:${CMAKE_BINARY_DIR}/lib"
-        )
-    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
@@ -624,45 +732,16 @@ if(LINUX)
         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)
-        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_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_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_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_UTILS_FOR_TEST})
-        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
@@ -689,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(
@@ -706,7 +785,7 @@ if(LINUX
         )
     endif()
 
-    if(UMF_BUILD_GPU_EXAMPLES 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(
@@ -715,9 +794,7 @@ if(LINUX
                 "UMF_BUILD_LEVEL_ZERO_PROVIDER to be turned ON - skipping")
     endif()
 
-    if(UMF_BUILD_GPU_EXAMPLES
-       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(
@@ -728,7 +805,7 @@ if(LINUX
     endif()
 
     # TODO add IPC examples for CUDA
-    if(UMF_BUILD_GPU_EXAMPLES AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
+    if(UMF_BUILD_GPU_EXAMPLES AND UMF_LEVEL_ZERO_ENABLED)
         set(EXAMPLES ${EXAMPLES} ipc_level_zero)
     else()
         message(
@@ -754,7 +831,7 @@ if(LINUX
         )
     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}"
         )
@@ -774,15 +851,5 @@ if(LINUX
                 "${CMAKE_INSTALL_PREFIX}" "${STANDALONE_CMAKE_OPTIONS}"
                 ${EXAMPLES}
             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-        if(LINUX)
-            # prepend LD_LIBRARY_PATH with ${CMAKE_BINARY_DIR}/lib it is
-            # required because ${CMAKE_BINARY_DIR}/lib contains libze_loader.so
-            # and tests should use it instead of system one.
-            set_property(
-                TEST umf-standalone_examples
-                PROPERTY
-                    ENVIRONMENT_MODIFICATION
-                    "LD_LIBRARY_PATH=path_list_prepend:${CMAKE_BINARY_DIR}/lib")
-        endif()
     endif()
 endif()
diff --git a/test/c_api/disjoint_pool.c b/test/c_api/disjoint_pool.c
index b529497c8f..932e14c38c 100644
--- a/test/c_api/disjoint_pool.c
+++ b/test/c_api/disjoint_pool.c
@@ -36,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);
@@ -48,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/coarse_lib.cpp b/test/coarse_lib.cpp
index 7611833899..598df11ca2 100644
--- a/test/coarse_lib.cpp
+++ b/test/coarse_lib.cpp
@@ -57,13 +57,6 @@ static umf_result_t alloc_cb_fails(void *provider, size_t size,
     return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
 }
 
-static umf_result_t free_cb_fails(void *provider, void *ptr, size_t size) {
-    (void)provider; //unused
-    (void)ptr;      //unused
-    (void)size;     //unused
-    return UMF_RESULT_ERROR_USER_SPECIFIC;
-}
-
 static umf_result_t split_cb_fails(void *provider, void *ptr, size_t totalSize,
                                    size_t firstSize) {
     (void)provider;  //unused
@@ -121,7 +114,14 @@ 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));
+                      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;
@@ -145,30 +145,31 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_provider) {
 
     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, 1);
+    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, 2);
+    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, 0);
+    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, 1);
+    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, 0);
+    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, 1);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
 
     coarse_delete(ch);
-    umfMemoryProviderDestroy(malloc_memory_provider);
+    umf_result = umfMemoryProviderDestroy(malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 }
 
 TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_fixed_memory) {
@@ -194,27 +195,27 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_fixed_memory) {
 
     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, 1);
+    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, 2);
+    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, 0);
+    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, 1);
+    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, 0);
+    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, 1);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
 
     coarse_delete(ch);
 }
@@ -242,7 +243,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_fixed_memory_various) {
 
     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, 1);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
 
     // free NULL
     umf_result = coarse_free(ch, nullptr, 2 * MB);
@@ -257,9 +258,9 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_fixed_memory_various) {
     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, 0);
+    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, 1);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
 
     // not freed allocation
     // coarse_delete() prints LOG_WARN() in Debug mode
@@ -268,7 +269,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_fixed_memory_various) {
     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, 2);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
 
     coarse_delete(ch);
 }
@@ -295,7 +296,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_merge) {
 
     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, 1);
+    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);
@@ -303,25 +304,25 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_merge) {
     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, 2);
+    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, 3);
+    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, 2);
+    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, 0);
+    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, 1);
+    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);
@@ -329,25 +330,25 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_merge) {
     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, 2);
+    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, 3);
+    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, 2);
+    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, 0);
+    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, 1);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
 
     coarse_delete(coarse_handle);
     umfMemoryProviderDestroy(malloc_memory_provider);
@@ -432,10 +433,10 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_add_memory_fixed_null_0) {
 }
 
 TEST_P(CoarseWithMemoryStrategyTest, coarseTest_null_stats) {
-    ASSERT_EQ(coarse_get_stats(nullptr).alloc_size, 0);
-    ASSERT_EQ(coarse_get_stats(nullptr).used_size, 0);
-    ASSERT_EQ(coarse_get_stats(nullptr).num_all_blocks, 0);
-    ASSERT_EQ(coarse_get_stats(nullptr).num_free_blocks, 0);
+    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) {
@@ -460,7 +461,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_merge_negative) {
 
     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, 1);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
 
     /* test coarse_split */
 
@@ -469,7 +470,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_merge_negative) {
     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, 2);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
 
     // firstSize >= totalSize
     umf_result = coarse_split(ch, ptr, 6 * MB, 6 * MB);
@@ -495,14 +496,14 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_merge_negative) {
     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, 1);
+    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, 1);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
 
     /* test coarse_merge */
 
@@ -511,21 +512,21 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_merge_negative) {
     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, 2);
+    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, 3);
+    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, 4);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)4);
 
     // now we have 3 used blocks: (1 * MB) + (2 * MB) + (3 * MB)
 
@@ -558,7 +559,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_merge_negative) {
     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, 4);
+    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
 
@@ -574,13 +575,13 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_merge_negative) {
     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, 3);
+    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, 0);
+    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, 1);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
 
     coarse_delete(coarse_handle);
     umfMemoryProviderDestroy(malloc_memory_provider);
@@ -607,36 +608,8 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_alloc_cb_fails) {
     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, 0);
-    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, 0);
-
-    coarse_delete(ch);
-    umfMemoryProviderDestroy(malloc_memory_provider);
-}
-
-TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_free_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.free = free_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_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, 1);
+    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);
@@ -669,34 +642,34 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_cb_fails) {
     void *ptr = nullptr;
     const size_t alloc_size = 20 * MB;
 
-    ASSERT_EQ(coarse_get_stats(ch).used_size, 0);
-    ASSERT_EQ(coarse_get_stats(ch).alloc_size, 0);
-    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, 0);
+    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, 1);
+    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, 0);
+    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, 1);
+    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, 0);
+    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, 1);
+    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);
@@ -705,21 +678,21 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_cb_fails) {
 
     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, 1);
+    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, 1);
+    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, 0);
+    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, 1);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
 
     coarse_delete(coarse_handle);
     umfMemoryProviderDestroy(malloc_memory_provider);
@@ -749,7 +722,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_merge_cb_fails) {
 
     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, 1);
+    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);
@@ -757,37 +730,37 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_merge_cb_fails) {
     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, 2);
+    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, 3);
+    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, 3);
+    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, 3);
+    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, 3);
+    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, 0);
+    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, 3);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
 
     coarse_delete(coarse_handle);
 }
@@ -808,15 +781,15 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_fixed_memory_alloc_set) {
     coarse_t *ch = coarse_handle;
 
     ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
-    ASSERT_EQ(coarse_get_stats(ch).alloc_size, 0);
-    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, 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_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, 0);
-    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, 0);
+    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);
 }
@@ -837,15 +810,15 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_fixed_memory_free_set) {
     coarse_t *ch = coarse_handle;
 
     ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
-    ASSERT_EQ(coarse_get_stats(ch).alloc_size, 0);
-    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, 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_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, 0);
-    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, 0);
+    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);
 }
@@ -864,15 +837,15 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_fixed_memory_alloc_free_set) {
     coarse_t *ch = coarse_handle;
 
     ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
-    ASSERT_EQ(coarse_get_stats(ch).alloc_size, 0);
-    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, 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_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, 0);
-    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, 0);
+    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);
 }
@@ -896,31 +869,31 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_provider_alloc_not_set) {
     void *ptr;
 
     ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
-    ASSERT_EQ(coarse_get_stats(ch).alloc_size, 0);
-    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, 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_ERROR_NOT_SUPPORTED);
 
     ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
-    ASSERT_EQ(coarse_get_stats(ch).alloc_size, 0);
-    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, 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_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, 0);
-    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, 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_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, 0);
-    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, 0);
+    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);
@@ -957,7 +930,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic) {
 
     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, 1);
+    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);
@@ -965,14 +938,14 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic) {
     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, 2);
+    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, 3);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
     ASSERT_NE(p1, p2);
 
     // swap pointers to get p1 < p2
@@ -988,14 +961,14 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic) {
     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, 3);
+    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, 3);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
 
     // free all allocs
     // overall alloc size shouldn't change
@@ -1003,24 +976,24 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic) {
     // 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, 3);
+    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, 1);
+    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, 0);
+    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, 0);
+    ASSERT_EQ((uintptr_t)p2 & 127, 0ULL);
 
     umf_result = coarse_free(ch, p1, 1 * MB - 4);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
@@ -1034,7 +1007,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic) {
     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, 1);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
 
     // free all memory
     umf_result = coarse_free(ch, p1, init_buffer_size);
@@ -1045,7 +1018,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic) {
     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, 2);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
 
     // alloc additional 2 MB
     // the non-used block should be used
@@ -1054,7 +1027,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic) {
     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, 3);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
     ASSERT_NE(p1, p2);
 
     // make sure that p1 < p2
@@ -1069,12 +1042,12 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic) {
     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, 1);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
 
     // alloc 10x 2 MB - this should occupy all allocated memory
-    constexpr int allocs_size = 10;
+    constexpr size_t allocs_size = 10;
     void *allocs[allocs_size] = {0};
-    for (int i = 0; i < allocs_size; i++) {
+    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);
@@ -1086,12 +1059,12 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic) {
     ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, allocs_size);
 
     // free all memory
-    for (int i = 0; i < allocs_size; i++) {
+    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, 1);
+    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);
 
@@ -1129,7 +1102,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_simple1) {
 
     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, 1);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
 
     // test 1
 
@@ -1204,7 +1177,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_simple2) {
 
     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, 1);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
 
     // test
     double sizes[] = {2, 4, 0.5, 1, 8, 0.25};
@@ -1249,10 +1222,10 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_alignment_provider) {
 
     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, 1);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
 
     const int niter = 10;
-    const int size = 1 * MB;
+    const size_t size = 1 * MB;
     void *ptr[niter] = {0};
 
     for (int i = 0; i < niter; i++) {
@@ -1263,7 +1236,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_alignment_provider) {
 
     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, niter + 1);
+    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);
@@ -1273,7 +1246,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_alignment_provider) {
 
     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, niter + 1);
+    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);
@@ -1289,8 +1262,8 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_alignment_provider) {
         ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     }
 
-    ASSERT_EQ(coarse_get_stats(ch).used_size, 0);
-    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, 1);
+    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);
@@ -1318,10 +1291,10 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_alignment_fixed_memory) {
 
     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, 1);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
 
     const int niter = 10;
-    const int size = 1 * MB;
+    const size_t size = 1 * MB;
     void *ptr[niter] = {0};
 
     for (int i = 0; i < niter; i++) {
@@ -1332,7 +1305,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_alignment_fixed_memory) {
 
     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, niter + 1);
+    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);
@@ -1342,7 +1315,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_alignment_fixed_memory) {
 
     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, niter + 1);
+    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);
@@ -1358,8 +1331,8 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_alignment_fixed_memory) {
         ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     }
 
-    ASSERT_EQ(coarse_get_stats(ch).used_size, 0);
-    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, 1);
+    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);
 }
@@ -1396,7 +1369,7 @@ TEST_P(CoarseWithMemoryStrategyTest,
 
     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, 1);
+    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);
@@ -1404,7 +1377,7 @@ TEST_P(CoarseWithMemoryStrategyTest,
 
     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, 1);
+    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 bf116a6779..879d392868 100644
--- a/test/common/ipc_common.c
+++ b/test/common/ipc_common.c
@@ -5,13 +5,21 @@
  * 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 <stdio.h>
-#include <stdlib.h>
-#include <string.h>
 #include <sys/prctl.h>
 #include <sys/socket.h>
 #include <unistd.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 #include "ipc_common.h"
 
@@ -53,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
@@ -101,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;
@@ -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,35 +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 memory provider failed\n");
-        return -1;
+        goto err_end;
     }
 
     umf_memory_pool_handle_t pool;
@@ -417,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;
@@ -455,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;
     }
@@ -508,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);
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 558b9d665a..30abd08cad 100644
--- a/test/common/pool.hpp
+++ b/test/common/pool.hpp
@@ -25,11 +25,43 @@
 #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);
@@ -83,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);
@@ -97,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
@@ -133,19 +185,36 @@ 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 =
diff --git a/test/common/pool_null.c b/test/common/pool_null.c
index 40d6626797..ccabfee562 100644
--- a/test/common/pool_null.c
+++ b/test/common/pool_null.c
@@ -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,6 +70,12 @@ 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_POOL_OPS_VERSION_CURRENT,
     .initialize = nullInitialize,
@@ -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 9a9e010193..c05a16d325 100644
--- a/test/common/pool_trace.c
+++ b/test/common/pool_trace.c
@@ -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,6 +93,20 @@ 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_POOL_OPS_VERSION_CURRENT,
     .initialize = traceInitialize,
@@ -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 38fe7336ec..947392559c 100644
--- a/test/common/provider.hpp
+++ b/test/common/provider.hpp
@@ -18,6 +18,36 @@
 #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 {
 
 umf_memory_provider_handle_t
@@ -36,64 +66,93 @@ auto wrapProviderUnique(umf_memory_provider_handle_t hProvider) {
 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;
 
@@ -124,7 +183,10 @@ 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 =
@@ -133,7 +195,7 @@ umf_memory_provider_ops_t BA_GLOBAL_PROVIDER_OPS =
 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;
     }
@@ -149,10 +211,13 @@ 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 =
+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 b4e54f9764..2ce8c78ddb 100644
--- a/test/common/provider_null.c
+++ b/test/common/provider_null.c
@@ -5,23 +5,37 @@
 #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,6 +144,24 @@ 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_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = nullInitialize,
@@ -139,13 +172,15 @@ umf_memory_provider_ops_t UMF_NULL_PROVIDER_OPS = {
     .get_recommended_page_size = nullGetRecommendedPageSize,
     .get_min_page_size = nullGetPageSize,
     .get_name = nullName,
-    .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 20f44e8683..c780197c95 100644
--- a/test/common/provider_trace.c
+++ b/test/common/provider_trace.c
@@ -5,11 +5,13 @@
 #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) {
@@ -200,13 +212,15 @@ umf_memory_provider_ops_t UMF_TRACE_PROVIDER_OPS = {
     .get_recommended_page_size = traceGetRecommendedPageSize,
     .get_min_page_size = traceGetPageSize,
     .get_name = traceName,
-    .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 d69ca35353..997ff77b2c 100644
--- a/test/common/test_helpers.c
+++ b/test/common/test_helpers.c
@@ -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
index 5d4f9c62bd..52c8febadd 100644
--- a/test/ctl/config.txt
+++ b/test/ctl/config.txt
@@ -1 +1,3 @@
-debug.heap.alloc_pattern=321
\ No newline at end of file
+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
index 711cb5e179..ddff10eea6 100644
--- a/test/ctl/ctl_debug.c
+++ b/test/ctl/ctl_debug.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,90 +11,151 @@
  * 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 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; }
+struct ctl *get_debug_ctl(void) { return &ctl_debug; }
 
 /*
  * CTL_WRITE_HANDLER(alloc_pattern) -- sets the alloc_pattern field in heap
  */
-static int CTL_WRITE_HANDLER(alloc_pattern)(void *ctx,
-                                            enum ctl_query_source source,
-                                            void *arg,
-                                            struct ctl_index_utlist *indexes) {
+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)source, (void)indexes, (void)ctx, (void)size;
 
     int arg_in = *(int *)arg;
     alloc_pattern = arg_in;
-    return 0;
+    return UMF_RESULT_SUCCESS;
 }
 
 /*
  * CTL_READ_HANDLER(alloc_pattern) -- returns alloc_pattern heap field
  */
-static int CTL_READ_HANDLER(alloc_pattern)(void *ctx,
-                                           enum ctl_query_source source,
-                                           void *arg,
-                                           struct ctl_index_utlist *indexes) {
+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)source, (void)indexes, (void)ctx, (void)size;
 
     int *arg_out = arg;
     *arg_out = alloc_pattern;
-    return 0;
+    return UMF_RESULT_SUCCESS;
 }
 
-static int CTL_WRITE_HANDLER(enable_logging)(void *ctx,
-                                             enum ctl_query_source source,
-                                             void *arg,
-                                             struct ctl_index_utlist *indexes) {
+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)source, (void)indexes, (void)ctx, (void)size;
 
     int arg_in = *(int *)arg;
     enable_logging = arg_in;
-    return 0;
+    return UMF_RESULT_SUCCESS;
 }
 
-static int CTL_READ_HANDLER(enable_logging)(void *ctx,
-                                            enum ctl_query_source source,
-                                            void *arg,
-                                            struct ctl_index_utlist *indexes) {
+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)source, (void)indexes, (void)ctx, (void)size;
 
     int *arg_out = arg;
     *arg_out = enable_logging;
-    return 0;
+    return UMF_RESULT_SUCCESS;
 }
 
-static int CTL_WRITE_HANDLER(log_level)(void *ctx, enum ctl_query_source source,
-                                        void *arg,
-                                        struct ctl_index_utlist *indexes) {
+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)source, (void)indexes, (void)ctx, (void)size;
 
     int arg_in = *(int *)arg;
     log_level = arg_in;
-    return 0;
+    return UMF_RESULT_SUCCESS;
 }
 
-static int CTL_READ_HANDLER(log_level)(void *ctx, enum ctl_query_source source,
-                                       void *arg,
-                                       struct ctl_index_utlist *indexes) {
+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)source, (void)indexes, (void)ctx, (void)size;
 
     int *arg_out = arg;
     *arg_out = log_level;
-    return 0;
+    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;
@@ -102,16 +163,21 @@ 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;
 
-static const struct ctl_node CTL_NODE(heap)[] = {CTL_LEAF_RW(alloc_pattern),
-                                                 CTL_LEAF_RW(enable_logging),
-                                                 CTL_LEAF_RW(log_level),
-
-                                                 CTL_NODE_END};
+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 struct ctl_node CTL_NODE(debug)[] = {CTL_CHILD(heap),
+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};
 
-                                                  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
@@ -119,8 +185,6 @@ static const struct ctl_node CTL_NODE(debug)[] = {CTL_CHILD(heap),
 void debug_ctl_register(struct ctl *ctl) { CTL_REGISTER_MODULE(ctl, debug); }
 
 void initialize_debug_ctl(void) {
-    ctl_debug = ctl_new();
-    debug_ctl_register(ctl_debug);
+    debug_ctl_register(&ctl_debug);
+    ctl_init(malloc, free);
 }
-
-void deinitialize_debug_ctl(void) { ctl_delete(ctl_debug); }
diff --git a/test/ctl/ctl_debug.h b/test/ctl/ctl_debug.h
index 9dd8bade5b..1d928c8be6 100644
--- a/test/ctl/ctl_debug.h
+++ b/test/ctl/ctl_debug.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
@@ -8,13 +8,13 @@
  */
 
 /*
- * ctl_debug.h -- definitions for CTL test
+ * ctl_debug.h -- definitions for CTL tests
  */
 
-#ifndef UMF_CTL_DEBUG_H
-#define UMF_CTL_DEBUG_H 1
+#ifndef UMF_TEST_CTL_DEBUG_H
+#define UMF_TEST_CTL_DEBUG_H 1
 
-#include "../src/ctl/ctl.h"
+#include "ctl/ctl_internal.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -29,4 +29,4 @@ void deinitialize_debug_ctl(void);
 }
 #endif
 
-#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/ctl/test.cpp b/test/ctl/test.cpp
deleted file mode 100644
index c35759c673..0000000000
--- a/test/ctl/test.cpp
+++ /dev/null
@@ -1,93 +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 "../common/base.hpp"
-#include "ctl/ctl.h"
-#include "ctl/ctl_debug.h"
-
-using namespace umf_test;
-
-TEST_F(test, ctl_debug_read_from_string) {
-    initialize_debug_ctl();
-    auto ctl_handler = get_debug_ctl();
-    ctl_load_config_from_string(ctl_handler, NULL,
-                                "debug.heap.alloc_pattern=1");
-
-    int value = 0;
-    ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
-              "debug.heap.alloc_pattern", CTL_QUERY_READ, &value);
-    ASSERT_EQ(value, 1);
-
-    // Test setting alloc_pattern to 2
-    ctl_load_config_from_string(ctl_handler, NULL,
-                                "debug.heap.alloc_pattern=2");
-    ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
-              "debug.heap.alloc_pattern", CTL_QUERY_READ, &value);
-    ASSERT_EQ(value, 2);
-
-    // Test setting alloc_pattern to 0
-    ctl_load_config_from_string(ctl_handler, NULL,
-                                "debug.heap.alloc_pattern=0");
-    ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
-              "debug.heap.alloc_pattern", CTL_QUERY_READ, &value);
-    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),
-              0);
-
-    // Negative test: invalid path
-    ASSERT_NE(ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
-                        "invalid.path.alloc_pattern", CTL_QUERY_READ, &value),
-              0);
-
-    debug_ctl_register(ctl_handler);
-    deinitialize_debug_ctl();
-}
-
-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) {
-#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"), 0);
-
-    int value = 0;
-    ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
-              "debug.heap.alloc_pattern", CTL_QUERY_READ, &value);
-    ASSERT_EQ(value, 321);
-
-    value = 0;
-    ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC, "debug.heap.log_level",
-              CTL_QUERY_READ, &value);
-    ASSERT_EQ(value, 5);
-
-    value = 0;
-    ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
-              "debug.heap.enable_logging", CTL_QUERY_READ, &value);
-    ASSERT_EQ(value, 1);
-
-    debug_ctl_register(ctl_handler);
-    deinitialize_debug_ctl();
-#endif
-}
diff --git a/test/disjoint_pool_file_prov.cpp b/test/disjoint_pool_file_prov.cpp
index 58e15f5714..817a0c1088 100644
--- a/test/disjoint_pool_file_prov.cpp
+++ b/test/disjoint_pool_file_prov.cpp
@@ -37,7 +37,13 @@ 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));
+                      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;
@@ -49,7 +55,7 @@ TEST_P(FileWithMemoryStrategyTest, disjointFileMallocPool_simple1) {
     ASSERT_NE(malloc_memory_provider, nullptr);
 
     umf_file_memory_provider_params_handle_t file_params = nullptr;
-    umf_result = umfFileMemoryProviderParamsCreate(&file_params, FILE_PATH);
+    umf_result = umfFileMemoryProviderParamsCreate(FILE_PATH, &file_params);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_NE(file_params, nullptr);
 
@@ -129,9 +135,12 @@ TEST_P(FileWithMemoryStrategyTest, disjointFileMallocPool_simple1) {
         }
     }
 
-    umfPoolDestroy(pool);
-    umfMemoryProviderDestroy(file_memory_provider);
-    umfMemoryProviderDestroy(malloc_memory_provider);
+    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) {
@@ -144,7 +153,7 @@ TEST_P(FileWithMemoryStrategyTest, disjointFileMallocPool_simple2) {
     ASSERT_NE(malloc_memory_provider, nullptr);
 
     umf_file_memory_provider_params_handle_t file_params = nullptr;
-    umf_result = umfFileMemoryProviderParamsCreate(&file_params, FILE_PATH);
+    umf_result = umfFileMemoryProviderParamsCreate(FILE_PATH, &file_params);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_NE(file_params, nullptr);
 
@@ -202,9 +211,12 @@ TEST_P(FileWithMemoryStrategyTest, disjointFileMallocPool_simple2) {
         }
     }
 
-    umfPoolDestroy(pool);
-    umfMemoryProviderDestroy(file_memory_provider);
-    umfMemoryProviderDestroy(malloc_memory_provider);
+    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 {
@@ -232,7 +244,7 @@ TEST_P(FileWithMemoryStrategyTest, disjointFileMMapPool_random) {
     const unsigned char alloc_check_val = 11;
 
     umf_file_memory_provider_params_handle_t file_params = nullptr;
-    umf_result = umfFileMemoryProviderParamsCreate(&file_params, FILE_PATH);
+    umf_result = umfFileMemoryProviderParamsCreate(FILE_PATH, &file_params);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_NE(file_params, nullptr);
 
@@ -358,6 +370,8 @@ TEST_P(FileWithMemoryStrategyTest, disjointFileMMapPool_random) {
         allocs.erase(allocs.begin());
     }
 
-    umfPoolDestroy(pool);
-    umfMemoryProviderDestroy(file_memory_provider);
+    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 c0642dd760..c9496f863d 100644
--- a/test/ipcAPI.cpp
+++ b/test/ipcAPI.cpp
@@ -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;
@@ -117,4 +128,5 @@ INSTANTIATE_TEST_SUITE_P(umfIpcTestSuite, umfIpcTest,
                          ::testing::Values(ipcTestParams{
                              umfProxyPoolOps(), nullptr, nullptr,
                              &IPC_MOCK_PROVIDER_OPS, nullptr, nullptr,
-                             &hostMemoryAccessor}));
+                             &hostMemoryAccessor}),
+                         ipcTestParamsNameGen);
diff --git a/test/ipcFixtures.hpp b/test/ipcFixtures.hpp
index cf31ff7584..104ca3c26d 100644
--- a/test/ipcFixtures.hpp
+++ b/test/ipcFixtures.hpp
@@ -5,21 +5,21 @@
 #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 <algorithm>
-#include <cstring>
-#include <numeric>
-#include <random>
-#include <tuple>
+#include "base.hpp"
+#include "multithread_helpers.hpp"
+#include "pool.hpp"
+#include "test_helpers.h"
 
 class MemoryAccessor {
   public:
@@ -27,6 +27,7 @@ class MemoryAccessor {
     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 {
@@ -47,6 +48,8 @@ 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)();
@@ -60,11 +63,34 @@ typedef umf_result_t (*pfnProviderParamsDestroy)(void *);
 // provider_ops, pfnProviderParamsCreate, pfnProviderParamsDestroy,
 // memoryAccessor
 using ipcTestParams =
-    std::tuple<umf_memory_pool_ops_t *, pfnPoolParamsCreate,
-               pfnPoolParamsDestroy, umf_memory_provider_ops_t *,
+    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() {}
@@ -166,11 +192,11 @@ struct umfIpcTest : umf_test::test,
     stats_type stat;
     MemoryAccessor *memAccessor = nullptr;
 
-    umf_memory_pool_ops_t *poolOps = nullptr;
+    const umf_memory_pool_ops_t *poolOps = nullptr;
     pfnPoolParamsCreate poolParamsCreate = nullptr;
     pfnPoolParamsDestroy poolParamsDestroy = nullptr;
 
-    umf_memory_provider_ops_t *providerOps = nullptr;
+    const umf_memory_provider_ops_t *providerOps = nullptr;
     pfnProviderParamsCreate providerParamsCreate = nullptr;
     pfnProviderParamsDestroy providerParamsDestroy = nullptr;
     size_t openedIpcCacheSize = 0;
@@ -437,7 +463,7 @@ TEST_P(umfIpcTest, GetIPCHandleSize) {
 
     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) {
@@ -547,9 +573,9 @@ TEST_P(umfIpcTest, BasicFlow) {
     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);
 }
 
@@ -673,12 +699,35 @@ TEST_P(umfIpcTest, openInTwoIpcHandlers) {
 
     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, PutIPCHandleAfterFree) {
+    constexpr size_t SIZE = 100;
+    umf_test::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
+
+    void *ptr = umfPoolMalloc(pool.get(), SIZE);
+    EXPECT_NE(ptr, nullptr);
+
+    umf_ipc_handle_t ipcHandle = nullptr;
+    size_t handleSize = 0;
+    umf_result_t ret = umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfPoolFree(pool.get(), ptr);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfPutIPCHandle(ipcHandle);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    pool.reset(nullptr);
+    EXPECT_EQ(stat.putCount, stat.getCount);
+}
+
 TEST_P(umfIpcTest, ConcurrentGetConcurrentPutHandles) {
     concurrentGetConcurrentPutHandles(false);
 }
@@ -721,6 +770,7 @@ TEST_P(umfIpcTest, ConcurrentDestroyIpcHandlers) {
 
     for (size_t i = 0; i < NUM_POOLS; ++i) {
         consumerPools.push_back(makePool());
+        ASSERT_NE(consumerPools[i].get(), nullptr);
     }
 
     for (size_t i = 0; i < NUM_ALLOCS; ++i) {
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_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_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/malloc_compliance_tests.cpp b/test/malloc_compliance_tests.cpp
index b91bde1f6d..b828281987 100644
--- a/test/malloc_compliance_tests.cpp
+++ b/test/malloc_compliance_tests.cpp
@@ -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 e8071a2d81..f2cfb61bb7 100644
--- a/test/memoryPoolAPI.cpp
+++ b/test/memoryPoolAPI.cpp
@@ -3,28 +3,35 @@
 // 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;
@@ -42,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) {
@@ -71,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) {
@@ -124,6 +140,13 @@ 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_test::poolMakeCOps<pool, void>();
 
@@ -166,13 +189,17 @@ 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);
@@ -294,6 +321,31 @@ TEST_F(tagTest, SetAndGetInvalidPool) {
     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(
@@ -303,16 +355,31 @@ INSTANTIATE_TEST_SUITE_P(
                             &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr},
         poolCreateExtParams{umfDisjointPoolOps(), defaultDisjointPoolConfig,
                             defaultDisjointPoolConfigDestroy,
-                            &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}));
+                            &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, nullptr,
-                             &BA_GLOBAL_PROVIDER_OPS, 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 /////////////////
 
@@ -349,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> {};
 
@@ -357,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());
@@ -366,7 +459,7 @@ 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;
         }
     };
@@ -396,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;
         }
 
@@ -416,9 +509,12 @@ 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_test::providerMakeCOps<memory_provider, char>();
@@ -440,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
@@ -466,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
@@ -513,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 720f11b413..5cbc8c2cac 100644
--- a/test/memoryProviderAPI.cpp
+++ b/test/memoryProviderAPI.cpp
@@ -3,18 +3,20 @@
 // 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,20 +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, 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);
@@ -104,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);
@@ -117,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);
@@ -138,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);
@@ -169,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) {
@@ -233,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);
@@ -241,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);
@@ -249,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);
@@ -257,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);
@@ -265,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);
@@ -273,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);
@@ -281,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);
@@ -326,11 +339,18 @@ 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;
         }
     };
@@ -377,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 7b9c4891d3..2cde749be2 100644
--- a/test/memspaces/mempolicy.cpp
+++ b/test/memspaces/mempolicy.cpp
@@ -81,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) {
@@ -109,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) {
@@ -134,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) {
@@ -166,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 5f39e021d0..2b42750239 100644
--- a/test/poolFixtures.hpp
+++ b/test/poolFixtures.hpp
@@ -8,10 +8,12 @@
 #include <array>
 #include <cstring>
 #include <functional>
+#include <list>
 #include <random>
 #include <string>
 #include <thread>
 
+#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>
@@ -21,17 +23,6 @@
 #include "provider.hpp"
 #include "utils/utils_sanitizers.h"
 
-typedef void *(*pfnPoolParamsCreate)();
-typedef umf_result_t (*pfnPoolParamsDestroy)(void *);
-
-typedef void *(*pfnProviderParamsCreate)();
-typedef umf_result_t (*pfnProviderParamsDestroy)(void *);
-
-using poolCreateExtParams =
-    std::tuple<umf_memory_pool_ops_t *, pfnPoolParamsCreate,
-               pfnPoolParamsDestroy, umf_memory_provider_ops_t *,
-               pfnProviderParamsCreate, pfnProviderParamsDestroy>;
-
 umf_test::pool_unique_handle_t poolCreateExtUnique(poolCreateExtParams params) {
     auto [pool_ops, poolParamsCreate, poolParamsDestroy, provider_ops,
           providerParamsCreate, providerParamsDestroy] = params;
@@ -49,6 +40,10 @@ umf_test::pool_unique_handle_t poolCreateExtUnique(poolCreateExtParams 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;
 
@@ -63,6 +58,10 @@ umf_test::pool_unique_handle_t poolCreateExtUnique(poolCreateExtParams 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);
+    }
 
     // we do not need params anymore
     if (poolParamsDestroy) {
@@ -131,6 +130,11 @@ 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);
@@ -401,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();
@@ -467,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);
     }
 
@@ -525,6 +559,9 @@ TEST_P(umfPoolTest, mallocUsableSize) {
             << "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}) {
@@ -538,7 +575,11 @@ TEST_P(umfPoolTest, mallocUsableSize) {
                 ptr = umfPoolAlignedMalloc(pool.get(), allocSize, alignment);
             }
             ASSERT_NE(ptr, nullptr);
-            size_t result = umfPoolMallocUsableSize(pool.get(), ptr);
+            size_t result = 0;
+            umf_result_t ret =
+                umfPoolMallocUsableSize(pool.get(), ptr, &result);
+
+            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
             ASSERT_TRUE(result == 0 || result >= allocSize);
 
             // Make sure we can write to this memory
@@ -573,6 +614,15 @@ TEST_P(umfPoolTest, umfPoolAlignedMalloc) {
 #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
@@ -597,8 +647,8 @@ TEST_P(umfPoolTest, pool_from_ptr_whole_size_success) {
     // 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(&params, ptr_for_pool,
-                                                    size_of_pool_from_ptr);
+    umf_result = umfFixedMemoryProviderParamsCreate(
+        ptr_for_pool, size_of_pool_from_ptr, &params);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_NE(params, nullptr);
 
@@ -654,8 +704,8 @@ TEST_P(umfPoolTest, pool_from_ptr_half_size_success) {
     // 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(&params, ptr_for_pool,
-                                                    size_of_pool_from_ptr);
+    umf_result = umfFixedMemoryProviderParamsCreate(
+        ptr_for_pool, size_of_pool_from_ptr, &params);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_NE(params, nullptr);
 
@@ -687,4 +737,120 @@ TEST_P(umfPoolTest, pool_from_ptr_half_size_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 9bdef4f131..065b457de0 100644
--- a/test/pools/disjoint_pool.cpp
+++ b/test/pools/disjoint_pool.cpp
@@ -4,6 +4,9 @@
 
 #include <memory>
 
+#include <cstdarg>
+#include <umf/base.h>
+#include <umf/memory_pool.h>
 #include <umf/pools/pool_disjoint.h>
 
 #include "pool.hpp"
@@ -12,10 +15,13 @@
 #include "provider.hpp"
 #include "provider_null.h"
 #include "provider_trace.h"
+#include "umf/memory_provider.h"
 
 using umf_test::test;
 using namespace umf_test;
 
+static void get_test_va_list(va_list *a, ...) { va_start(*a, a); }
+
 TEST_F(test, internals) {
     static umf_result_t expectedResult = UMF_RESULT_SUCCESS;
     struct memory_provider : public umf_test::provider_base_t {
@@ -33,7 +39,7 @@ TEST_F(test, internals) {
         }
 
         umf_result_t
-        get_min_page_size([[maybe_unused]] void *ptr,
+        get_min_page_size([[maybe_unused]] const void *ptr,
                           [[maybe_unused]] size_t *pageSize) noexcept {
             *pageSize = 1024;
             return UMF_RESULT_SUCCESS;
@@ -56,14 +62,20 @@ TEST_F(test, internals) {
 
     // in "internals" test we use ops interface to directly manipulate the pool
     // structure
-    umf_memory_pool_ops_t *ops = umfDisjointPoolOps();
+    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, 1024);
+    EXPECT_EQ(pool->provider_min_page_size, (size_t)1024);
 
     // check buckets sizes
     size_t expected_size = DEFAULT_DISJOINT_MIN_BUCKET_SIZE;
@@ -95,16 +107,16 @@ TEST_F(test, internals) {
     EXPECT_NE(bucket, nullptr);
 
     // check bucket stats
-    EXPECT_EQ(bucket->alloc_count, 1);
+    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, 0);
-    EXPECT_EQ(bucket->curr_slabs_in_use, 1);
+    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, 1);
+    EXPECT_EQ(bucket->available_slabs_num, (size_t)1);
     EXPECT_EQ(bucket->available_slabs->next, nullptr);
     slab_t *slab = bucket->available_slabs->val;
 
@@ -216,11 +228,14 @@ TEST_F(test, sharedLimits) {
     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(params, limits.get());
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
@@ -243,8 +258,8 @@ TEST_F(test, sharedLimits) {
     ret = umfDisjointPoolParamsDestroy(params);
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    EXPECT_EQ(0, numAllocs);
-    EXPECT_EQ(0, numFrees);
+    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++) {
@@ -253,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();
 
@@ -269,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);
@@ -327,11 +433,200 @@ TEST_F(test, disjointPoolInvalidBucketSize) {
     umfDisjointPoolParamsDestroy(params);
 }
 
+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(), defaultDisjointPoolConfig,
                              defaultDisjointPoolConfigDestroy,
-                             &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}));
+                             &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}),
+                         poolCreateExtParamsNameGen);
 
 void *memProviderParams() { return (void *)&DEFAULT_DISJOINT_CAPACITY; }
 
@@ -342,10 +637,15 @@ INSTANTIATE_TEST_SUITE_P(
                             defaultDisjointPoolConfigDestroy,
                             &MOCK_OUT_OF_MEM_PROVIDER_OPS, memProviderParams,
                             nullptr},
-        static_cast<int>(DEFAULT_DISJOINT_CAPACITY) / 2)));
+        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(), defaultDisjointPoolConfig,
                              defaultDisjointPoolConfigDestroy,
-                             &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}));
+                             &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 53d2a41b37..8af7809970 100644
--- a/test/pools/jemalloc_coarse_devdax.cpp
+++ b/test/pools/jemalloc_coarse_devdax.cpp
@@ -2,15 +2,16 @@
 // 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"
 
 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) {
+    if (path == nullptr || path[0] == '\0' || size == nullptr ||
+        size[0] == '\0') {
         return false;
     }
 
@@ -20,10 +21,14 @@ bool devDaxEnvSet() {
 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 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");
@@ -41,4 +46,5 @@ static std::vector<poolCreateExtParams> poolParamsList =
         : 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 dcd03898ee..b6f84804fe 100644
--- a/test/pools/jemalloc_coarse_file.cpp
+++ b/test/pools/jemalloc_coarse_file.cpp
@@ -2,15 +2,15 @@
 // 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"
 
 void *getFileParamsDefault() {
     umf_file_memory_provider_params_handle_t file_params = NULL;
     umf_result_t res =
-        umfFileMemoryProviderParamsCreate(&file_params, FILE_PATH);
+        umfFileMemoryProviderParamsCreate(FILE_PATH, &file_params);
     if (res != UMF_RESULT_SUCCESS) {
         throw std::runtime_error(
             "Failed to create File Memory Provider params");
@@ -28,4 +28,5 @@ INSTANTIATE_TEST_SUITE_P(jemallocCoarseFileTest, umfPoolTest,
                          ::testing::Values(poolCreateExtParams{
                              umfJemallocPoolOps(), nullptr, nullptr,
                              umfFileMemoryProviderOps(), getFileParamsDefault,
-                             destroyFileParams}));
+                             destroyFileParams}),
+                         poolCreateExtParamsNameGen);
diff --git a/test/pools/jemalloc_pool.cpp b/test/pools/jemalloc_pool.cpp
index 8112f36bf4..c87b049c1a 100644
--- a/test/pools/jemalloc_pool.cpp
+++ b/test/pools/jemalloc_pool.cpp
@@ -2,8 +2,8 @@
 // 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"
@@ -40,8 +40,8 @@ void *createFixedMemoryProviderParams() {
     }
 
     umf_fixed_memory_provider_params_handle_t params = nullptr;
-    umf_result_t res = umfFixedMemoryProviderParamsCreate(
-        &params, memory_buffer.get(), memory_size);
+    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");
@@ -55,16 +55,40 @@ umf_result_t destroyFixedMemoryProviderParams(void *params) {
         (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}));
+    ::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
@@ -119,3 +143,116 @@ TEST_F(test, metadataNotAllocatedUsingProvider) {
             [pool = pool.get()](void *ptr) { umfPoolFree(pool, ptr); });
     }
 }
+
+TEST_F(test, jemallocPoolNullParams) {
+    auto ret = umfJemallocPoolParamsSetNumArenas(NULL, 1);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(test, jemallocPoolParams) {
+    umf_jemalloc_pool_params_handle_t params = nullptr;
+    auto ret = umfJemallocPoolParamsCreate(&params);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfJemallocPoolParamsSetNumArenas(params, 1);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfJemallocPoolParamsDestroy(params);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+}
+
+TEST_F(test, jemallocPoolParamsInvalid) {
+    umf_jemalloc_pool_params_handle_t params = nullptr;
+    auto ret = umfJemallocPoolParamsCreate(&params);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfJemallocPoolParamsSetNumArenas(params, SIZE_MAX);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    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_memory_pool_handle_t pool;
+    ret = umfPoolCreate(umfJemallocPoolOps(), provider, params, 0, &pool);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umfMemoryProviderDestroy(provider);
+
+    ret = umfJemallocPoolParamsDestroy(params);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    ret = umfOsMemoryProviderParamsDestroy(provider_params);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+}
+
+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);
+}
+
+TEST_F(test, jemallocProviderDoesNotSupportSplit) {
+    umf_jemalloc_pool_params_handle_t params = nullptr;
+    umf_result_t res = umfJemallocPoolParamsCreate(&params);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+
+    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);
+
+    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);
+
+    umfMemoryProviderDestroy(ba_provider);
+    umfJemallocPoolParamsDestroy(params);
+}
+
+TEST_F(test, jemallocPoolCustomName) {
+    umf_jemalloc_pool_params_handle_t params = nullptr;
+    umf_result_t res = umfJemallocPoolParamsCreate(&params);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfJemallocPoolParamsSetName(params, "my_jemalloc");
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+
+    auto nullProvider = nullProviderCreate();
+
+    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");
+
+    umfPoolDestroy(pool);
+    umfMemoryProviderDestroy(nullProvider);
+    umfJemallocPoolParamsDestroy(params);
+}
+
+TEST(JemallocPoolOps, default_name_null_handle) {
+    const char *name = nullptr;
+    EXPECT_EQ(umfJemallocPoolOps()->get_name(nullptr, &name),
+              UMF_RESULT_SUCCESS);
+    EXPECT_STREQ(name, "jemalloc");
+}
diff --git a/test/pools/pool_base_alloc.cpp b/test/pools/pool_base_alloc.cpp
index 441ab37ec3..583b417cf6 100644
--- a/test/pools/pool_base_alloc.cpp
+++ b/test/pools/pool_base_alloc.cpp
@@ -4,15 +4,14 @@
 
 #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); }
@@ -31,8 +30,11 @@ struct base_alloc_pool : public umf_test::pool_base_t {
             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);
@@ -41,6 +43,15 @@ struct base_alloc_pool : public umf_test::pool_base_t {
     umf_result_t get_last_allocation_error() {
         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 =
@@ -49,4 +60,5 @@ umf_memory_pool_ops_t BA_POOL_OPS =
 INSTANTIATE_TEST_SUITE_P(baPool, umfPoolTest,
                          ::testing::Values(poolCreateExtParams{
                              &BA_POOL_OPS, nullptr, nullptr,
-                             &umf_test::BASE_PROVIDER_OPS, nullptr, nullptr}));
+                             &umf_test::BASE_PROVIDER_OPS, nullptr, nullptr}),
+                         poolCreateExtParamsNameGen);
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 86c5804022..83fa855279 100644
--- a/test/pools/scalable_coarse_devdax.cpp
+++ b/test/pools/scalable_coarse_devdax.cpp
@@ -2,15 +2,16 @@
 // 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"
 
 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) {
+    if (path == nullptr || path[0] == '\0' || size == nullptr ||
+        size[0] == '\0') {
         return false;
     }
 
@@ -20,10 +21,14 @@ bool devDaxEnvSet() {
 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 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");
@@ -45,4 +50,5 @@ static std::vector<poolCreateExtParams> poolParamsList =
                    : 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 a5fd5b46a6..778a47202c 100644
--- a/test/pools/scalable_coarse_file.cpp
+++ b/test/pools/scalable_coarse_file.cpp
@@ -2,15 +2,15 @@
 // 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"
 
 void *getFileParamsDefault() {
     umf_file_memory_provider_params_handle_t file_params = NULL;
     umf_result_t res =
-        umfFileMemoryProviderParamsCreate(&file_params, FILE_PATH);
+        umfFileMemoryProviderParamsCreate(FILE_PATH, &file_params);
     if (res != UMF_RESULT_SUCCESS) {
         throw std::runtime_error(
             "Failed to create File Memory Provider params");
@@ -28,4 +28,5 @@ INSTANTIATE_TEST_SUITE_P(scalableCoarseFileTest, umfPoolTest,
                          ::testing::Values(poolCreateExtParams{
                              umfScalablePoolOps(), nullptr, nullptr,
                              umfFileMemoryProviderOps(), getFileParamsDefault,
-                             destroyFileParams}));
+                             destroyFileParams}),
+                         poolCreateExtParamsNameGen);
diff --git a/test/pools/scalable_pool.cpp b/test/pools/scalable_pool.cpp
index 54c0128a40..d34e16826c 100644
--- a/test/pools/scalable_pool.cpp
+++ b/test/pools/scalable_pool.cpp
@@ -2,8 +2,8 @@
 // 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"
@@ -28,7 +28,8 @@ INSTANTIATE_TEST_SUITE_P(
     scalablePoolTest, umfPoolTest,
     ::testing::Values(poolCreateExtParams{
         umfScalablePoolOps(), nullptr, nullptr, umfOsMemoryProviderOps(),
-        createOsMemoryProviderParams, destroyOsMemoryProviderParams}));
+        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,7 +58,7 @@ 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 =
@@ -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_devdax_memory.cpp b/test/provider_devdax_memory.cpp
index 6efeef90cb..b22f4fa291 100644
--- a/test/provider_devdax_memory.cpp
+++ b/test/provider_devdax_memory.cpp
@@ -3,19 +3,22 @@
 // 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 <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"
-
-#include <umf/memory_provider.h>
-#include <umf/providers/provider_devdax_memory.h>
+#ifndef _WIN32
+#include "test_helpers_linux.h"
+#endif
 
 using umf_test::test;
 
@@ -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_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);
-}
-
 struct umfProviderTest
     : umf_test::test,
       ::testing::WithParamInterface<providerCreateExtParams> {
@@ -107,7 +94,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);
 }
@@ -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);
 
@@ -180,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");
@@ -208,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) {}
 
@@ -234,7 +225,7 @@ TEST_P(umfProviderTest, purge_force) {
     test_alloc_free_success(provider.get(), page_size, 0, PURGE_FORCE);
 }
 
-TEST_P(umfProviderTest, purge_force_unalligned_alloc) {
+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);
@@ -295,10 +286,42 @@ 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);
@@ -310,6 +333,58 @@ TEST_P(umfProviderTest, free_NULL) {
     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
 
 TEST_P(umfProviderTest, free_INVALID_POINTER_SIZE_GT_0) {
@@ -338,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);
 
@@ -357,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);
 
@@ -377,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);
@@ -394,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);
 }
@@ -402,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);
 }
@@ -411,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);
 
@@ -426,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);
 
@@ -442,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);
 
@@ -460,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);
 
@@ -478,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 47b389c95f..1db7011534 100644
--- a/test/provider_devdax_memory_ipc.cpp
+++ b/test/provider_devdax_memory_ipc.cpp
@@ -18,7 +18,8 @@ using umf_test::test;
 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) {
+    if (path == nullptr || path[0] == '\0' || size == nullptr ||
+        size[0] == '\0') {
         return false;
     }
 
@@ -28,13 +29,14 @@ bool devDaxEnvSet() {
 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) {
+    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");
@@ -77,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 bcc9d26453..c59223eb5a 100644
--- a/test/provider_file_memory.cpp
+++ b/test/provider_file_memory.cpp
@@ -2,17 +2,18 @@
 // 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 "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_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);
-}
-
 struct FileProviderParamsDefault
     : umf_test::test,
       ::testing::WithParamInterface<providerCreateExtParams> {
@@ -105,7 +90,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);
 }
@@ -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);
 
@@ -176,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");
@@ -191,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");
@@ -215,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) {}
 
@@ -360,10 +348,38 @@ 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);
@@ -375,11 +391,63 @@ TEST_P(FileProviderParamsDefault, free_NULL) {
     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);
@@ -402,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);
 }
@@ -412,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);
 }
@@ -422,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);
@@ -437,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);
@@ -473,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;
diff --git a/test/provider_file_memory_ipc.cpp b/test/provider_file_memory_ipc.cpp
index 90623a1793..fe50d8408f 100644
--- a/test/provider_file_memory_ipc.cpp
+++ b/test/provider_file_memory_ipc.cpp
@@ -20,7 +20,7 @@ using umf_test::test;
 void *createFileParamsShared() {
     umf_file_memory_provider_params_handle_t file_params = NULL;
     umf_result_t res =
-        umfFileMemoryProviderParamsCreate(&file_params, FILE_PATH);
+        umfFileMemoryProviderParamsCreate(FILE_PATH, &file_params);
     if (res != UMF_RESULT_SUCCESS) {
         throw std::runtime_error(
             "Failed to create File Memory Provider params");
@@ -45,7 +45,7 @@ umf_result_t destroyFileParamsShared(void *params) {
 void *createFileParamsFSDAX() {
     umf_file_memory_provider_params_handle_t file_params = NULL;
     umf_result_t res = umfFileMemoryProviderParamsCreate(
-        &file_params, getenv("UMF_TESTS_FSDAX_PATH"));
+        getenv("UMF_TESTS_FSDAX_PATH"), &file_params);
     if (res != UMF_RESULT_SUCCESS) {
         //test will be skipped.
         return nullptr;
@@ -67,6 +67,32 @@ umf_result_t destroyFileParamsFSDAX(void *params) {
         (umf_file_memory_provider_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
+
 HostMemoryAccessor hostAccessor;
 
 static std::vector<ipcTestParams> ipcManyPoolsTestParamsList = {
@@ -74,8 +100,9 @@ static std::vector<ipcTestParams> ipcManyPoolsTestParamsList = {
 //    {umfProxyPoolOps(), nullptr, umfFileMemoryProviderOps(),
 //     file_params_shared.get(), &hostAccessor},
 #ifdef UMF_POOL_JEMALLOC_ENABLED
-    {umfJemallocPoolOps(), nullptr, nullptr, umfFileMemoryProviderOps(),
-     createFileParamsShared, destroyFileParamsShared, &hostAccessor},
+    {umfJemallocPoolOps(), createJemallocParams, destroyJemallocParams,
+     umfFileMemoryProviderOps(), createFileParamsShared,
+     destroyFileParamsShared, &hostAccessor},
 #endif
 #ifdef UMF_POOL_SCALABLE_ENABLED
     {umfScalablePoolOps(), nullptr, nullptr, umfFileMemoryProviderOps(),
@@ -87,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;
     }
@@ -97,8 +124,9 @@ static std::vector<ipcTestParams> getIpcFsDaxTestParamsList(void) {
 //        {umfProxyPoolOps(), nullptr, umfFileMemoryProviderOps(),
 //         file_params_fsdax.get(), &hostAccessor},
 #ifdef UMF_POOL_JEMALLOC_ENABLED
-        {umfJemallocPoolOps(), nullptr, nullptr, umfFileMemoryProviderOps(),
-         createFileParamsFSDAX, destroyFileParamsFSDAX, &hostAccessor},
+        {umfJemallocPoolOps(), createJemallocParams, destroyJemallocParams,
+         umfFileMemoryProviderOps(), createFileParamsFSDAX,
+         destroyFileParamsFSDAX, &hostAccessor},
 #endif
 #ifdef UMF_POOL_SCALABLE_ENABLED
         {umfScalablePoolOps(), nullptr, nullptr, umfFileMemoryProviderOps(),
@@ -112,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
index dac651435a..a72deda63a 100644
--- a/test/provider_fixed_memory.cpp
+++ b/test/provider_fixed_memory.cpp
@@ -2,18 +2,19 @@
 // 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/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
 
-#include <umf/memory_provider.h>
-#include <umf/pools/pool_proxy.h>
-#include <umf/providers/provider_fixed_memory.h>
-
 using umf_test::test;
 
 #define FIXED_BUFFER_SIZE (10 * utils_get_page_size())
@@ -38,22 +39,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_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);
-}
-
 struct FixedProviderTest
     : umf_test::test,
       ::testing::WithParamInterface<providerCreateExtParams> {
@@ -68,7 +53,7 @@ struct FixedProviderTest
         // Create provider parameters
         umf_fixed_memory_provider_params_handle_t params = nullptr;
         umf_result_t res = umfFixedMemoryProviderParamsCreate(
-            &params, memory_buffer, memory_size);
+            memory_buffer, memory_size, &params);
         ASSERT_EQ(res, UMF_RESULT_SUCCESS);
         ASSERT_NE(params, nullptr);
 
@@ -118,7 +103,9 @@ struct FixedProviderTest
         const char *message;
         int32_t error;
         auto provider = this->provider.get();
-        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);
     }
@@ -151,7 +138,8 @@ struct FixedProviderTest
 
 INSTANTIATE_TEST_SUITE_P(fixedProviderTest, FixedProviderTest,
                          ::testing::Values(providerCreateExtParams{
-                             umfFixedMemoryProviderOps(), nullptr}));
+                             umfFixedMemoryProviderOps(), nullptr}),
+                         providerCreateExtParamsNameGen);
 
 TEST_P(FixedProviderTest, create_destroy) {
     // Creation and destruction are handled in SetUp and TearDown
@@ -239,6 +227,11 @@ TEST_P(FixedProviderTest, alloc_page64_align_one_half_pages_WRONG_ALIGNMENT_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) {
@@ -264,10 +257,46 @@ TEST_P(FixedProviderTest, get_recommended_page_size) {
 }
 
 TEST_P(FixedProviderTest, 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, "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);
@@ -301,13 +330,65 @@ TEST_P(FixedProviderTest, purge_force_INVALID_POINTER) {
     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(nullptr, memory_buffer, memory_size);
+        umfFixedMemoryProviderParamsCreate(memory_buffer, memory_size, nullptr);
     ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     umf_result = umfFixedMemoryProviderParamsDestroy(nullptr);
@@ -318,7 +399,7 @@ 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(&wrong_params, nullptr, memory_size);
+        umfFixedMemoryProviderParamsCreate(nullptr, memory_size, &wrong_params);
     ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
     ASSERT_EQ(wrong_params, nullptr);
 }
@@ -328,16 +409,110 @@ TEST_F(test, create_with_zero_size) {
     char memory_buffer[memory_size];
     umf_fixed_memory_provider_params_handle_t wrong_params = nullptr;
     umf_result_t umf_result =
-        umfFixedMemoryProviderParamsCreate(&wrong_params, memory_buffer, 0);
+        umfFixedMemoryProviderParamsCreate(memory_buffer, 0, &wrong_params);
     ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
     ASSERT_EQ(wrong_params, nullptr);
 }
 
-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);
+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;
@@ -413,8 +588,8 @@ TEST_P(FixedProviderTest, pool_from_ptr_whole_size_success) {
     // 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(&params, ptr_for_pool,
-                                                    size_of_pool_from_ptr);
+    umf_result = umfFixedMemoryProviderParamsCreate(
+        ptr_for_pool, size_of_pool_from_ptr, &params);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_NE(params, nullptr);
 
@@ -437,14 +612,16 @@ TEST_P(FixedProviderTest, pool_from_ptr_whole_size_success) {
     umf_result = umfPoolFree(poolFromPtr, ptr);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-    umfPoolDestroy(poolFromPtr);
+    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);
 
-    umfPoolDestroy(proxyFixedPool);
+    umf_result = umfPoolDestroy(proxyFixedPool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 }
 
 TEST_P(FixedProviderTest, pool_from_ptr_half_size_success) {
@@ -466,8 +643,8 @@ TEST_P(FixedProviderTest, pool_from_ptr_half_size_success) {
     // 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(&params, ptr_for_pool,
-                                                    size_of_pool_from_ptr);
+    umf_result = umfFixedMemoryProviderParamsCreate(
+        ptr_for_pool, size_of_pool_from_ptr, &params);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_NE(params, nullptr);
 
@@ -490,12 +667,14 @@ TEST_P(FixedProviderTest, pool_from_ptr_half_size_success) {
     umf_result = umfPoolFree(poolFromPtr, ptr);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-    umfPoolDestroy(poolFromPtr);
+    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);
 
-    umfPoolDestroy(proxyFixedPool);
+    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 f3552b9236..49b023a741 100644
--- a/test/provider_os_memory.cpp
+++ b/test/provider_os_memory.cpp
@@ -2,12 +2,7 @@
 // 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 "ipcFixtures.hpp"
-#include "test_helpers.h"
-#include "utils/cpp_helpers.hpp"
-
+#include <umf/experimental/ctl.h>
 #include <umf/memory_provider.h>
 #include <umf/pools/pool_disjoint.h>
 #include <umf/providers/provider_os_memory.h>
@@ -15,6 +10,12 @@
 #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)
@@ -44,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_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);
-}
-
 struct umfProviderTest
     : umf_test::test,
       ::testing::WithParamInterface<providerCreateExtParams> {
@@ -108,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);
 }
@@ -215,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);
 
@@ -244,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) {}
 
@@ -325,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);
@@ -403,6 +419,58 @@ TEST_P(umfProviderTest, close_ipc_handle_wrong_visibility) {
     ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
 
+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);
+}
+
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest);
 
 void *createOsMemoryProviderParamsShared() {
@@ -461,16 +529,43 @@ umf_result_t destroyDisjointPoolParams(void *params) {
         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 = {
     {umfDisjointPoolOps(), createDisjointPoolParams, destroyDisjointPoolParams,
      umfOsMemoryProviderOps(), createOsMemoryProviderParamsShared,
      destroyOsMemoryProviderParamsShared, &hostAccessor},
 #ifdef UMF_POOL_JEMALLOC_ENABLED
-    {umfJemallocPoolOps(), nullptr, nullptr, umfOsMemoryProviderOps(),
-     createOsMemoryProviderParamsShared, destroyOsMemoryProviderParamsShared,
-     &hostAccessor},
+    {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 cfc58f2f06..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;
 
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
index 55acc452cf..52d5eeb8fd 100644
--- a/test/provider_tracking.cpp
+++ b/test/provider_tracking.cpp
@@ -2,39 +2,23 @@
 // 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/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
 
-#include <umf/memory_provider.h>
-#include <umf/pools/pool_proxy.h>
-#include <umf/providers/provider_fixed_memory.h>
-
 using umf_test::test;
 
 #define FIXED_BUFFER_SIZE (512 * utils_get_page_size())
 #define INVALID_PTR ((void *)0x01)
 
-using providerCreateExtParams = std::tuple<umf_memory_provider_ops_t *, void *>;
-
-static 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);
-}
-
 struct TrackingProviderTest
     : umf_test::test,
       ::testing::WithParamInterface<providerCreateExtParams> {
@@ -49,7 +33,7 @@ struct TrackingProviderTest
         // Create provider parameters
         umf_fixed_memory_provider_params_handle_t params = nullptr;
         umf_result_t res = umfFixedMemoryProviderParamsCreate(
-            &params, memory_buffer, memory_size);
+            memory_buffer, memory_size, &params);
         ASSERT_EQ(res, UMF_RESULT_SUCCESS);
         ASSERT_NE(params, nullptr);
 
@@ -95,7 +79,7 @@ createPoolFromAllocation(void *ptr0, size_t size1,
 
     // Create provider parameters
     umf_fixed_memory_provider_params_handle_t params = nullptr;
-    umf_result = umfFixedMemoryProviderParamsCreate(&params, ptr0, size1);
+    umf_result = umfFixedMemoryProviderParamsCreate(ptr0, size1, &params);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_NE(params, nullptr);
 
@@ -120,7 +104,8 @@ createPoolFromAllocation(void *ptr0, size_t size1,
 
 INSTANTIATE_TEST_SUITE_P(trackingProviderTest, TrackingProviderTest,
                          ::testing::Values(providerCreateExtParams{
-                             umfFixedMemoryProviderOps(), nullptr}));
+                             umfFixedMemoryProviderOps(), nullptr}),
+                         providerCreateExtParamsNameGen);
 
 TEST_P(TrackingProviderTest, create_destroy) {
     // Creation and destruction are handled in SetUp and TearDown
@@ -151,8 +136,10 @@ TEST_P(TrackingProviderTest, whole_size_success) {
     umf_result = umfPoolFree(pool1, ptr1);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-    umfPoolDestroy(pool1);
-    umfMemoryProviderDestroy(provider1);
+    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);
@@ -183,8 +170,10 @@ TEST_P(TrackingProviderTest, half_size_success) {
     umf_result = umfPoolFree(pool1, ptr1);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-    umfPoolDestroy(pool1);
-    umfMemoryProviderDestroy(provider1);
+    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);
@@ -212,8 +201,10 @@ TEST_P(TrackingProviderTest, failure_exceeding_size) {
     ptr1 = umfPoolMalloc(pool1, size1);
     ASSERT_EQ(ptr1, nullptr);
 
-    umfPoolDestroy(pool1);
-    umfMemoryProviderDestroy(provider1);
+    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);
@@ -252,8 +243,10 @@ TEST_P(TrackingProviderTest, success_max_levels) {
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
     for (int i = TEST_LEVEL_SUCCESS - 1; i >= 0; i--) {
-        umfPoolDestroy(pools[i + 1]);
-        umfMemoryProviderDestroy(providers[i + 1]);
+        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]);
@@ -287,8 +280,10 @@ TEST_P(TrackingProviderTest, failure_exceeding_levels) {
     ASSERT_EQ(ptr[f], nullptr);
 
     for (int i = TEST_LEVEL_FAILURE - 1; i >= 0; i--) {
-        umfPoolDestroy(pools[i + 1]);
-        umfMemoryProviderDestroy(providers[i + 1]);
+        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]);
@@ -326,8 +321,10 @@ TEST_P(TrackingProviderTest, reverted_free_half_size) {
     umf_result = umfPoolFree(pool1, ptr1);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-    umfPoolDestroy(pool1);
-    umfMemoryProviderDestroy(provider1);
+    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.
@@ -365,8 +362,10 @@ TEST_P(TrackingProviderTest, reverted_free_the_same_size) {
     umf_result = umfPoolFree(pool1, ptr1);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-    umfPoolDestroy(pool1);
-    umfMemoryProviderDestroy(provider1);
+    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.
diff --git a/test/provider_tracking_fixture_tests.cpp b/test/provider_tracking_fixture_tests.cpp
index d81d4f8b1d..60ff9a1761 100644
--- a/test/provider_tracking_fixture_tests.cpp
+++ b/test/provider_tracking_fixture_tests.cpp
@@ -21,22 +21,32 @@
 
 struct provider_from_pool : public umf_test::provider_base_t {
     umf_memory_pool_handle_t pool;
-    umf_result_t initialize(umf_memory_pool_handle_t _pool) noexcept {
+
+    provider_from_pool() : pool(nullptr) {}
+
+    umf_result_t initialize(const umf_memory_pool_t *_pool) noexcept {
         if (!_pool) {
             return UMF_RESULT_ERROR_INVALID_ARGUMENT;
         }
-        pool = _pool;
+        // 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);
     }
-    const char *get_name() noexcept { return "provider_from_pool"; }
+
+    umf_result_t get_name(const char **name) noexcept {
+        *name = "provider_from_pool";
+        return UMF_RESULT_SUCCESS;
+    }
 
     virtual ~provider_from_pool() {
         if (pool) {
@@ -52,7 +62,7 @@ umf_memory_provider_ops_t PROVIDER_FROM_POOL_OPS =
 static void *providerFromPoolParamsCreate(void) {
     umf_file_memory_provider_params_handle_t paramsFile = NULL;
     umf_result_t umf_result =
-        umfFileMemoryProviderParamsCreate(&paramsFile, FILE_PATH);
+        umfFileMemoryProviderParamsCreate(FILE_PATH, &paramsFile);
     EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
     EXPECT_NE(paramsFile, nullptr);
 
@@ -82,10 +92,12 @@ INSTANTIATE_TEST_SUITE_P(TrackingProviderPoolTest, umfPoolTest,
                          ::testing::Values(poolCreateExtParams{
                              umfProxyPoolOps(), nullptr, nullptr,
                              &PROVIDER_FROM_POOL_OPS,
-                             providerFromPoolParamsCreate, nullptr}));
+                             providerFromPoolParamsCreate, nullptr}),
+                         poolCreateExtParamsNameGen);
 
 INSTANTIATE_TEST_SUITE_P(TrackingProviderMultiPoolTest, umfMultiPoolTest,
                          ::testing::Values(poolCreateExtParams{
                              umfProxyPoolOps(), nullptr, nullptr,
                              &PROVIDER_FROM_POOL_OPS,
-                             providerFromPoolParamsCreate, nullptr}));
+                             providerFromPoolParamsCreate, nullptr}),
+                         poolCreateExtParamsNameGen);
diff --git a/test/providers/cuda_helpers.cpp b/test/providers/cuda_helpers.cpp
index 3e81c184ff..4678ea4acd 100644
--- a/test/providers/cuda_helpers.cpp
+++ b/test/providers/cuda_helpers.cpp
@@ -110,7 +110,7 @@ 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
 #if OPEN_CU_LIBRARY_GLOBAL
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_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_consumer.c b/test/providers/ipc_level_zero_prov_consumer.c
index 5fb2128815..abe08e7c82 100644
--- a/test/providers/ipc_level_zero_prov_consumer.c
+++ b/test/providers/ipc_level_zero_prov_consumer.c
@@ -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>
 
@@ -88,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 e6ffcf2ed6..535020eaeb 100644
--- a/test/providers/ipc_level_zero_prov_producer.c
+++ b/test/providers/ipc_level_zero_prov_producer.c
@@ -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>
 
@@ -88,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 a7e5dbe5a0..8a3d729eb0 100644
--- a/test/providers/provider_cuda.cpp
+++ b/test/providers/provider_cuda.cpp
@@ -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"
@@ -106,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);
@@ -116,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);
@@ -126,6 +128,8 @@ class CUDAMemoryAccessor : public MemoryAccessor {
         ASSERT_EQ(ret, 0);
     }
 
+    const char *getName() override { return "CUDAMemoryAccessor"; }
+
   private:
     CUdevice hDevice_;
     CUcontext hContext_;
@@ -268,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
@@ -383,6 +472,48 @@ TEST_P(umfCUDAProviderTest, cudaProviderNullParams) {
     EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
 
+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);
+}
+
 TEST_P(umfCUDAProviderTest, multiContext) {
     CUdevice device;
     int ret = get_cuda_device(&device);
@@ -452,6 +583,87 @@ TEST_P(umfCUDAProviderTest, multiContext) {
     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<
@@ -564,9 +776,16 @@ TEST_P(umfCUDAProviderAllocFlagsTest, reuseParams) {
 // TODO add tests that mixes CUDA Memory Provider and Disjoint Pool
 
 INSTANTIATE_TEST_SUITE_P(umfCUDAProviderTestSuite, umfCUDAProviderTest,
-                         ::testing::Values(UMF_MEMORY_TYPE_DEVICE,
+                         ::testing::Values(UMF_MEMORY_TYPE_HOST,
                                            UMF_MEMORY_TYPE_SHARED,
-                                           UMF_MEMORY_TYPE_HOST));
+                                           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(
     umfCUDAProviderAllocFlagsTestSuite, umfCUDAProviderAllocFlagsTest,
@@ -575,7 +794,13 @@ INSTANTIATE_TEST_SUITE_P(
         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)));
+        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 4054c26a83..9ddea2048c 100644
--- a/test/providers/provider_cuda_not_impl.cpp
+++ b/test/providers/provider_cuda_not_impl.cpp
@@ -29,6 +29,6 @@ TEST_F(test, cuda_provider_not_implemented) {
     result = umfCUDAMemoryProviderParamsSetAllocFlags(hParams, 0);
     ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
 
-    umf_memory_provider_ops_t *ops = umfCUDAMemoryProviderOps();
+    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 47b62cc945..1894d0aa4e 100644
--- a/test/providers/provider_level_zero.cpp
+++ b/test/providers/provider_level_zero.cpp
@@ -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"
@@ -113,10 +115,17 @@ struct LevelZeroProviderInit
 INSTANTIATE_TEST_SUITE_P(, LevelZeroProviderInit,
                          ::testing::Values(UMF_MEMORY_TYPE_HOST,
                                            UMF_MEMORY_TYPE_DEVICE,
-                                           UMF_MEMORY_TYPE_SHARED));
+                                           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();
@@ -146,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();
@@ -171,7 +180,7 @@ TEST_F(LevelZeroProviderInit, FailNonNullDevice) {
     if (GetParam() != UMF_MEMORY_TYPE_HOST) {
         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();
@@ -195,28 +204,44 @@ TEST_F(LevelZeroProviderInit, 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,
@@ -224,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);
 
@@ -233,6 +258,8 @@ 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_;
@@ -246,6 +273,7 @@ struct umfLevelZeroProviderTest
         test::SetUp();
 
         umf_usm_memory_type_t memory_type = this->GetParam();
+        umfExpectedMemoryType = memory_type;
 
         params = nullptr;
         memAccessor = nullptr;
@@ -298,6 +326,7 @@ struct umfLevelZeroProviderTest
     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);
@@ -381,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(
@@ -400,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);
@@ -480,13 +632,100 @@ TEST_P(umfLevelZeroProviderTest, setDeviceOrdinalValid) {
     }
 }
 
+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);
+
+    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(UMF_MEMORY_TYPE_DEVICE,
-                                           UMF_MEMORY_TYPE_SHARED,
-                                           UMF_MEMORY_TYPE_HOST));
+INSTANTIATE_TEST_SUITE_P(
+    umfLevelZeroProviderTestSuite, umfLevelZeroProviderTest,
+    ::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;
 
@@ -508,5 +747,6 @@ INSTANTIATE_TEST_SUITE_P(
     umfLevelZeroProviderTestSuite, umfIpcTest,
     ::testing::Values(ipcTestParams{
         umfProxyPoolOps(), nullptr, nullptr, umfLevelZeroMemoryProviderOps(),
-        createL0ParamsDeviceMemory, destroyL0Params, &l0Accessor}));
+        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 4948bd66f1..dfbd4a2b21 100644
--- a/test/providers/provider_level_zero_not_impl.cpp
+++ b/test/providers/provider_level_zero_not_impl.cpp
@@ -38,6 +38,6 @@ TEST_F(test, level_zero_provider_not_implemented) {
     result = umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(hParams, 0);
     ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
 
-    umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
+    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-test_disjoint_pool.supp b/test/supp/drd-test_disjoint_pool.supp
deleted file mode 100644
index 2a5548d27e..0000000000
--- a/test/supp/drd-test_disjoint_pool.supp
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-   False-positive ConflictingAccess in critnib_insert
-   drd:ConflictingAccess
-   fun:utils_atomic_store_release_ptr
-   fun:critnib_insert
-   ...
-}
diff --git a/test/supp/drd-test_ipc.supp b/test/supp/drd-test_ipc.supp
index fbdbd0183f..e55b2ee8d8 100644
--- a/test/supp/drd-test_ipc.supp
+++ b/test/supp/drd-test_ipc.supp
@@ -17,18 +17,12 @@
 }
 
 {
-   [false-positive] trackingGetIpcHandle
-   drd:ConflictingAccess
-   fun:trackingGetIpcHandle
-   fun:umfMemoryProviderGetIPCHandle
-   fun:umfGetIPCHandle
-}
-
-{
-   [false-positive] trackingGetIpcHandle
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
    drd:ConflictingAccess
-   fun:memmove
-   fun:trackingGetIpcHandle
-   fun:umfMemoryProviderGetIPCHandle
-   fun:umfGetIPCHandle
+   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
index fbdbd0183f..e55b2ee8d8 100644
--- a/test/supp/drd-test_ipc_max_opened_limit.supp
+++ b/test/supp/drd-test_ipc_max_opened_limit.supp
@@ -17,18 +17,12 @@
 }
 
 {
-   [false-positive] trackingGetIpcHandle
-   drd:ConflictingAccess
-   fun:trackingGetIpcHandle
-   fun:umfMemoryProviderGetIPCHandle
-   fun:umfGetIPCHandle
-}
-
-{
-   [false-positive] trackingGetIpcHandle
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
    drd:ConflictingAccess
-   fun:memmove
-   fun:trackingGetIpcHandle
-   fun:umfMemoryProviderGetIPCHandle
-   fun:umfGetIPCHandle
+   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
index 8d8746861c..cb6179f875 100644
--- a/test/supp/drd-test_jemalloc_coarse_devdax.supp
+++ b/test/supp/drd-test_jemalloc_coarse_devdax.supp
@@ -5,11 +5,3 @@
    fun:je_*
    ...
 }
-
-{
-   False-positive ConflictingAccess in critnib_insert
-   drd:ConflictingAccess
-   fun:utils_atomic_store_release_ptr
-   fun:critnib_insert
-   ...
-}
diff --git a/test/supp/drd-test_jemalloc_coarse_file.supp b/test/supp/drd-test_jemalloc_coarse_file.supp
index 8d8746861c..cb6179f875 100644
--- a/test/supp/drd-test_jemalloc_coarse_file.supp
+++ b/test/supp/drd-test_jemalloc_coarse_file.supp
@@ -5,11 +5,3 @@
    fun:je_*
    ...
 }
-
-{
-   False-positive ConflictingAccess in critnib_insert
-   drd:ConflictingAccess
-   fun:utils_atomic_store_release_ptr
-   fun:critnib_insert
-   ...
-}
diff --git a/test/supp/drd-test_provider_file_memory_ipc.supp b/test/supp/drd-test_provider_file_memory_ipc.supp
index 9883001f7c..2252cb021b 100644
--- a/test/supp/drd-test_provider_file_memory_ipc.supp
+++ b/test/supp/drd-test_provider_file_memory_ipc.supp
@@ -27,23 +27,6 @@
    ...
 }
 
-{
-   [false-positive] trackingGetIpcHandle
-   drd:ConflictingAccess
-   fun:trackingGetIpcHandle
-   fun:umfMemoryProviderGetIPCHandle
-   fun:umfGetIPCHandle
-}
-
-{
-   [false-positive] trackingGetIpcHandle
-   drd:ConflictingAccess
-   fun:memmove
-   fun:trackingGetIpcHandle
-   fun:umfMemoryProviderGetIPCHandle
-   fun:umfGetIPCHandle
-}
-
 {
    False-positive ConflictingAccess in jemalloc
    drd:ConflictingAccess
diff --git a/test/supp/helgrind-test_disjoint_pool.supp b/test/supp/helgrind-test_disjoint_pool.supp
index 65dfdd2c78..917237d7e9 100644
--- a/test/supp/helgrind-test_disjoint_pool.supp
+++ b/test/supp/helgrind-test_disjoint_pool.supp
@@ -27,11 +27,3 @@
    fun:*gthread_mutex_unlock*pthread_mutex_t
    ...
 }
-
-{
-   False-positive Race in critnib_insert
-   Helgrind:Race
-   fun:utils_atomic_store_release_ptr
-   fun:critnib_insert
-   ...
-}
diff --git a/test/supp/helgrind-test_ipc.supp b/test/supp/helgrind-test_ipc.supp
index 25ae87ea43..fb17fd7a08 100644
--- a/test/supp/helgrind-test_ipc.supp
+++ b/test/supp/helgrind-test_ipc.supp
@@ -1,20 +1,3 @@
-{
-   False-positive race in critnib_insert (lack of instrumentation)
-   Helgrind:Race
-   fun:utils_atomic_store_release_ptr
-   fun:critnib_insert
-   ...
-}
-
-{
-   False-positive race in critnib_find (lack of instrumentation)
-   Helgrind:Race
-   fun:find_predecessor
-   fun:find_le
-   fun:critnib_find
-   ...
-}
-
 {
    [false-positive] Double check locking pattern in trackingOpenIpcHandle
    Helgrind:Race
@@ -35,20 +18,3 @@
    fun:umfOpenIPCHandle
    ...
 }
-
-{
-   [false-positive] umfMemoryProviderGetIPCHandle
-   Helgrind:Race
-   fun:trackingGetIpcHandle
-   fun:umfMemoryProviderGetIPCHandle
-   fun:umfGetIPCHandle
-}
-
-{
-   [false-positive] umfMemoryProviderGetIPCHandle
-   Helgrind:Race
-   fun:memmove
-   fun:trackingGetIpcHandle
-   fun:umfMemoryProviderGetIPCHandle
-   fun:umfGetIPCHandle
-}
diff --git a/test/supp/helgrind-test_ipc_max_opened_limit.supp b/test/supp/helgrind-test_ipc_max_opened_limit.supp
index 25ae87ea43..fb17fd7a08 100644
--- a/test/supp/helgrind-test_ipc_max_opened_limit.supp
+++ b/test/supp/helgrind-test_ipc_max_opened_limit.supp
@@ -1,20 +1,3 @@
-{
-   False-positive race in critnib_insert (lack of instrumentation)
-   Helgrind:Race
-   fun:utils_atomic_store_release_ptr
-   fun:critnib_insert
-   ...
-}
-
-{
-   False-positive race in critnib_find (lack of instrumentation)
-   Helgrind:Race
-   fun:find_predecessor
-   fun:find_le
-   fun:critnib_find
-   ...
-}
-
 {
    [false-positive] Double check locking pattern in trackingOpenIpcHandle
    Helgrind:Race
@@ -35,20 +18,3 @@
    fun:umfOpenIPCHandle
    ...
 }
-
-{
-   [false-positive] umfMemoryProviderGetIPCHandle
-   Helgrind:Race
-   fun:trackingGetIpcHandle
-   fun:umfMemoryProviderGetIPCHandle
-   fun:umfGetIPCHandle
-}
-
-{
-   [false-positive] umfMemoryProviderGetIPCHandle
-   Helgrind:Race
-   fun:memmove
-   fun:trackingGetIpcHandle
-   fun:umfMemoryProviderGetIPCHandle
-   fun:umfGetIPCHandle
-}
diff --git a/test/supp/helgrind-test_jemalloc_coarse_devdax.supp b/test/supp/helgrind-test_jemalloc_coarse_devdax.supp
index 2f4980f519..98d748feac 100644
--- a/test/supp/helgrind-test_jemalloc_coarse_devdax.supp
+++ b/test/supp/helgrind-test_jemalloc_coarse_devdax.supp
@@ -5,11 +5,3 @@
    fun:je_*
    ...
 }
-
-{
-   False-positive Race in critnib_insert
-   Helgrind:Race
-   fun:utils_atomic_store_release_ptr
-   fun:critnib_insert
-   ...
-}
diff --git a/test/supp/helgrind-test_jemalloc_coarse_file.supp b/test/supp/helgrind-test_jemalloc_coarse_file.supp
index 2f4980f519..98d748feac 100644
--- a/test/supp/helgrind-test_jemalloc_coarse_file.supp
+++ b/test/supp/helgrind-test_jemalloc_coarse_file.supp
@@ -5,11 +5,3 @@
    fun:je_*
    ...
 }
-
-{
-   False-positive Race in critnib_insert
-   Helgrind:Race
-   fun:utils_atomic_store_release_ptr
-   fun:critnib_insert
-   ...
-}
diff --git a/test/supp/helgrind-test_provider_file_memory_ipc.supp b/test/supp/helgrind-test_provider_file_memory_ipc.supp
index 11791e4ed2..63e7d626c2 100644
--- a/test/supp/helgrind-test_provider_file_memory_ipc.supp
+++ b/test/supp/helgrind-test_provider_file_memory_ipc.supp
@@ -19,23 +19,6 @@
    ...
 }
 
-{
-   False-positive race in critnib_insert (lack of instrumentation)
-   Helgrind:Race
-   fun:utils_atomic_store_release_ptr
-   fun:critnib_insert
-   ...
-}
-
-{
-   False-positive race in critnib_find (lack of instrumentation)
-   Helgrind:Race
-   fun:find_predecessor
-   fun:find_le
-   fun:critnib_find
-   ...
-}
-
 {
    False-positive ConflictingAccess in jemalloc
    Helgrind:Race
@@ -52,20 +35,3 @@
    fun:tbb_pool_finalize
    ...
 }
-
-{
-   [false-positive] trackingGetIpcHandle
-   Helgrind:Race
-   fun:trackingGetIpcHandle
-   fun:umfMemoryProviderGetIPCHandle
-   fun:umfGetIPCHandle
-}
-
-{
-   [false-positive] trackingGetIpcHandle
-   Helgrind:Race
-   fun:memmove
-   fun:trackingGetIpcHandle
-   fun:umfMemoryProviderGetIPCHandle
-   fun:umfGetIPCHandle
-}
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 4cf7890001..cba8a4fb3e 100644
--- a/test/test_installation.py
+++ b/test/test_installation.py
@@ -125,6 +125,9 @@ def _create_match_list(self) -> List[str]:
                 )
                 lib.append(f"lib/{lib_prefix}umf.{self.umf_version}.{lib_ext_shared}")
         else:
+            lib.append(f"lib/{lib_prefix}umf_ba.{lib_ext_static}")
+            lib.append(f"lib/{lib_prefix}umf_coarse.{lib_ext_static}")
+            lib.append(f"lib/{lib_prefix}umf_utils.{lib_ext_static}")
             lib.append(f"lib/{lib_prefix}umf.{lib_ext_static}")
             if self.umfd_lib and platform.system() == "Windows":
                 lib.append(f"lib/{lib_prefix}umfd.{lib_ext_static}")
@@ -181,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")
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 2e4f655f64..fa2610dd37 100755
--- a/test/test_valgrind.sh
+++ b/test/test_valgrind.sh
@@ -11,8 +11,9 @@ TOOL=$3
 TESTS=$4
 
 function print_usage() {
-	echo "$(basename $0) - run UMF tests and examples under a valgrind tool (memcheck, drd or helgrind)"
-	echo "Usage: $(basename $0) <workspace_dir> <build_dir> <memcheck|drd|helgrind> [tests_examples]"
+	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)."
@@ -43,6 +44,8 @@ if [ $(ls -1 ${BUILD_DIR}/test/test_* 2>/dev/null | wc -l) -eq 0 ]; then
 	exit 1
 fi
 
+EXCLUDE_LONGEST_TESTS=0
+
 case $TOOL in
 memcheck)
 	OPTION="--leak-check=full"
@@ -50,6 +53,11 @@ memcheck)
 drd)
 	OPTION="--tool=drd"
 	;;
+drdshort)
+	OPTION="--tool=drd"
+	TOOL="drd"
+	EXCLUDE_LONGEST_TESTS=1
+	;;
 helgrind)
 	OPTION="--tool=helgrind"
 	;;
@@ -120,6 +128,9 @@ for test in $TESTS; do
 		echo "- SKIPPED"
 		continue; # skip testing helper binaries used by the ipc_file_prov_* tests
 		;;
+	./test/test_ctl_env_app)
+		continue; # this is not a standalone test
+		;;
 	./test/test_memspace_host_all)
 		FILTER='--gtest_filter="-*allocsSpreadAcrossAllNumaNodes"'
 		;;
@@ -132,9 +143,17 @@ for test in $TESTS; do
 	./test/test_memspace_highest_capacity)
 		FILTER='--gtest_filter="-*highestCapacityVerify*"'
 		;;
+	./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*"'
 		;;
+	./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*"'
 		;;
@@ -150,6 +169,16 @@ for test in $TESTS; do
 		;;
 	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
diff --git a/test/utils/cpp_helpers.hpp b/test/utils/cpp_helpers.hpp
index 037c633c17..1f8ffb4e7a 100644
--- a/test/utils/cpp_helpers.hpp
+++ b/test/utils/cpp_helpers.hpp
@@ -10,11 +10,6 @@
 #ifndef UMF_TEST_HELPERS_HPP
 #define UMF_TEST_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>
-
 #include <array>
 #include <functional>
 #include <memory>
@@ -22,11 +17,17 @@
 #include <tuple>
 #include <utility>
 
+#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 (...) {                                                        \
         }                                                                      \
@@ -68,36 +75,50 @@ 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_POOL_OPS_VERSION_CURRENT;
-    ops.finalize = [](void *obj) { delete reinterpret_cast<T *>(obj); };
+    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_PROVIDER_OPS_VERSION_CURRENT;
-    ops.finalize = [](void *obj) { delete reinterpret_cast<T *>(obj); };
+    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, T, free, UMF_RESULT_ERROR_UNKNOWN);
-    UMF_ASSIGN_OP_NORETURN(ops, T, get_last_native_error);
+    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)));
         }
     };
 
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 467ea1e033..50e1ead7a7 100644
--- a/third_party/requirements.txt
+++ b/third_party/requirements.txt
@@ -1,12 +1,14 @@
 # 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.19.1
+pygments==2.19.2
 sphinxcontrib_applehelp==2.0.0
 sphinxcontrib_devhelp==2.0.0
 sphinxcontrib_htmlhelp==2.1.0
@@ -16,5 +18,6 @@ breathe==4.36.0
 sphinx==8.1.3
 sphinx_book_theme==1.1.3
 # Spelling check in documentation
-pyenchant==3.2.2
-sphinxcontrib-spelling==8.0.1
+codespell==2.4.1
+pyenchant==3.3.0
+sphinxcontrib-spelling==8.0.2