diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index f00070d21..c24160fbb 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -14,3 +14,12 @@ updates:
         applies-to: version-updates
         patterns:
           - "*"
+  - package-ecosystem: "github-actions"
+    directory: "/.github/workflows/"
+    schedule:
+      interval: "daily"
+    groups:
+      actions-dependencies:
+        applies-to: version-updates
+        patterns:
+          - "*"
diff --git a/.github/docker/ubuntu-20.04.Dockerfile b/.github/docker/ubuntu-20.04.Dockerfile
index a6a45a8c1..8869303b7 100644
--- a/.github/docker/ubuntu-20.04.Dockerfile
+++ b/.github/docker/ubuntu-20.04.Dockerfile
@@ -1,10 +1,10 @@
-# 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")
@@ -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})"
+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 75c71c526..915d92c26 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
 
@@ -17,24 +17,30 @@ ENV NOTTY 1
 ENV DEBIAN_FRONTEND noninteractive
 
 # Base development packages
+# It seems that libtool is not directly needed
+# but it is still required when Building UMF
 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)
 ARG MISC_DEPS="\
 	automake \
 	clang \
+	lcov \
 	python3-pip \
 	sudo \
 	whois"
@@ -43,14 +49,14 @@ 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
@@ -59,5 +65,5 @@ 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})"
+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 000000000..e56338ab9
--- /dev/null
+++ b/.github/docker/ubuntu-24.04.Dockerfile
@@ -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
+
+#
+# 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
+ARG BASE_DEPS="\
+	build-essential \
+	cmake \
+	git \
+	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/get_system_info.sh b/.github/scripts/get_system_info.sh
index 81c54ce98..573c7195d 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
diff --git a/.github/scripts/install_oneAPI.sh b/.github/scripts/install_oneAPI.sh
new file mode 100755
index 000000000..6b8e49e28
--- /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 -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 24b9023fe..288af6a19 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"]
 
 [files]
 # completely exclude those files from consideration:
diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml
index 7eb3c7b06..6f540ae39 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_compare: ${{ inputs.bench_script_compare }}
+      runner: ${{ inputs.runner }}
diff --git a/.github/workflows/coverity.yml b/.github/workflows/coverity.yml
index ebae6086a..a087d1197 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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       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 000000000..93a6c3994
--- /dev/null
+++ b/.github/workflows/detect_changes.yml
@@ -0,0 +1,44 @@
+name: DetectChanges
+
+on:
+  pull_request:
+    paths:
+      - '.github/docker/*.Dockerfile'
+      - '.github/scripts/*'
+  push:
+    paths:
+      - '.github/docker/*.Dockerfile'
+      - '.github/scripts/*'
+
+permissions:
+  contents: read
+
+jobs:
+  DetectChanges:
+    runs-on: ubuntu-latest
+    outputs:
+      changed_files: ${{ steps.changed-files.outputs.all_changed_files }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+
+      - name: Get changed files
+        id: changed-files
+        uses: tj-actions/changed-files@ed68ef82c095e0d48ec87eccea555d944a631a4c #v46.0.5
+
+      - 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 0918a3699..196fae109 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 000000000..58280e53e
--- /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 f209cf2c5..2cdc42480 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -16,18 +16,17 @@ env:
 
 jobs:
   fuzz-test:
-      name: Fuzz test
       strategy:
         fail-fast: false
         matrix:
           build_type: [Debug, Release]
           compiler: [{c: clang, cxx: clang++}]
-      
+      name: Fuzz test (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@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           fetch-depth: 0
 
@@ -36,13 +35,20 @@ jobs:
           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
@@ -50,21 +56,29 @@ jobs:
       - 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: 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"
+
       - name: Fuzz long test
         working-directory: ${{github.workspace}}/build
         run: ctest -C ${{matrix.build_type}} --output-on-failure --verbose -L "fuzz-long"
 
   valgrind:
-    name: 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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
 
@@ -79,7 +93,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
@@ -93,7 +107,6 @@ jobs:
       run: ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{github.workspace}}/build ${{matrix.tool}}
 
   Windows-generators:
-    name: Windows ${{matrix.generator}} generator
     strategy:
       matrix:
         build_type: [Debug, Release]
@@ -102,12 +115,13 @@ 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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
 
@@ -133,7 +147,7 @@ jobs:
 
     - 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
@@ -186,7 +200,6 @@ jobs:
         ${{ matrix.static_hwloc == 'ON' && '--hwloc' || '' }}
 
   icx:
-   name: ICX
    env:
      VCPKG_PATH: "${{github.workspace}}/build/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows"
    strategy:
@@ -200,12 +213,12 @@ 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
+     uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
      with:
        fetch-depth: 0
   
@@ -220,7 +233,7 @@ jobs:
      run: vcpkg install --triplet x64-windows
   
    - name: Install Ninja
-     uses: seanmiddleditch/gha-setup-ninja@96bed6edff20d1dd61ecff9b75cc519d516e6401 # v5
+     uses: seanmiddleditch/gha-setup-ninja@3b1f8f94a2f8254bd26914c4ab9474d4f0015f67 # v6
   
    - name: Download icx compiler
      env:
@@ -270,10 +283,10 @@ jobs:
        call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
        ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
 
-  hwloc-fallback:
   # 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 +296,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:
@@ -321,11 +334,19 @@ jobs:
   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"
+      os: "['Ubuntu']"
   CUDA:
     uses: ./.github/workflows/reusable_gpu.yml
     with:
-      name: "CUDA"
+      provider: "CUDA"
+      runner: "CUDA"
 
   # Full execution of QEMU tests
   QEMU:
@@ -334,14 +355,32 @@ 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'
+
+  Benchmarks-sycl:
+    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
diff --git a/.github/workflows/nightly_looped_sanitizers.yml b/.github/workflows/nightly_looped_sanitizers.yml
new file mode 100644
index 000000000..c151fdbe9
--- /dev/null
+++ b/.github/workflows/nightly_looped_sanitizers.yml
@@ -0,0 +1,80 @@
+# Check code with looped compilers' sanitizers
+# This build lasts 6 hours.
+name: Sanitizers - Looped
+
+# 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"
+
+permissions:
+  contents: read
+
+jobs:
+  ubuntu-build:
+    name: Ubuntu
+    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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      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 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: 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=ON
+        -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: while ctest --output-on-failure; do date; done && exit 1
diff --git a/.github/workflows/pr_push.yml b/.github/workflows/pr_push.yml
index 511808887..8ad9c83c1 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,23 @@ 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']"
+      os: "['Ubuntu']"
   CUDA:
     needs: [Build]
     uses: ./.github/workflows/reusable_gpu.yml
     with:
-      name: "CUDA"
+      provider: "CUDA"
+      runner: "CUDA"
       shared_lib: "['ON']"
   Sanitizers:
     needs: [FastBuild]
@@ -90,6 +99,6 @@ jobs:
     uses: ./.github/workflows/reusable_compatibility.yml
     strategy:
       matrix:
-        tag: ["v0.11.0-dev1"]
+        tag: ["v0.11.0-rc1"]
     with:
       tag: ${{matrix.tag}}
diff --git a/.github/workflows/reusable_basic.yml b/.github/workflows/reusable_basic.yml
index b30bfed4c..ed8494b2c 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']
@@ -26,8 +32,9 @@ jobs:
         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'
@@ -36,7 +43,9 @@ jobs:
             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'
@@ -45,7 +54,8 @@ jobs:
             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'
@@ -54,8 +64,9 @@ jobs:
             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'
@@ -64,8 +75,9 @@ jobs:
             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'
@@ -74,8 +86,9 @@ jobs:
             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'
@@ -85,8 +98,9 @@ jobs:
             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'
@@ -95,7 +109,8 @@ jobs:
             install_tbb: 'OFF'
             disable_hwloc: 'OFF'
             link_hwloc_statically: 'OFF'
-          - os: 'ubuntu-22.04'
+            cmake_ver: 'default'
+          - os: ubuntu-22.04
             build_type: Debug
             compiler: {c: gcc, cxx: g++}
             shared_library: 'ON'
@@ -104,7 +119,8 @@ jobs:
             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'
@@ -113,42 +129,43 @@ jobs:
             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}}, disable_hwloc=${{matrix.disable_hwloc}}, 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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
 
-    - name: Install apt packages
+    - name: Install cmake (non-default version)
+      if: matrix.cmake_ver != 'default'
+      run: |
+        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: Uninstall hwloc
+      if: matrix.disable_hwloc == 'ON'
       run: |
-        sudo apt-get update
-        sudo apt-get install -y clang cmake libnuma-dev lcov
+        echo ${USERPASS} | sudo -Sk apt-get remove --purge -y '*hwloc*'
+        echo ${USERPASS} | sudo -Sk apt-get autoremove -y
 
-    - 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
 
@@ -194,7 +211,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@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
       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}}
@@ -215,9 +232,9 @@ jobs:
         ${{ 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"
+      VCPKG_PATH_BIN: "${{github.workspace}}/build/vcpkg/packages/hwloc_x64-windows/bin;${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows/bin;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows/bin"
     strategy:
       matrix:
         os: ['windows-2019', 'windows-2022']
@@ -226,6 +243,7 @@ jobs:
         shared_library: ['ON', 'OFF']
         level_zero_provider: ['ON']
         cuda_provider: ['ON']
+        cmake_ver: ['default']
         include:
           - os: 'windows-2019'
             # clang build fails on Windows 2022
@@ -235,6 +253,7 @@ jobs:
             level_zero_provider: 'ON'
             cuda_provider: 'ON'
             toolset: "-T ClangCL"
+            cmake_ver: '3.14.0-win64-x64'
           - os: 'windows-2022'
             build_type: Release
             compiler: {c: cl, cxx: cl}
@@ -242,21 +261,42 @@ jobs:
             level_zero_provider: 'ON'
             cuda_provider: 'ON'
             umfd_lib: 'ON'
+            cmake_ver: '3.28.0-windows-x86_64'
           - os: 'windows-2022'
             build_type: Release
             compiler: {c: cl, cxx: cl}
             shared_library: 'ON'
             level_zero_provider: 'OFF'
             cuda_provider: 'OFF'
-
+            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}}, cmake_ver=${{matrix.cmake_ver}})
     runs-on: ${{matrix.os}}
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
 
+    - name: Install cmake (non-default version)
+      if: matrix.cmake_ver != 'default'
+      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
+
     - name: Initialize vcpkg
       uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
       with:
@@ -264,8 +304,13 @@ jobs:
         vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
         vcpkgJsonGlob: '**/vcpkg.json'
 
+    # Install the dependencies and add the bin folders to the PATH for older
+    # versions of CMake to correctly locate the libraries
     - name: Install dependencies
-      run: vcpkg install --triplet x64-windows
+      run: |
+        vcpkg install --triplet x64-windows        
+        $env:Path = "${{env.VCPKG_PATH_BIN}};$env:Path"
+        echo "PATH=$env:Path" >> $env:GITHUB_ENV
       shell: pwsh # Specifies PowerShell as the shell for running the script.
 
     - name: Get UMF version
@@ -297,10 +342,23 @@ jobs:
 
     - name: Run tests
       working-directory: ${{env.BUILD_DIR}}
-      run: ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
+      # For CMake versions < 3.22 we have to add the build directory to the PATH
+      # manually
+      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_DIR}}/bin/${{matrix.build_type}};${{env.BUILD_DIR}}/src/proxy_lib/${{matrix.build_type}};$env:Path"
+          }
+        }
+        ctest -C ${{matrix.build_type}} --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
+      # 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}}
@@ -331,7 +389,7 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
 
@@ -373,7 +431,7 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
 
@@ -415,7 +473,7 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
 
@@ -450,20 +508,20 @@ jobs:
       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: '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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
 
@@ -499,6 +557,7 @@ jobs:
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
         -DUMF_BUILD_SHARED_LIBRARY=ON
         -DUMF_TESTS_FAIL_ON_SKIP=ON
+        -DUMF_LINK_HWLOC_STATICALLY=${{matrix.static_hwloc}}
         ${{matrix.static_hwloc}}
 
     - name: Build UMF
diff --git a/.github/workflows/reusable_benchmarks.yml b/.github/workflows/reusable_benchmarks.yml
index 3953e98de..c45f53477 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,23 @@ 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
 
 env:
   UMF_DIR: "${{github.workspace}}/umf-repo"
@@ -32,16 +41,21 @@ 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
@@ -50,7 +64,7 @@ jobs:
         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({
@@ -97,27 +111,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
+    - name: Checkout UMF results branch
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       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)!
+        #
+        # 15.04.2025
+        # branch: sycl
+        ref: 08d11bcae0cc2daec903f222c9b3e3af92f3b806
+        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,27 +155,62 @@ 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
@@ -160,7 +220,7 @@ jobs:
           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 +228,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 +237,43 @@ 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 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
+          cp ${{ github.workspace }}/sc/devops/scripts/benchmarks/html/data.json .
+
+          git add data.json results/
+          git commit -m "Add benchmark results and data.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"
+          (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 a7602d269..51d76d3d6 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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       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@b1ae8d918b6e85bd611117d3d9a3be4f903ee5e4 # v1.33.1
       with:
         config: ./.github/workflows/.spellcheck-conf.toml
 
diff --git a/.github/workflows/reusable_codeql.yml b/.github/workflows/reusable_codeql.yml
index 252e70eee..1c2902db7 100644
--- a/.github/workflows/reusable_codeql.yml
+++ b/.github/workflows/reusable_codeql.yml
@@ -8,7 +8,7 @@ permissions:
 
 env:
   BUILD_DIR : "${{github.workspace}}/build"
-  INSTL_DIR : "${{github.workspace}}/../install-dir"
+  INSTL_DIR : "${{github.workspace}}/install-dir"
 
 jobs:
   analyze:
@@ -30,17 +30,17 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
 
     - name: Setup newer Python
-      uses: actions/setup-python@0a5c61591373683505ea898e09a3ea4f39ef2b9c # v5.0.0
+      uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
       with:
         python-version: "3.10"
 
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@b7bf0a3ed3ecfa44160715d7c442788f65f0f923 # v3.23.2
+      uses: github/codeql-action/init@fca7ace96b7d713c7035871441bd52efbe39e27e # v3.28.19
       with:
         languages: cpp
 
@@ -91,4 +91,4 @@ 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@fca7ace96b7d713c7035871441bd52efbe39e27e # v3.28.19
diff --git a/.github/workflows/reusable_compatibility.yml b/.github/workflows/reusable_compatibility.yml
index 523b09e12..12ad0bf10 100644
--- a/.github/workflows/reusable_compatibility.yml
+++ b/.github/workflows/reusable_compatibility.yml
@@ -9,7 +9,7 @@ on:
       tag:
         description: Check backward compatibility with this tag
         type: string
-        default: "v0.11.0-dev1"
+        default: "v0.11.0-rc1"
 
 permissions:
   contents: read
@@ -23,93 +23,114 @@ 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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      with:
+        fetch-depth: 0
+        path: ${{github.workspace}}/latest_version
 
-    - name: Configure "tag" UMF build
-      working-directory: ${{github.workspace}}/tag_version
+    - name: Configure latest UMF build
+      working-directory: ${{github.workspace}}/latest_version
       run: >
         cmake
-        -B ${{github.workspace}}/tag_version/build
+        -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=ON
-        -DUMF_BUILD_EXAMPLES=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
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
-        -DUMF_TESTS_FAIL_ON_SKIP=ON
-
-    - name: Build "tag" UMF
-      working-directory: ${{github.workspace}}/tag_version
-      run: |
-        cmake --build ${{github.workspace}}/tag_version/build -j $(nproc)
 
-    - name: Run "tag" UMF tests
-      working-directory: ${{github.workspace}}/tag_version/build
+    - name: Build latest UMF
+      working-directory: ${{github.workspace}}/latest_version
       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
+        cmake --build ${{github.workspace}}/latest_version/build -j $(nproc)
 
-    - name: Configure latest UMF build
+    - name: Install latest UMF
       working-directory: ${{github.workspace}}/latest_version
+      run: sudo cmake --install ${{github.workspace}}/latest_version/build --config Debug
+
+    - name: Configure "tag" UMF build
+      working-directory: ${{github.workspace}}/tag_version
       run: >
         cmake
-        -B ${{github.workspace}}/latest_version/build
+        -B ${{github.workspace}}/tag_version/build
         -DCMAKE_BUILD_TYPE=Debug
         -DUMF_BUILD_SHARED_LIBRARY=ON
         -DCMAKE_C_COMPILER=gcc
         -DCMAKE_CXX_COMPILER=g++
-        -DUMF_BUILD_TESTS=OFF
+        -DUMF_BUILD_TESTS=ON
+        -DUMF_BUILD_EXAMPLES=ON
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
         -DUMF_BUILD_CUDA_PROVIDER=ON
         -DUMF_FORMAT_CODE_STYLE=OFF
         -DUMF_DEVELOPER_MODE=ON
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
 
-    - name: Build latest UMF
-      working-directory: ${{github.workspace}}/latest_version
+    - name: Build "tag" UMF
+      working-directory: ${{github.workspace}}/tag_version
       run: |
-        cmake --build ${{github.workspace}}/latest_version/build -j $(nproc)
+        cmake --build ${{github.workspace}}/tag_version/build -j $(nproc)
+
+    - name: Run "tag" UMF tests
+      working-directory: ${{github.workspace}}/tag_version/build
+      run: |
+        LD_LIBRARY_PATH=${{github.workspace}}/tag_version/build/lib/ ctest --output-on-failure
 
     - name: Run "tag" UMF tests with latest UMF libs (warnings enabled)
       working-directory: ${{github.workspace}}/tag_version/build
-      # 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
 
+    # Browse all folders in the examples directory, build them using the 
+    # latest UMF version, and run them, excluding those in the exclude list.
+    - name: Build and run "tag" examples using the latest UMF libraries
+      working-directory: ${{github.workspace}}/tag_version
+      run: |  
+        EXAMPLES_EXCLUDE_LIST="cmake|common|hmat|level_zero|cuda"
+        rm -rf build
+        rm -rf include
+        mkdir _examples
+        cd _examples
+        EXAMPLES_LIST=$(find ${{github.workspace}}/tag_version/examples -maxdepth 1 -mindepth 1 -type d | grep -Ev $EXAMPLES_EXCLUDE_LIST | xargs -n 1 basename)
+        for EXAMPLE_NAME in $EXAMPLES_LIST; do
+          cd ${{github.workspace}}/tag_version
+          mkdir -p _examples/$EXAMPLE_NAME;
+          cd _examples/$EXAMPLE_NAME;
+          echo "Building example: $EXAMPLE_NAME"
+          CMAKE_PREFIX_PATH=${{github.workspace}}/latest_version/_install cmake ${{github.workspace}}/tag_version/examples/$EXAMPLE_NAME;
+          make;
+          find . -maxdepth 1 -type f -executable -exec echo "Running example: {}" \; -exec {} \;
+        done
+
   windows:
     name: Windows
     env:
       VCPKG_PATH: "${{github.workspace}}/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/vcpkg/packages/jemalloc_x64-windows"
+      VCPKG_BIN_PATH: "${{github.workspace}}/vcpkg/packages/hwloc_x64-windows/bin;${{github.workspace}}/vcpkg/packages/tbb_x64-windows/bin;${{github.workspace}}/vcpkg/packages/jemalloc_x64-windows/bin"
     runs-on: "windows-2022"
 
     steps:
     - name: Checkout "tag" UMF version
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
         ref: refs/tags/${{inputs.tag}}
@@ -128,6 +149,36 @@ jobs:
       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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      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 +205,67 @@ 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
+      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
+
+    # 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
+            }
+          }
+        }
+
+  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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
         path: ${{github.workspace}}/latest_version
@@ -164,11 +274,12 @@ 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
@@ -177,28 +288,16 @@ jobs:
         -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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
         ref: refs/tags/${{inputs.tag}}
@@ -235,41 +334,34 @@ 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
-      run: |
-        cmake --build ${{github.workspace}}/latest_version/build -j $(nproc)
-
-    # NOTE: Once not implemented features may now be implemented - exclude these tests
     - name: Run "tag" UMF tests 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"
+        ctest --verbose
+
+    # 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 c8dde20ec..b632b718d 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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         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@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.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@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: coverage_html_report
           path: coverage/coverage_report
diff --git a/.github/workflows/reusable_dax.yml b/.github/workflows/reusable_dax.yml
index 4ea5ddac7..3d059a07c 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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         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@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         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 000000000..1e3549fa4
--- /dev/null
+++ b/.github/workflows/reusable_dockers_build.yml
@@ -0,0 +1,43 @@
+# Build and push Docker images to GHCR
+name: BuildDockers
+
+on: 
+  workflow_call:
+  workflow_dispatch:
+
+permissions:
+  packages: write
+  contents: 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
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        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@74a5d142397b4f367a81961eba4e8cd7edddf772 # v3.4.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 9317478bb..e73b67033 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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
 
@@ -45,22 +45,40 @@ jobs:
           -DUMF_DISABLE_HWLOC=ON
         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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
-        path: umf-repo/build/benchmark_results.html
-        key: benchmark-results-
+        repository: intel/llvm
+        # 15.04.2025
+        # branch: sycl
+        ref: 08d11bcae0cc2daec903f222c9b3e3af92f3b806
+        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/data.json';
+        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@56afc609e74202658d3ffba0e8f6dda462b719fa # v3.0.1
       with:
         path: build/docs_build/generated/html
diff --git a/.github/workflows/reusable_fast.yml b/.github/workflows/reusable_fast.yml
index 7b1087ed0..63bbc85d0 100644
--- a/.github/workflows/reusable_fast.yml
+++ b/.github/workflows/reusable_fast.yml
@@ -1,80 +1,124 @@
-# 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
-            build_tests: 'ON'
-            simple_cmake: 'OFF'
-          # pure C build (Windows)
-          - os: windows-latest
-            # Tests' building is off for a pure C build
-            build_tests: 'OFF'
-            simple_cmake: 'OFF'
-          - os: ubuntu-latest
+          - os: ubuntu-24.04
             build_tests: 'ON'
-            # Windows doesn't recognize 'CMAKE_BUILD_TYPE', it uses '--config' param in build command
-            extra_build_options: '-DCMAKE_BUILD_TYPE=Release -DUMF_BUILD_BENCHMARKS=ON -DUMF_BUILD_BENCHMARKS_MT=ON'
+            extra_build_options: ' -DUMF_BUILD_BENCHMARKS=ON -DUMF_BUILD_BENCHMARKS_MT=ON'
             simple_cmake: 'OFF'
-          # pure C build (Linux)
-          - os: ubuntu-latest
-            # Windows doesn't recognize 'CMAKE_BUILD_TYPE', it uses '--config' param in build command
+          # pure C build
+          - os: ubuntu-24.04
             # Tests' building is off for a pure C build
             build_tests: 'OFF'
-            extra_build_options: '-DCMAKE_BUILD_TYPE=Release -DUMF_BUILD_BENCHMARKS=ON'
+            extra_build_options: '-DUMF_BUILD_BENCHMARKS=ON'
             simple_cmake: 'OFF'
-          # simplest CMake on ubuntu-latest
-          - os: ubuntu-latest
+          # simplest CMake on Ubuntu 22.04, 24.04
+          - os: ubuntu-24.04
             build_tests: 'ON'
-            extra_build_options: '-DCMAKE_BUILD_TYPE=Release'
             simple_cmake: 'ON'
-          # simplest CMake ubuntu-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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
 
     - name: Initialize vcpkg
-      if: matrix.os == 'windows-latest'
       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'
+    - name: Install dependencies
       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
-
     - name: Configure CMake
       if: matrix.simple_cmake == 'OFF'
       run: >
@@ -91,7 +135,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 +142,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 +161,6 @@ 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
diff --git a/.github/workflows/reusable_gpu.yml b/.github/workflows/reusable_gpu.yml
index 6fcd40820..1f342733e 100644
--- a/.github/workflows/reusable_gpu.yml
+++ b/.github/workflows/reusable_gpu.yml
@@ -5,10 +5,14 @@ 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
@@ -27,16 +31,14 @@ permissions:
 
 env:
   BUILD_DIR : "${{github.workspace}}/build"
-  INSTL_DIR : "${{github.workspace}}/../install-dir"
+  INSTL_DIR : "${{github.workspace}}/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}}"
+      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:
@@ -45,18 +47,28 @@ jobs:
         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}}, build_type=${{matrix.build_type}}, 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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           fetch-depth: 0
 
@@ -81,12 +93,12 @@ jobs:
       - name: Configure build
         run: >
           cmake
-          -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}${{env.CUDA_PATH}}"
+          -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}};${{env.EXTRA_CMAKE_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_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,13 +109,13 @@ 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 == 'Windows' && '-DCMAKE_SUPPRESS_REGENERATION=ON' || '' }}
 
       - name: Build UMF
-        run: cmake --build ${{env.BUILD_DIR}} --config ${{matrix.build_type}} -j ${{matrix.number_of_processors}}
+        run: cmake --build ${{env.BUILD_DIR}} --config ${{matrix.build_type}} -j ${{env.PROCS}}
 
       - name: Run tests
         working-directory: ${{env.BUILD_DIR}}
@@ -128,7 +140,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@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         if: ${{ matrix.build_type == 'Debug' && matrix.os == 'Ubuntu' }}
         with:
           name: ${{env.COVERAGE_NAME}}-shared-${{matrix.shared_library}}
diff --git a/.github/workflows/reusable_multi_numa.yml b/.github/workflows/reusable_multi_numa.yml
index 47a48adb2..63075c6f9 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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         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@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         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 c519be95b..4eb191fef 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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         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@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         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 257e90f62..df4125d1a 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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       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@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
       with:
         name: exports-coverage-qemu-${{matrix.os}}
         path: coverage
diff --git a/.github/workflows/reusable_sanitizers.yml b/.github/workflows/reusable_sanitizers.yml
index c74448e1d..becab2cc4 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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
 
@@ -75,7 +75,6 @@ jobs:
         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:
@@ -83,11 +82,12 @@ jobs:
         compiler: [{c: cl, cxx: cl}, {c: clang-cl, cxx: clang-cl}]
         # Only ASAN is supported
         sanitizers: [{asan: ON}]
+    name: Sanitizers (windows-2022, compilers=${{matrix.compiler.c}}/${{matrix.compiler.cxx}}, asan=${{matrix.sanitizers.asan}})
     runs-on: windows-2022
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
 
@@ -98,7 +98,7 @@ jobs:
     # 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
+      uses: TheMrMilchmann/setup-msvc-dev@fb19abb8a41b3cf0340f5d1be17d420309232be6 # v3.0.1
       with:
         arch: x64
         toolset: '14'
diff --git a/.github/workflows/reusable_sycl.yml b/.github/workflows/reusable_sycl.yml
new file mode 100644
index 000000000..7752aa7d4
--- /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-03-15"] # "latest" or llvm with UMF v0.11.0-dev4
+
+    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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      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 c10229276..6fe6350d9 100644
--- a/.github/workflows/reusable_trivy.yml
+++ b/.github/workflows/reusable_trivy.yml
@@ -15,12 +15,12 @@ jobs:
 
     steps:
       - name: Clone the git repo
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           fetch-depth: 0
 
       - name: Run Trivy
-        uses: aquasecurity/trivy-action@84384bd6e777ef152729993b8145ea352e9dd3ef # v0.17.0
+        uses: aquasecurity/trivy-action@76071ef0d7ec797419534a183b498b4d6366cf37 # v0.31.0
         with:
           scan-type: 'config'
           hide-progress: false
@@ -37,6 +37,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@fca7ace96b7d713c7035871441bd52efbe39e27e # v3.28.19
         with:
           sarif_file: 'trivy-results.sarif'
diff --git a/.github/workflows/reusable_valgrind.yml b/.github/workflows/reusable_valgrind.yml
index 5999297d6..65bb767ed 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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       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 b28bb150e..c28fc44da 100644
--- a/.github/workflows/scorecard.yml
+++ b/.github/workflows/scorecard.yml
@@ -26,12 +26,12 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
 
     - name: Run analysis
-      uses: ossf/scorecard-action@0864cf19026789058feabb7e87baa5f140aac736 # v2.3.1
+      uses: ossf/scorecard-action@05b42c624433fc40578a4040d5cf5e36ddca8cde # v2.4.2
       with:
         results_file: scorecard_results.sarif
         results_format: sarif
@@ -39,7 +39,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@ea165f8d65b6e75b540449e92b4886f43607fa02 # 4.6.2
       with:
         name: Scorecard results
         path: scorecard_results.sarif
@@ -47,6 +47,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@fca7ace96b7d713c7035871441bd52efbe39e27e # v3.28.19
       with:
         sarif_file: scorecard_results.sarif
diff --git a/CMakeLists.txt b/CMakeLists.txt
index f7e640abc..4eeb575df 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})
 
@@ -71,7 +73,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_BUILD_FUZZTESTS
+           "Build UMF fuzz tests (supported only on Linux with Clang)" OFF)
 umf_option(
     UMF_DISABLE_HWLOC
     "Disable hwloc and UMF features requiring it (OS provider, memtargets, topology discovery)"
@@ -116,6 +119,13 @@ set_property(CACHE UMF_PROXY_LIB_BASED_ON_POOL
              PROPERTY STRINGS ${KNOWN_PROXY_LIB_POOLS})
 list(APPEND UMF_OPTIONS_LIST UMF_PROXY_LIB_BASED_ON_POOL)
 
+if(UMF_DISABLE_HWLOC)
+    message(
+        WARNING
+            "UMF_DISABLE_HWLOC option is now deprecated and will be removed in v0.12.0 UMF release!"
+    )
+endif()
+
 # --------------------------------------------------------------------------- #
 # Setup required variables, definitions; fetch dependencies; include
 # sub_directories based on build options; set flags; etc.
@@ -225,12 +235,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
@@ -253,12 +264,9 @@ if(NOT UMF_DISABLE_HWLOC AND (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}")
@@ -317,6 +325,7 @@ else()
                                    DIRECTORY)
             set(LIBHWLOC_LIBRARIES ${HWLOC_LIB_PATH})
             set(LIBHWLOC_INCLUDE_DIRS ${hwloc_targ_BINARY_DIR}/include)
+            set(LIBHWLOC_FOUND TRUE)
         else() # not Windows
             FetchContent_Declare(
                 hwloc_targ
@@ -359,6 +368,7 @@ else()
             set(LIBHWLOC_LIBRARY_DIRS ${hwloc_targ_BINARY_DIR}/lib)
             set(LIBHWLOC_INCLUDE_DIRS ${hwloc_targ_BINARY_DIR}/include)
             set(LIBHWLOC_LIBRARIES ${hwloc_targ_BINARY_DIR}/lib/libhwloc.a)
+            set(LIBHWLOC_FOUND TRUE)
         endif()
     endif() # UMF_LINK_HWLOC_STATICALLY
 
@@ -387,58 +397,116 @@ 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.21.9)
 
-    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()
+            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)
+        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
@@ -564,6 +632,23 @@ if(CMAKE_GENERATOR MATCHES "Visual Studio" OR CMAKE_GENERATOR MATCHES
     set(CMAKE_UMF_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin/$<CONFIG>)
 endif()
 
+# Valgrind
+if(UMF_USE_VALGRIND)
+    if(UMF_USE_ASAN
+       OR UMF_USE_TSAN
+       OR UMF_USE_UBSAN
+       OR UMF_USE_MSAN)
+        message(FATAL_ERROR "Cannot use valgrind and sanitizers together")
+    endif()
+
+    if(PkgConfig_FOUND)
+        pkg_check_modules(VALGRIND valgrind)
+    endif()
+    if(NOT VALGRIND_FOUND)
+        find_package(VALGRIND REQUIRED valgrind)
+    endif()
+endif()
+
 # Sanitizer flags
 if(UMF_USE_ASAN)
     add_sanitizer_flag(address)
@@ -579,12 +664,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 +722,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)
@@ -685,18 +791,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)
@@ -876,12 +970,11 @@ if(UMF_FORMAT_CODE_STYLE)
             COMMENT "Format C/C++, CMake, and Python files")
         message(
             STATUS
-                "  Adding convenience targets 'format-check' and 'format-apply'."
-        )
+                "Adding convenience targets 'format-check' and 'format-apply'.")
     else()
         message(
             STATUS
-                "  Convenience targets 'format-check' and 'format-apply' are "
+                "Convenience targets 'format-check' and 'format-apply' are "
                 "not available. Use commands specific for found tools (see the log above)."
         )
     endif()
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 6a050c0ae..cb2f9de1f 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 a7b613774..c12e01f37 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,18 @@
+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 00d6136df..cc8d9f06a 100644
--- a/README.md
+++ b/README.md
@@ -18,10 +18,7 @@ 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.
 
 ## Build
 
@@ -75,7 +72,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 +94,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,7 +122,7 @@ 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_FORMAT_CODE_STYLE | Add clang, cmake, and black -format-check and -format-apply targets to make | ON/OFF | OFF |
diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
index d52fc0857..9b46ed6ea 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -60,8 +60,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 +89,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 +98,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 +120,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 f57c0d5ae..d4375fe9d 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 a960d89bc..201c9e382 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 cfc9982d2..74551b20e 100644
--- a/benchmark/benchmark_umf.hpp
+++ b/benchmark/benchmark_umf.hpp
@@ -11,8 +11,6 @@
 #include <benchmark/benchmark.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 +28,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 +40,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", provider,
+                   NULL, 0);
+    }
+
+    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", provider,
+                      &arg, sizeof(arg));
+        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 +72,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 +86,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 +98,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 +126,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 +145,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 +158,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 +190,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 +202,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 +214,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;
         }
@@ -207,7 +246,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 +255,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 +265,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 +317,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(
+            &params_fixed, (void *)0x1, 0x1); // 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 +470,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 d00ffba90..fac2d063a 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 5e4e2eead..cfc59b5ad 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 2dab1f383..524191dca 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 2efd072d4..f9d1dfe38 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 8c23f481c..e0445cfa4 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 6536e8c4a..c1a098a79 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 000000000..d87e546c2
--- /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 02aaf5c71..8fea0a743 100644
--- a/cmake/helpers.cmake
+++ b/cmake/helpers.cmake
@@ -225,7 +225,8 @@ endfunction()
 
 function(add_umf_target_compile_options name)
     check_add_target_compile_options(${name} "-Wno-covered-switch-default")
-
+    target_compile_definitions(${name}
+                               PRIVATE ${UMF_COMMON_COMPILE_DEFINITIONS})
     if(NOT MSVC)
         target_compile_options(
             ${name}
@@ -260,6 +261,10 @@ function(add_umf_target_compile_options name)
                                                        -g -O0)
             endif()
         endif()
+        if(UMF_USE_VALGRIND)
+            target_compile_definitions(${name} PRIVATE "UMF_VG_ENABLED=1")
+            target_include_directories(${name} PRIVATE ${VALGRIND_INCLUDE_DIRS})
+        endif()
     elseif(MSVC)
         target_compile_options(
             ${name}
@@ -386,6 +391,7 @@ function(add_umf_library)
     target_include_directories(
         ${ARG_NAME}
         PRIVATE ${UMF_CMAKE_SOURCE_DIR}/include
+                ${UMF_CMAKE_SOURCE_DIR}/src
                 ${UMF_CMAKE_SOURCE_DIR}/src/utils
                 ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc
                 ${UMF_CMAKE_SOURCE_DIR}/src/coarse)
diff --git a/docs/config/Doxyfile b/docs/config/Doxyfile
index 630946374..9c520d46c 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/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 8bb352787..91f47901c 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
diff --git a/examples/basic/basic.c b/examples/basic/basic.c
index 846e71eda..41e48c6f6 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;
diff --git a/examples/cmake/FindCUDA.cmake b/examples/cmake/FindCUDA.cmake
index 5e4e2eead..d41ddaf77 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 e6db190d4..6cd1ffede 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 aa7620bc2..0bef8be3e 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 8c23f481c..4cf40b60d 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 12bdc1823..6012c07b9 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 6536e8c4a..fea1b7a8c 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 000000000..566345de0
--- /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/cuda_shared_memory/CMakeLists.txt b/examples/cuda_shared_memory/CMakeLists.txt
index 0e57ec607..d6aa60dad 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 50c8f9240..883297edb 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 a442fca6a..dbf1bb092 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
@@ -224,7 +225,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 +292,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;
diff --git a/examples/dram_and_fsdax/dram_and_fsdax.c b/examples/dram_and_fsdax/dram_and_fsdax.c
index 970242e10..80c7ecc03 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;
diff --git a/examples/ipc_level_zero/CMakeLists.txt b/examples/ipc_level_zero/CMakeLists.txt
index 2aa391d65..726ced3f1 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 87dbbd022..a7901cb09 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"
 
diff --git a/examples/level_zero_shared_memory/CMakeLists.txt b/examples/level_zero_shared_memory/CMakeLists.txt
index b7c990145..3fd8da5ab 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 7cfe89366..605f239f8 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_numa/memspace_numa.c b/examples/memspace_numa/memspace_numa.c
index 4f225cd69..b0e399fb2 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/mempolicy.h>
+#include <umf/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/base.h b/include/umf/base.h
index 12e99aa2b..ab306870c 100644
--- a/include/umf/base.h
+++ b/include/umf/base.h
@@ -51,6 +51,46 @@ typedef enum umf_result_t {
     UMF_RESULT_ERROR_UNKNOWN = 0x7ffffffe  ///< Unknown error
 } umf_result_t;
 
+/// @brief Type of the CTL query
+typedef enum umf_ctl_query_type {
+    CTL_QUERY_READ,
+    CTL_QUERY_WRITE,
+    CTL_QUERY_RUNNABLE,
+    CTL_QUERY_SUBTREE,
+
+    MAX_CTL_QUERY_TYPE
+} umf_ctl_query_type_t;
+
+///
+/// @brief Get value of a specified attribute at the given name.
+/// @param name name of an attribute to be retrieved
+/// @param ctx pointer to the pool or the provider
+/// @param arg [out] pointer to the variable where the value will be stored
+/// @param size size of the value, depends on the context
+/// @return UMF_RESULT_SUCCESS on success or UMF_RESULT_ERROR_UNKNOWN on failure.
+///
+umf_result_t umfCtlGet(const char *name, void *ctx, void *arg, size_t size);
+
+///
+/// @brief Set value of a specified attribute at the given name.
+/// @param name name of an attribute to be set
+/// @param ctx pointer to the pool or the provider, NULL for the 'default' path
+/// @param arg [in] pointer to the value that will be set
+/// @param size [in] size of the value, depends on the context
+/// @return UMF_RESULT_SUCCESS on success or UMF_RESULT_ERROR_UNKNOWN on failure.
+///
+umf_result_t umfCtlSet(const char *name, void *ctx, void *arg, size_t size);
+
+///
+/// @brief Execute callback related with the specified attribute.
+/// @param name name of an attribute to be executed
+/// @param ctx pointer to the pool or the provider
+/// @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
+/// @return UMF_RESULT_SUCCESS on success or UMF_RESULT_ERROR_UNKNOWN on failure.
+///
+umf_result_t umfCtlExec(const char *name, void *ctx, void *arg, size_t size);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/umf/memory_pool.h b/include/umf/memory_pool.h
index ed3d1eb0d..c9b02214e 100644
--- a/include/umf/memory_pool.h
+++ b/include/umf/memory_pool.h
@@ -51,15 +51,16 @@ typedef uint32_t umf_pool_create_flags_t;
 /// @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
@@ -106,7 +107,7 @@ void *umfPoolRealloc(umf_memory_pool_handle_t hPool, void *ptr, size_t size);
 /// @param ptr pointer to the allocated memory
 /// @return size of the memory block allocated from the \p hPool
 ///
-size_t umfPoolMallocUsableSize(umf_memory_pool_handle_t hPool, void *ptr);
+size_t umfPoolMallocUsableSize(umf_memory_pool_handle_t hPool, const void *ptr);
 
 ///
 /// @brief Frees the memory space of the specified \p hPool pointed by \p ptr
@@ -165,6 +166,14 @@ umf_memory_pool_handle_t umfPoolByPtr(const void *ptr);
 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
+/// @return pointer to a string containing the name of the \p pool
+///         or NULL if the pool doesn't support retrieving its name.
+///
+const char *umfPoolGetName(umf_memory_pool_handle_t pool);
+
 ///
 /// @brief Set a custom tag on the memory pool that can be later retrieved using umfPoolGetTag.
 /// @param hPool specified memory pool
diff --git a/include/umf/memory_pool_ops.h b/include/umf/memory_pool_ops.h
index 657f40aea..7b03ec8d2 100644
--- a/include/umf/memory_pool_ops.h
+++ b/include/umf/memory_pool_ops.h
@@ -20,7 +20,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(0, 12)
 
 ///
 /// @brief This structure comprises function pointers used by corresponding umfPool*
@@ -42,13 +42,14 @@ typedef struct umf_memory_pool_ops_t {
     /// @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
@@ -94,7 +95,7 @@ typedef struct umf_memory_pool_ops_t {
     /// @param ptr pointer to the allocated memory
     /// @return size of the memory block allocated from the \p pool
     ///
-    size_t (*malloc_usable_size)(void *pool, void *ptr);
+    size_t (*malloc_usable_size)(void *pool, const void *ptr);
 
     ///
     /// @brief Frees the memory space of the specified \p pool pointed by \p ptr
@@ -125,6 +126,41 @@ 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);
+
+    ///
+    /// Following functions, with ext prefix, are optional and memory pool implementation
+    /// can keep them 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 operationType type of the operation to be performed.
+    /// @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.
+    ///
+    /// @return umf_result_t result of the control operation.
+    ///
+    umf_result_t (*ext_ctl)(void *hPool, int operationType, const char *name,
+                            void *arg, size_t size,
+                            umf_ctl_query_type_t queryType);
+
+    ///
+    /// @brief Retrieves the name of the memory pool
+    /// @param pool valid pointer to the memory pool or NULL value
+    /// \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.
+    /// @return A constant character string representing the pool's name.
+    ///
+    const char *(*ext_get_name)(void *pool);
 } umf_memory_pool_ops_t;
 
 #ifdef __cplusplus
diff --git a/include/umf/memory_provider.h b/include/umf/memory_provider.h
index cff6f9eec..b9fbb28c9 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
@@ -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
@@ -125,7 +126,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
diff --git a/include/umf/memory_provider_ops.h b/include/umf/memory_provider_ops.h
index aaddd503b..8f383235c 100644
--- a/include/umf/memory_provider_ops.h
+++ b/include/umf/memory_provider_ops.h
@@ -19,127 +19,7 @@ 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)
-
-///
-/// @brief This structure comprises optional function pointers used
-/// by corresponding umfMemoryProvider* calls. A memory provider implementation
-/// can keep them NULL.
-///
-typedef struct umf_memory_provider_ext_ops_t {
-    ///
-    /// @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.
-    /// @param provider pointer to the memory provider
-    /// @param ptr beginning of the virtual memory range
-    /// @param size size of the virtual memory range
-    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
-    ///         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);
-
-    ///
-    /// @brief Discard physical pages within the virtual memory mapping associated at the given addr and \p size.
-    ///        This call is synchronous and if it succeeds, pages are guaranteed to be zero-filled on the next access.
-    /// @param provider pointer to the memory provider
-    /// @param ptr beginning of the virtual memory range
-    /// @param size size of the virtual memory range
-    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure
-    ///         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);
-
-    ///
-    /// @brief Merges two coarse grain allocations into a single allocation that
-    ///        can be managed (freed) as a whole.
-    ///        allocation_split and allocation_merge should be both set or both NULL.
-    ///        allocation_merge should NOT be called concurrently with allocation_split()
-    ///        with the same pointer.
-    /// @param hProvider handle to the memory provider
-    /// @param lowPtr pointer to the first allocation
-    /// @param highPtr pointer to the second allocation (should be > lowPtr)
-    /// @param totalSize size of a new merged allocation. Should be equal
-    ///        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);
-
-    ///
-    /// @brief Splits a coarse grain allocation into 2 adjacent allocations that
-    ///        can be managed (freed) separately.
-    ///        allocation_split and allocation_merge should be both set or both NULL.
-    ///        allocation_split should NOT be called concurrently with allocation_merge()
-    ///        with the same pointer.
-    /// @param hProvider handle to the memory provider
-    /// @param ptr pointer to the beginning of the allocation
-    /// @param totalSize total size of the allocation to be split
-    /// @param firstSize size of the first new allocation, second allocation
-    //         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 {
-    ///
-    /// @brief Retrieve the size of opaque data structure required to store IPC data.
-    /// @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);
-
-    ///
-    /// @brief Retrieve an IPC memory handle for the specified allocation.
-    /// @param provider pointer to the memory provider.
-    /// @param ptr beginning of the virtual memory range.
-    /// @param size size of the memory address range.
-    /// @param providerIpcData [out] pointer to the preallocated opaque data structure to store IPC handle.
-    /// @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);
-
-    ///
-    /// @brief Release IPC handle retrieved with get_ipc_handle function.
-    /// @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);
-
-    ///
-    /// @brief Open IPC handle.
-    /// @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);
-
-    ///
-    /// @brief Closes an IPC memory handle.
-    /// @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;
+#define UMF_PROVIDER_OPS_VERSION_CURRENT UMF_MAKE_VERSION(0, 12)
 
 ///
 /// @brief This structure comprises function pointers used by corresponding
@@ -157,13 +37,14 @@ typedef struct umf_memory_provider_ops_t {
     /// @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 (*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.
     ///
-    void (*finalize)(void *provider);
+    umf_result_t (*finalize)(void *provider);
 
     ///
     /// @brief Allocates \p size bytes of uninitialized storage from memory \p provider
@@ -231,7 +112,7 @@ typedef struct umf_memory_provider_ops_t {
     /// @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,
+    umf_result_t (*get_min_page_size)(void *provider, const void *ptr,
                                       size_t *pageSize);
 
     ///
@@ -242,14 +123,152 @@ typedef struct umf_memory_provider_ops_t {
     const char *(*get_name)(void *provider);
 
     ///
-    /// @brief Optional ops
+    /// Following functions, with ext prefix, are optional and memory provider implementation
+    /// can keep them NULL.
     ///
-    umf_memory_provider_ext_ops_t ext;
 
     ///
-    /// @brief Optional IPC ops. The API allows sharing of memory objects across different processes.
+    /// @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.
+    /// @param provider pointer to the memory provider
+    /// @param ptr beginning of the virtual memory range
+    /// @param size size of the virtual memory range
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+    ///         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 (*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.
+    ///        This call is synchronous and if it succeeds, pages are guaranteed to be zero-filled on the next access.
+    /// @param provider pointer to the memory provider
+    /// @param ptr beginning of the virtual memory range
+    /// @param size size of the virtual memory range
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure
+    ///         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 (*ext_purge_force)(void *provider, void *ptr, size_t size);
+
+    ///
+    /// @brief Merges two coarse grain allocations into a single allocation that
+    ///        can be managed (freed) as a whole.
+    ///        allocation_split and allocation_merge should be both set or both NULL.
+    ///        allocation_merge should NOT be called concurrently with allocation_split()
+    ///        with the same pointer.
+    /// @param hProvider handle to the memory provider
+    /// @param lowPtr pointer to the first allocation
+    /// @param highPtr pointer to the second allocation (should be > lowPtr)
+    /// @param totalSize size of a new merged allocation. Should be equal
+    ///        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 (*ext_allocation_merge)(void *hProvider, void *lowPtr,
+                                         void *highPtr, size_t totalSize);
+
+    ///
+    /// @brief Splits a coarse grain allocation into 2 adjacent allocations that
+    ///        can be managed (freed) separately.
+    ///        allocation_split and allocation_merge should be both set or both NULL.
+    ///        allocation_split should NOT be called concurrently with allocation_merge()
+    ///        with the same pointer.
+    /// @param hProvider handle to the memory provider
+    /// @param ptr pointer to the beginning of the allocation
+    /// @param totalSize total size of the allocation to be split
+    /// @param firstSize size of the first new allocation, second allocation
+    //         has a size equal to totalSize - firstSize
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure
+    ///
+    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 (*ext_get_ipc_handle_size)(void *provider, size_t *size);
+
     ///
-    umf_memory_provider_ipc_ops_t ipc;
+    /// @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.
+    /// @param providerIpcData [out] pointer to the preallocated opaque data structure to store IPC handle.
+    /// @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 (*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 (*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 (*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 (*ext_close_ipc_handle)(void *provider, void *ptr,
+                                         size_t size);
+
+    ///
+    /// @brief Control operation for the memory provider.
+    ///        The function is used to perform various control operations
+    ///        on the memory provider.
+    ///
+    /// @param provider handle to the memory provider.
+    /// @param operationType type of the operation to be performed.
+    /// @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.
+    ///
+    /// @return umf_result_t result of the control operation.
+    ///
+    umf_result_t (*ext_ctl)(void *provider, int operationType, const char *name,
+                            void *arg, size_t size,
+                            umf_ctl_query_type_t queryType);
+
 } umf_memory_provider_ops_t;
 
 #ifdef __cplusplus
diff --git a/include/umf/memspace.h b/include/umf/memspace.h
index 85b6b3681..4b4597ef3 100644
--- a/include/umf/memspace.h
+++ b/include/umf/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
@@ -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/pools/pool_disjoint.h b/include/umf/pools/pool_disjoint.h
index a1558b85b..9f467d9a6 100644
--- a/include/umf/pools/pool_disjoint.h
+++ b/include/umf/pools/pool_disjoint.h
@@ -35,7 +35,8 @@ umfDisjointPoolSharedLimitsCreate(size_t MaxSize);
 
 /// @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.
@@ -106,7 +107,7 @@ 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
 }
diff --git a/include/umf/pools/pool_jemalloc.h b/include/umf/pools/pool_jemalloc.h
index 5974e6440..8d5b090d6 100644
--- a/include/umf/pools/pool_jemalloc.h
+++ b/include/umf/pools/pool_jemalloc.h
@@ -16,7 +16,34 @@ 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);
+
+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 c13cb3b22..df405e8d9 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 1915ad0b7..f93e8d38e 100644
--- a/include/umf/pools/pool_scalable.h
+++ b/include/umf/pools/pool_scalable.h
@@ -55,7 +55,7 @@ umfScalablePoolParamsSetKeepAllMemory(umf_scalable_pool_params_handle_t hParams,
 
 /// @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 95f2634fb..0c07e7482 100644
--- a/include/umf/providers/provider_cuda.h
+++ b/include/umf/providers/provider_cuda.h
@@ -61,7 +61,7 @@ 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);
+const umf_memory_provider_ops_t *umfCUDAMemoryProviderOps(void);
 
 #ifdef __cplusplus
 }
diff --git a/include/umf/providers/provider_devdax_memory.h b/include/umf/providers/provider_devdax_memory.h
index 0fb5218bc..91678ef7f 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
@@ -65,7 +65,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 f652e2cb8..fed5147cc 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
@@ -66,7 +66,7 @@ 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);
 
 #ifdef __cplusplus
 }
diff --git a/include/umf/providers/provider_fixed_memory.h b/include/umf/providers/provider_fixed_memory.h
index 2351faf31..00273d565 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
@@ -49,7 +49,7 @@ 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 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 b20fb40d5..895922b4c 100644
--- a/include/umf/providers/provider_level_zero.h
+++ b/include/umf/providers/provider_level_zero.h
@@ -91,7 +91,7 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(
     umf_level_zero_memory_provider_params_handle_t hParams,
     uint32_t deviceOrdinal);
 
-umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void);
+const umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void);
 
 #ifdef __cplusplus
 }
diff --git a/include/umf/providers/provider_os_memory.h b/include/umf/providers/provider_os_memory.h
index 90455cad1..17bea65b0 100644
--- a/include/umf/providers/provider_os_memory.h
+++ b/include/umf/providers/provider_os_memory.h
@@ -146,7 +146,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 000000000..1deb417bd
--- /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 a4d92cc08..4a6ecefc5 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 24beb1e0a..d11e04c4f 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -30,38 +30,16 @@ set(UMF_COMMON_COMPILE_DEFINITIONS
     ${UMF_COMMON_COMPILE_DEFINITIONS} UMF_VERSION=${UMF_VERSION}
     UMF_ALL_CMAKE_VARIABLES="${UMF_ALL_CMAKE_VARIABLES}")
 
-set(BA_SOURCES
-    ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_linear.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_global.c)
-
 add_subdirectory(utils)
+add_subdirectory(base_alloc)
 add_subdirectory(coarse)
 
-set(UMF_LIBS $<BUILD_INTERFACE:umf_utils> $<BUILD_INTERFACE:coarse>)
-
-set(CTL_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/ctl/ctl.c)
-
-if(LINUX)
-    set(BA_SOURCES ${BA_SOURCES}
-                   ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_linux.c)
-elseif(WINDOWS)
-    set(BA_SOURCES ${BA_SOURCES}
-                   ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_windows.c)
-elseif(MACOSX)
-    set(BA_SOURCES ${BA_SOURCES}
-                   ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_linux.c)
-endif()
-
-set(BA_SOURCES
-    ${BA_SOURCES}
-    PARENT_SCOPE)
+set(UMF_LIBS umf_utils umf_ba umf_coarse)
 
 set(HWLOC_DEPENDENT_SOURCES topology.c)
 
 set(UMF_SOURCES
-    ${BA_SOURCES}
-    ${CTL_SOURCES}
+    ctl/ctl.c
     libumf.c
     ipc.c
     ipc_cache.c
@@ -115,20 +93,22 @@ 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 +156,7 @@ target_include_directories(umf PRIVATE ${UMF_PRIVATE_INCLUDE_DIRS})
 target_link_directories(umf PRIVATE ${UMF_PRIVATE_LIBRARY_DIRS})
 target_compile_definitions(umf PRIVATE ${UMF_COMMON_COMPILE_DEFINITIONS})
 
-add_dependencies(umf coarse)
+add_dependencies(umf umf_ba umf_coarse umf_utils)
 
 if(UMF_LINK_HWLOC_STATICALLY)
     add_dependencies(umf ${UMF_HWLOC_NAME})
@@ -198,24 +178,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 +206,6 @@ target_include_directories(
 
 install(TARGETS umf EXPORT ${PROJECT_NAME}-targets)
 
-add_subdirectory(pool)
-
 if(UMF_PROXY_LIB_ENABLED)
     add_subdirectory(proxy_lib)
 endif()
diff --git a/src/base_alloc/CMakeLists.txt b/src/base_alloc/CMakeLists.txt
new file mode 100644
index 000000000..ed84cc9a5
--- /dev/null
+++ b/src/base_alloc/CMakeLists.txt
@@ -0,0 +1,28 @@
+# Copyright (C) 2025 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+include(${UMF_CMAKE_SOURCE_DIR}/cmake/helpers.cmake)
+
+set(UMF_BA_SOURCES_COMMON base_alloc_global.c base_alloc.c base_alloc_linear.c)
+set(UMF_BA_SOURCES_LINUX base_alloc_linux.c)
+set(UMF_BA_SOURCES_WINDOWS base_alloc_windows.c)
+
+if(LINUX OR MACOSX)
+    set(UMF_BA_SOURCES ${UMF_BA_SOURCES_COMMON} ${UMF_BA_SOURCES_LINUX})
+elseif(WINDOWS)
+    set(UMF_BA_SOURCES ${UMF_BA_SOURCES_COMMON} ${UMF_BA_SOURCES_WINDOWS})
+endif()
+
+add_umf_library(
+    NAME umf_ba
+    TYPE STATIC
+    SRCS ${UMF_BA_SOURCES}
+    LIBS umf_utils)
+
+target_include_directories(umf_ba
+                           PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc)
+
+if(NOT UMF_BUILD_SHARED_LIBRARY)
+    install(TARGETS umf_ba EXPORT ${PROJECT_NAME}-targets)
+endif()
diff --git a/src/base_alloc/base_alloc.c b/src/base_alloc/base_alloc.c
index 00e58078e..60126c9f0 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
@@ -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 ecec3367c..7cc8ae494 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);
 
@@ -233,7 +235,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;
     }
diff --git a/src/base_alloc/base_alloc_global.h b/src/base_alloc/base_alloc_global.h
index bd55d352f..4cec99725 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,7 +20,7 @@ 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);
 
 #ifdef __cplusplus
diff --git a/src/coarse/CMakeLists.txt b/src/coarse/CMakeLists.txt
index c211f9a7b..32465b4e4 100644
--- a/src/coarse/CMakeLists.txt
+++ b/src/coarse/CMakeLists.txt
@@ -4,23 +4,21 @@
 
 include(${UMF_CMAKE_SOURCE_DIR}/cmake/helpers.cmake)
 
-set(COARSE_SOURCES coarse.c ../ravl/ravl.c)
-
-if(UMF_BUILD_SHARED_LIBRARY AND (NOT WINDOWS))
-    set(COARSE_EXTRA_SRCS ${BA_SOURCES})
-    set(COARSE_EXTRA_LIBS $<BUILD_INTERFACE:umf_utils>)
-endif()
+set(UMF_COARSE_SOURCES coarse.c ${UMF_CMAKE_SOURCE_DIR}/src/ravl/ravl.c)
+set(UMF_COARSE_LIBS umf_utils umf_ba)
 
 add_umf_library(
-    NAME coarse
+    NAME umf_coarse
     TYPE STATIC
-    SRCS ${COARSE_SOURCES} ${COARSE_EXTRA_SRCS}
-    LIBS ${COARSE_EXTRA_LIBS})
+    SRCS ${UMF_COARSE_SOURCES}
+    LIBS ${UMF_COARSE_LIBS})
 
 target_include_directories(
-    coarse
-    PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
-            $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>
-            $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src/ravl>)
+    umf_coarse
+    PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/coarse
+            ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc
+            ${UMF_CMAKE_SOURCE_DIR}/src/ravl)
 
-add_library(${PROJECT_NAME}::coarse ALIAS coarse)
+if(NOT UMF_BUILD_SHARED_LIBRARY)
+    install(TARGETS umf_coarse EXPORT ${PROJECT_NAME}-targets)
+endif()
diff --git a/src/coarse/coarse.c b/src/coarse/coarse.c
index 19798466e..a161ea575 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 7db9dd3dc..47a6568c5 100644
--- a/src/critnib/critnib.c
+++ b/src/critnib/critnib.c
@@ -90,7 +90,7 @@
 #define SLNODES (1 << SLICE)
 
 typedef uintptr_t word;
-typedef unsigned char sh_t;
+typedef uint8_t sh_t;
 
 struct critnib_node {
     /*
@@ -116,10 +116,27 @@ 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;
+    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 +178,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 +196,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 +212,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++) {
@@ -225,6 +257,15 @@ void critnib_delete(struct critnib *c) {
 
     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 +307,19 @@ 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;
+
+    do {
+        utils_atomic_load_acquire_ptr((void **)&c->deleted_leaf,
+                                      (void **)&deleted_leaf);
+        utils_atomic_store_release_ptr(&k->value, deleted_leaf);
+    } while (!utils_compare_exchange_u64(
+        (uint64_t *)&c->deleted_leaf, (uint64_t *)&k->value, (uint64_t *)&k));
+}
+
 /*
  * internal: free_leaf -- free (to internal pool, not malloc) a leaf.
  *
@@ -277,21 +331,34 @@ 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);
+    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 c->deleted_leaf in critnib_release()
+            // when the reference count drops to 0.
+            utils_atomic_store_release_u8(&k->pending_deleted_leaf, 1);
+            return;
+        }
+    }
+
+    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;
+    do {
+        utils_atomic_load_acquire_ptr((void **)&c->deleted_leaf, (void **)&k);
+        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->value));
 
-    c->deleted_leaf = k->value;
     utils_annotate_memory_new(k, sizeof(*k));
 
     return k;
@@ -319,8 +386,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 == 1)
+        utils_atomic_store_release_u64(&k->ref_count, 1ULL);
+    } 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 +427,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 +460,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 +477,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 +489,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 +516,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 +524,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 +552,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 +579,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 +591,85 @@ 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;
+    utils_atomic_load_acquire_u64(&k->ref_count, &ref_count);
+
+    if (ref_count == 0) {
+        return -1;
+    }
+
+    /* decrement the reference count */
+    if (utils_atomic_decrement_u64(&k->ref_count) == 0) {
+        void *to_be_freed = NULL;
+        utils_atomic_load_acquire_ptr(&k->to_be_freed, &to_be_freed);
+        if (to_be_freed) {
+            utils_atomic_store_release_ptr(&k->to_be_freed, NULL);
+            c->cb_free_leaf(c->leaf_allocator, to_be_freed);
+        }
+        uint8_t pending_deleted_leaf;
+        utils_atomic_load_acquire_u8(&k->pending_deleted_leaf,
+                                     &pending_deleted_leaf);
+        if (pending_deleted_leaf) {
+            utils_atomic_store_release_u8(&k->pending_deleted_leaf, 0);
+            add_to_deleted_leaf_list(c, k);
+        }
+    }
+
+#ifndef NDEBUG
+    // check if the reference count is overflowed
+    utils_atomic_load_acquire_u64(&k->ref_count, &ref_count);
+    assert((ref_count & (1ULL << 63)) == 0);
+    assert(ref_count != (uint64_t)(0 - 1ULL));
+#endif
+
+    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;
+
+    do {
+        utils_atomic_load_acquire_u64(&k->ref_count, &expected);
+        if (expected == 0) {
+            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 +679,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 +710,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 +775,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 +795,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 +814,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 +850,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 +927,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 +975,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 +1024,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 +1039,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;
         }
@@ -792,9 +1068,13 @@ static int iter(struct critnib_node *__restrict n, word min, 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;
     }
diff --git a/src/critnib/critnib.h b/src/critnib/critnib.h
index e03780374..690d75fae 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,31 @@ 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);
+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 4db11ac21..e66df9937 100644
--- a/src/ctl/ctl.c
+++ b/src/ctl/ctl.c
@@ -24,6 +24,8 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <umf/base.h>
+
 #include "base_alloc/base_alloc_global.h"
 #include "utils/utils_common.h"
 #include "utlist.h"
@@ -34,8 +36,6 @@
 #include <stdio.h>
 #endif
 
-#define CTL_MAX_ENTRIES 100
-
 #define MAX_CONFIG_FILE_LEN (1 << 20) /* 1 megabyte */
 
 #define CTL_STRING_QUERY_SEPARATOR ";"
@@ -43,23 +43,9 @@
 #define CTL_QUERY_NODE_SEPARATOR "."
 #define CTL_VALUE_ARG_SEPARATOR ","
 
+/* GLOBAL TREE */
 static int ctl_global_first_free = 0;
-static struct ctl_node 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 umf_ctl_node_t CTL_NODE(global)[CTL_MAX_ENTRIES];
 
 void *Zalloc(size_t sz) {
     void *ptr = umf_ba_global_alloc(sz);
@@ -82,13 +68,18 @@ char *Strdup(const char *s) {
  * ctl_find_node -- (internal) searches for a matching entry point in the
  *    provided nodes
  *
+ * Name offset is used to return the offset of the name in the query string.
  * 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;
+static const umf_ctl_node_t *ctl_find_node(const umf_ctl_node_t *nodes,
+                                           const char *name,
+                                           umf_ctl_index_utlist_t *indexes,
+                                           size_t *name_offset) {
+    assert(nodes != NULL);
+    assert(name != NULL);
+    assert(name_offset != NULL);
+    const umf_ctl_node_t *n = NULL;
     char *sptr = NULL;
     char *parse_str = Strdup(name);
     if (parse_str == NULL) {
@@ -102,6 +93,12 @@ static const struct ctl_node *ctl_find_node(const struct ctl_node *nodes,
      * in the main ctl tree.
      */
     while (node_name != NULL) {
+        char *next_node = strtok_r(NULL, CTL_QUERY_NODE_SEPARATOR, &sptr);
+        *name_offset = node_name - parse_str;
+        if (n != NULL && n->type == CTL_NODE_SUBTREE) {
+            // if a subtree occurs, the subtree handler should be called
+            break;
+        }
         char *endptr;
         /*
          * Ignore errno from strtol: FreeBSD returns EINVAL if no
@@ -111,7 +108,7 @@ static const struct ctl_node *ctl_find_node(const struct ctl_node *nodes,
         int tmp_errno = errno;
         long index_value = strtol(node_name, &endptr, 0);
         errno = tmp_errno;
-        struct ctl_index_utlist *index_entry = NULL;
+        umf_ctl_index_utlist_t *index_entry = NULL;
         if (endptr != node_name) { /* a valid index */
             index_entry = umf_ba_global_alloc(sizeof(*index_entry));
             if (index_entry == NULL) {
@@ -125,9 +122,18 @@ static const struct ctl_node *ctl_find_node(const struct ctl_node *nodes,
             if (index_entry && n->type == CTL_NODE_INDEXED) {
                 break;
             } else if (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->name == NULL) {
             goto error;
         }
@@ -137,7 +143,7 @@ static const struct ctl_node *ctl_find_node(const struct ctl_node *nodes,
         }
 
         nodes = n->children;
-        node_name = strtok_r(NULL, CTL_QUERY_NODE_SEPARATOR, &sptr);
+        node_name = next_node;
     }
 
     umf_ba_global_free(parse_str);
@@ -152,11 +158,11 @@ static const struct ctl_node *ctl_find_node(const struct ctl_node *nodes,
  * 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) {
@@ -201,8 +207,8 @@ 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) {
     void *real_arg = NULL;
     switch (source) {
     case CTL_QUERY_CONFIG_INPUT:
@@ -222,9 +228,8 @@ 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
  */
-static void ctl_query_cleanup_real_args(const struct ctl_node *n,
-                                        void *real_arg,
-                                        enum ctl_query_source source) {
+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;
 
@@ -242,23 +247,38 @@ static void ctl_query_cleanup_real_args(const struct ctl_node *n,
 /*
  * 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) {
+static int 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,
+                               const char *extra_name,
+                               umf_ctl_query_type_t query_type) {
+    (void)query_type;
+    assert(n != NULL);
+    assert(n->cb[CTL_QUERY_READ] != NULL);
+    assert(MAX_CTL_QUERY_TYPE != query_type);
+
     if (arg == NULL) {
         errno = EINVAL;
         return -1;
     }
 
-    return n->cb[CTL_QUERY_READ](ctx, source, arg, indexes);
+    return n->cb[CTL_QUERY_READ](ctx, source, arg, size, indexes, extra_name,
+                                 MAX_CTL_QUERY_TYPE);
 }
 
 /*
  * 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 int 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,
+                                const char *extra_name,
+                                umf_ctl_query_type_t query_type) {
+    (void)query_type;
+    assert(n != NULL);
+    assert(n->cb[CTL_QUERY_WRITE] != NULL);
+    assert(MAX_CTL_QUERY_TYPE != query_type);
+
     if (arg == NULL) {
         errno = EINVAL;
         return -1;
@@ -269,7 +289,8 @@ static int ctl_exec_query_write(void *ctx, const struct ctl_node *n,
         return -1;
     }
 
-    int ret = n->cb[CTL_QUERY_WRITE](ctx, source, real_arg, indexes);
+    int ret = n->cb[CTL_QUERY_WRITE](ctx, source, real_arg, size, indexes,
+                                     extra_name, MAX_CTL_QUERY_TYPE);
     ctl_query_cleanup_real_args(n, real_arg, source);
 
     return ret;
@@ -278,26 +299,52 @@ 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 int 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,
+                                   const char *extra_name,
+                                   umf_ctl_query_type_t query_type) {
+    (void)query_type;
+    assert(n != NULL);
+    assert(n->cb[CTL_QUERY_RUNNABLE] != NULL);
+    assert(MAX_CTL_QUERY_TYPE != query_type);
+    return n->cb[CTL_QUERY_RUNNABLE](ctx, source, arg, size, indexes,
+                                     extra_name, MAX_CTL_QUERY_TYPE);
+}
+
+static int 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) {
+    assert(n != NULL);
+    assert(n->cb[CTL_QUERY_SUBTREE] != NULL);
+    assert(MAX_CTL_QUERY_TYPE != query_type);
+    return n->cb[CTL_QUERY_SUBTREE](ctx, source, arg, size, indexes, extra_name,
+                                    query_type);
 }
 
-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) = {
+typedef int (*umf_ctl_exec_query_t)(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);
+
+static umf_ctl_exec_query_t ctl_exec_query[MAX_CTL_QUERY_TYPE] = {
     ctl_exec_query_read,
     ctl_exec_query_write,
     ctl_exec_query_runnable,
+    ctl_exec_query_subtree,
 };
 
 /*
  * ctl_query -- (internal) parses the name and calls the appropriate methods
  *    from the ctl tree
  */
-int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
-              const char *name, enum ctl_query_type type, void *arg) {
+int ctl_query(struct ctl *ctl, void *ctx, umf_ctl_query_source_t source,
+              const char *name, umf_ctl_query_type_t type, void *arg,
+              size_t size) {
     if (name == NULL) {
         errno = EINVAL;
         return -1;
@@ -308,29 +355,35 @@ int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
      * easily retrieve the index values. The list is cleared once the ctl
      * query has been handled.
      */
-    struct ctl_index_utlist *indexes = NULL;
+    umf_ctl_index_utlist_t *indexes = NULL;
     indexes = Zalloc(sizeof(*indexes));
     if (!indexes) {
         return -1;
     }
 
     int ret = -1;
+    size_t name_offset = 0;
 
-    const struct ctl_node *n = ctl_find_node(CTL_NODE(global), name, indexes);
+    const umf_ctl_node_t *n =
+        ctl_find_node(CTL_NODE(global), name, indexes, &name_offset);
 
     if (n == NULL && ctl) {
         ctl_delete_indexes(indexes);
         indexes = NULL;
-        n = ctl_find_node(ctl->root, name, indexes);
+        n = ctl_find_node(ctl->root, name, indexes, &name_offset);
     }
 
-    if (n == NULL || n->type != CTL_NODE_LEAF || n->cb[type] == NULL) {
+    // 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) ||
+        n->cb[n->type == CTL_NODE_SUBTREE ? CTL_QUERY_SUBTREE : type] == NULL) {
         errno = EINVAL;
         goto out;
     }
 
-    ret = ctl_exec_query[type](ctx, n, source, arg, indexes);
-
+    ret =
+        ctl_exec_query[n->type == CTL_NODE_SUBTREE ? CTL_QUERY_SUBTREE : type](
+            ctx, n, source, arg, size, indexes, name + name_offset, type);
 out:
     ctl_delete_indexes(indexes);
 
@@ -341,10 +394,10 @@ int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
  * 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;
@@ -397,7 +450,7 @@ static int ctl_load_config(struct ctl *ctl, void *ctx, char *buf) {
         }
 
         r = ctl_query(ctl, ctx, CTL_QUERY_CONFIG_INPUT, name, CTL_QUERY_WRITE,
-                      value);
+                      value, 0);
 
         if (r < 0 && ctx != NULL) {
             return -1;
@@ -491,24 +544,6 @@ int ctl_load_config_from_file(struct ctl *ctl, void *ctx,
 }
 #endif
 
-/*
- * ctl_new -- allocates and initializes ctl data structures
- */
-struct ctl *ctl_new(void) {
-    struct ctl *c = Zalloc(sizeof(struct ctl));
-    if (c == NULL) {
-        return NULL;
-    }
-
-    c->first_free = 0;
-    return c;
-}
-
-/*
- * 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
  */
diff --git a/src/ctl/ctl.h b/src/ctl/ctl.h
index 9327b01af..59aa3c799 100644
--- a/src/ctl/ctl.h
+++ b/src/ctl/ctl.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2016-2024 Intel Corporation
+ * 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
@@ -21,19 +21,21 @@
 #include <errno.h>
 #include <stddef.h>
 
+#include <umf/memory_pool.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-struct ctl;
+#define CTL_MAX_ENTRIES 100
 
-struct ctl_index_utlist {
+typedef struct ctl_index_utlist {
     const char *name;
     long value;
     struct ctl_index_utlist *next;
-};
+} umf_ctl_index_utlist_t;
 
-enum ctl_query_source {
+typedef enum ctl_query_source {
     CTL_UNKNOWN_QUERY_SOURCE,
     /* query executed directly from the program */
     CTL_QUERY_PROGRAMMATIC,
@@ -41,24 +43,19 @@ enum ctl_query_source {
     CTL_QUERY_CONFIG_INPUT,
 
     MAX_CTL_QUERY_SOURCE
-};
+} umf_ctl_query_source_t;
 
-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);
+typedef int (*node_callback)(void *ctx, umf_ctl_query_source_t type, void *arg,
+                             size_t size, umf_ctl_index_utlist_t *indexes,
+                             const char *extra_name,
+                             umf_ctl_query_type_t query_type);
 
 enum ctl_node_type {
     CTL_NODE_UNKNOWN,
     CTL_NODE_NAMED,
     CTL_NODE_LEAF,
     CTL_NODE_INDEXED,
+    CTL_NODE_SUBTREE,
 
     MAX_CTL_NODE
 };
@@ -91,7 +88,7 @@ struct ctl_argument {
  * CTL Tree node structure, do not use directly. All the necessary functionality
  * is provided by the included macros.
  */
-struct ctl_node {
+typedef struct ctl_node {
     const char *name;
     enum ctl_node_type type;
 
@@ -99,10 +96,24 @@ struct ctl_node {
     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;
 };
 
-struct ctl *ctl_new(void);
-void ctl_delete(struct ctl *stats);
+void initialize_global_ctl(void);
 
 int ctl_load_config_from_string(struct ctl *ctl, void *ctx,
                                 const char *cfg_string);
@@ -138,8 +149,9 @@ int ctl_arg_string(const void *arg, void *dest, size_t dest_size);
 
 #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);
+int ctl_query(struct ctl *ctl, void *ctx, umf_ctl_query_source_t source,
+              const char *name, umf_ctl_query_type_t type, void *arg,
+              size_t size);
 
 /* Declaration of a new child node */
 #define CTL_CHILD(name, ...)                                                   \
@@ -161,6 +173,8 @@ int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
 
 #define CTL_RUNNABLE_HANDLER(name, ...) ctl_##__VA_ARGS__##_##name##_runnable
 
+#define CTL_SUBTREE_HANDLER(name, ...) ctl_##__VA_ARGS__##_##name##_subtree
+
 #define CTL_ARG(name) ctl_arg_##name
 
 /*
@@ -170,7 +184,8 @@ int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
 #define CTL_LEAF_RO(name, ...)                                                 \
     {                                                                          \
         CTL_STR(name), CTL_NODE_LEAF,                                          \
-            {CTL_READ_HANDLER(name, __VA_ARGS__), NULL, NULL}, NULL, NULL      \
+            {CTL_READ_HANDLER(name, __VA_ARGS__), NULL, NULL, NULL}, NULL,     \
+            NULL                                                               \
     }
 
 /*
@@ -180,7 +195,7 @@ int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
 #define CTL_LEAF_WO(name, ...)                                                 \
     {                                                                          \
         CTL_STR(name), CTL_NODE_LEAF,                                          \
-            {NULL, CTL_WRITE_HANDLER(name, __VA_ARGS__), NULL},                \
+            {NULL, CTL_WRITE_HANDLER(name, __VA_ARGS__), NULL, NULL},          \
             &CTL_ARG(name), NULL                                               \
     }
 
@@ -191,7 +206,22 @@ int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
 #define CTL_LEAF_RUNNABLE(name, ...)                                           \
     {                                                                          \
         CTL_STR(name), CTL_NODE_LEAF,                                          \
-            {NULL, NULL, CTL_RUNNABLE_HANDLER(name, __VA_ARGS__)}, NULL, NULL  \
+            {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                                                               \
+    }
+
+#define CTL_LEAF_SUBTREE2(name, fun, ...)                                      \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_SUBTREE,                                       \
+            {NULL, NULL, NULL, CTL_SUBTREE_HANDLER(fun, __VA_ARGS__)}, NULL,   \
+            NULL                                                               \
     }
 
 /*
@@ -201,7 +231,7 @@ int ctl_query(struct ctl *ctl, void *ctx, enum ctl_query_source source,
 #define CTL_LEAF_RW(name)                                                      \
     {                                                                          \
         CTL_STR(name), CTL_NODE_LEAF,                                          \
-            {CTL_READ_HANDLER(name), CTL_WRITE_HANDLER(name), NULL},           \
+            {CTL_READ_HANDLER(name), CTL_WRITE_HANDLER(name), NULL, NULL},     \
             &CTL_ARG(name), NULL                                               \
     }
 
diff --git a/src/libumf.c b/src/libumf.c
index e357b2583..46c264016 100644
--- a/src/libumf.c
+++ b/src/libumf.c
@@ -8,9 +8,11 @@
  */
 
 #include <stddef.h>
+#include <string.h>
 
 #include "base_alloc_global.h"
 #include "ipc_cache.h"
+#include "memory_provider_internal.h"
 #include "memspace_internal.h"
 #include "pool/pool_scalable_internal.h"
 #include "provider_cuda_internal.h"
@@ -26,6 +28,11 @@ umf_memory_tracker_handle_t TRACKER = NULL;
 
 static uint64_t umfRefCount = 0;
 
+static umf_ctl_node_t CTL_NODE(umf)[] = {CTL_CHILD(provider), CTL_CHILD(pool),
+                                         CTL_NODE_END};
+
+void initialize_global_ctl(void) { CTL_REGISTER_MODULE(NULL, umf); }
+
 int umfInit(void) {
     if (utils_fetch_and_add_u64(&umfRefCount, 1) == 0) {
         utils_log_init();
@@ -44,6 +51,7 @@ int umfInit(void) {
         }
 
         LOG_DEBUG("UMF IPC cache initialized");
+        initialize_global_ctl();
     }
 
     if (TRACKER) {
@@ -90,3 +98,42 @@ void umfTearDown(void) {
 }
 
 int umfGetCurrentVersion(void) { return UMF_VERSION_CURRENT; }
+
+umf_result_t umfCtlGet(const char *name, void *ctx, void *arg, size_t size) {
+    // ctx can be NULL when getting defaults
+    if (name == NULL || arg == NULL || size == 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    return ctl_query(NULL, ctx, CTL_QUERY_PROGRAMMATIC, name, CTL_QUERY_READ,
+                     arg, size);
+}
+
+umf_result_t umfCtlSet(const char *name, void *ctx, void *arg, size_t size) {
+    // ctx can be NULL when setting defaults
+    if (name == NULL || arg == NULL || size == 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    return ctl_query(NULL, ctx, CTL_QUERY_PROGRAMMATIC, name, CTL_QUERY_WRITE,
+                     arg, size)
+               ? UMF_RESULT_ERROR_UNKNOWN
+               : UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfCtlExec(const char *name, void *ctx, void *arg, size_t size) {
+    // arg can be NULL when executing a command
+    // ctx can be NULL when executing defaults
+    // size can depends on the arg
+    if (name == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if ((arg == NULL && size != 0) || (arg != NULL && size == 0)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    return ctl_query(NULL, ctx, CTL_QUERY_PROGRAMMATIC, name,
+                     CTL_QUERY_RUNNABLE, arg, size)
+               ? UMF_RESULT_ERROR_UNKNOWN
+               : UMF_RESULT_SUCCESS;
+}
diff --git a/src/libumf.def b/src/libumf.def
index ce8820a8f..10b0326b8 100644
--- a/src/libumf.def
+++ b/src/libumf.def
@@ -6,7 +6,7 @@
 
 LIBRARY UMF
 
-VERSION 0.11
+VERSION 0.12
 
 EXPORTS
     DllMain
@@ -60,7 +60,6 @@ EXPORTS
     umfMemoryProviderPurgeForce
     umfMemoryProviderPurgeLazy
     umfMemoryProviderPutIPCHandle
-    umfMemoryTrackerGetAllocInfo
     umfMempolicyCreate
     umfMempolicyDestroy
     umfMempolicySetCustomSplitPartitions
@@ -134,5 +133,14 @@ EXPORTS
     umfFixedMemoryProviderOps
     umfFixedMemoryProviderParamsCreate
     umfFixedMemoryProviderParamsDestroy
+    umfFixedMemoryProviderParamsSetMemory
     umfLevelZeroMemoryProviderParamsSetFreePolicy
     umfLevelZeroMemoryProviderParamsSetDeviceOrdinal
+; Added in UMF_0.12
+    umfCtlExec
+    umfCtlGet
+    umfCtlSet
+    umfJemallocPoolParamsCreate
+    umfJemallocPoolParamsDestroy
+    umfJemallocPoolParamsSetNumArenas
+    umfPoolGetName
diff --git a/src/libumf.map b/src/libumf.map
index 6582fd0f8..e283c3853 100644
--- a/src/libumf.map
+++ b/src/libumf.map
@@ -54,7 +54,6 @@ UMF_0.10 {
         umfMemoryProviderPurgeForce;
         umfMemoryProviderPurgeLazy;
         umfMemoryProviderPutIPCHandle;
-        umfMemoryTrackerGetAllocInfo;
         umfMempolicyCreate;
         umfMempolicyDestroy;
         umfMempolicySetCustomSplitPartitions;
@@ -132,6 +131,17 @@ UMF_0.11 {
         umfFixedMemoryProviderOps;
         umfFixedMemoryProviderParamsCreate;
         umfFixedMemoryProviderParamsDestroy;
+        umfFixedMemoryProviderParamsSetMemory;
         umfLevelZeroMemoryProviderParamsSetFreePolicy;
         umfLevelZeroMemoryProviderParamsSetDeviceOrdinal;
 } UMF_0.10;
+
+UMF_0.12 {
+        umfCtlExec;
+        umfCtlGet;
+        umfCtlSet;
+        umfJemallocPoolParamsCreate;
+        umfJemallocPoolParamsDestroy;
+        umfJemallocPoolParamsSetNumArenas;
+        umfPoolGetName;
+} UMF_0.11;
diff --git a/src/memory_pool.c b/src/memory_pool.c
index eb0054522..ad5182236 100644
--- a/src/memory_pool.c
+++ b/src/memory_pool.c
@@ -7,43 +7,181 @@
  *
  */
 
-#include "libumf.h"
-#include "memory_pool_internal.h"
-#include "utils_assert.h"
-
+#include <umf/base.h>
 #include <umf/memory_pool.h>
 #include <umf/memory_pool_ops.h>
 
 #include <assert.h>
-#include <stdlib.h>
+#include <string.h>
 
 #include "base_alloc_global.h"
+#include "ctl/ctl.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"
+
+#define UMF_DEFAULT_SIZE 100
+#define UMF_DEFAULT_LEN 100
+
+utils_mutex_t ctl_mtx;
+static UTIL_ONCE_FLAG mem_pool_ctl_initialized = UTIL_ONCE_FLAG_INIT;
+
+char CTL_DEFAULT_ENTRIES[UMF_DEFAULT_SIZE][UMF_DEFAULT_LEN] = {0};
+char CTL_DEFAULT_VALUES[UMF_DEFAULT_SIZE][UMF_DEFAULT_LEN] = {0};
+
+static struct ctl umf_pool_ctl_root;
+
+static void ctl_init(void);
+
+static int CTL_SUBTREE_HANDLER(by_handle_pool)(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) {
+    (void)indexes, (void)source;
+    umf_memory_pool_handle_t hPool = (umf_memory_pool_handle_t)ctx;
+    int ret = ctl_query(&umf_pool_ctl_root, hPool, source, extra_name,
+                        queryType, arg, size);
+    if (ret == -1 &&
+        errno == EINVAL) { // node was not found in pool_ctl_root, try to
+                           // query the specific pool directly
+        hPool->ops.ext_ctl(hPool->pool_priv, source, extra_name, arg, size,
+                           queryType);
+    }
+
+    return 0;
+}
+
+static int 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) {
+    (void)indexes, (void)source, (void)ctx;
+    utils_init_once(&mem_pool_ctl_initialized, ctl_init);
+    utils_mutex_lock(&ctl_mtx);
+
+    if (queryType == CTL_QUERY_WRITE) {
+        int i = 0;
+        for (; i < UMF_DEFAULT_SIZE; i++) {
+            if (CTL_DEFAULT_ENTRIES[i][0] == '\0' ||
+                strcmp(CTL_DEFAULT_ENTRIES[i], extra_name) == 0) {
+                strncpy(CTL_DEFAULT_ENTRIES[i], extra_name, UMF_DEFAULT_LEN);
+                CTL_DEFAULT_ENTRIES[i][UMF_DEFAULT_LEN - 1] = '\0';
+                strncpy(CTL_DEFAULT_VALUES[i], arg, UMF_DEFAULT_LEN);
+                CTL_DEFAULT_VALUES[i][UMF_DEFAULT_LEN - 1] = '\0';
+                break;
+            }
+        }
+        if (UMF_DEFAULT_SIZE == i) {
+            LOG_ERR("Default entries array is full");
+            utils_mutex_unlock(&ctl_mtx);
+            return UMF_RESULT_ERROR_OUT_OF_RESOURCES;
+        }
+    } else if (queryType == CTL_QUERY_READ) {
+        int i = 0;
+        for (; i < UMF_DEFAULT_SIZE; i++) {
+            if (strcmp(CTL_DEFAULT_ENTRIES[i], extra_name) == 0) {
+                strncpy(arg, CTL_DEFAULT_VALUES[i], size);
+                break;
+            }
+        }
+        if (UMF_DEFAULT_SIZE == i) {
+            LOG_WARN("Wrong path name: %s", extra_name);
+            utils_mutex_unlock(&ctl_mtx);
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+    }
+
+    utils_mutex_unlock(&ctl_mtx);
+
+    return 0;
+}
+
+static int CTL_READ_HANDLER(alloc_count)(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) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)size, (void)indexes, (void)extra_name, (void)query_type;
+
+    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};
+
+umf_ctl_node_t CTL_NODE(pool)[] = {CTL_LEAF_SUBTREE2(by_handle, by_handle_pool),
+                                   CTL_LEAF_SUBTREE(default), CTL_NODE_END};
+
+static void ctl_init(void) {
+    utils_mutex_init(&ctl_mtx);
+    CTL_REGISTER_MODULE(&umf_pool_ctl_root, stats);
+}
+
+static umf_result_t umfDefaultCtlPoolHandle(void *hPool, int operationType,
+                                            const char *name, void *arg,
+                                            size_t size,
+                                            umf_ctl_query_type_t queryType) {
+    (void)hPool;
+    (void)operationType;
+    (void)name;
+    (void)arg;
+    (void)size;
+    (void)queryType;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+// 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;
 
 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) {
         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;
+    // 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;
+
     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);
     }
 
+    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)) {
         // Wrap provider with memory tracking provider.
         ret = umfTrackingMemoryProviderCreate(provider, pool, &pool->provider);
@@ -54,9 +192,16 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
         pool->provider = provider;
     }
 
+    utils_init_once(&mem_pool_ctl_initialized, 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 == utils_mutex_init(&pool->lock)) {
         LOG_ERR("Failed to initialize mutex for pool");
@@ -69,6 +214,16 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
         goto err_pool_init;
     }
 
+    // Set default property "name" to pool if exists
+    for (int i = 0; i < UMF_DEFAULT_SIZE; i++) {
+        if (CTL_DEFAULT_ENTRIES[i][0] != '\0' &&
+            strstr(CTL_DEFAULT_ENTRIES[i], ops->ext_get_name(NULL))) {
+            ops->ext_ctl(pool->pool_priv, CTL_QUERY_PROGRAMMATIC,
+                         CTL_DEFAULT_ENTRIES[i], CTL_DEFAULT_VALUES[i],
+                         UMF_DEFAULT_LEN, CTL_QUERY_WRITE);
+        }
+    }
+
     *hPool = pool;
     LOG_INFO("Memory pool created: %p", (void *)pool);
     return UMF_RESULT_SUCCESS;
@@ -84,20 +239,30 @@ 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) {
+    if (umf_ba_global_is_destroyed()) {
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    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,6 +271,7 @@ 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) {
@@ -138,9 +304,17 @@ umf_result_t umfPoolGetMemoryProvider(umf_memory_pool_handle_t hPool,
     return UMF_RESULT_SUCCESS;
 }
 
+const char *umfPoolGetName(umf_memory_pool_handle_t pool) {
+    UMF_CHECK((pool != NULL), NULL);
+    if (pool->ops.ext_get_name == NULL) {
+        return NULL;
+    }
+    return pool->ops.ext_get_name(pool->pool_priv);
+}
+
 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 +330,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) {
+size_t umfPoolMallocUsableSize(umf_memory_pool_handle_t hPool,
+                               const void *ptr) {
     UMF_CHECK((hPool != NULL), 0);
     return hPool->ops.malloc_usable_size(hPool->pool_priv, ptr);
 }
 
 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) {
diff --git a/src/memory_pool_internal.h b/src/memory_pool_internal.h
index ab3378163..ad05464dd 100644
--- a/src/memory_pool_internal.h
+++ b/src/memory_pool_internal.h
@@ -24,9 +24,12 @@ extern "C" {
 #include "base_alloc.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,6 +37,11 @@ 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;
 
 #ifdef __cplusplus
diff --git a/src/memory_provider.c b/src/memory_provider.c
index ce6a10a20..c262ad80d 100644
--- a/src/memory_provider.c
+++ b/src/memory_provider.c
@@ -18,8 +18,23 @@
 #include "base_alloc_global.h"
 #include "libumf.h"
 #include "memory_provider_internal.h"
+#include "umf/base.h"
 #include "utils_assert.h"
 
+static int CTL_SUBTREE_HANDLER(by_handle_provider)(
+    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) {
+    (void)indexes, (void)source;
+    umf_memory_provider_handle_t hProvider = (umf_memory_provider_handle_t)ctx;
+    hProvider->ops.ext_ctl(hProvider->provider_priv, /*unused*/ 0, extra_name,
+                           arg, size, queryType);
+    return 0;
+}
+
+umf_ctl_node_t CTL_NODE(provider)[] = {
+    CTL_LEAF_SUBTREE2(by_handle, by_handle_provider), CTL_NODE_END};
+
 static umf_result_t umfDefaultPurgeLazy(void *provider, void *ptr,
                                         size_t size) {
     (void)provider;
@@ -93,69 +108,96 @@ static umf_result_t umfDefaultCloseIPCHandle(void *provider, void *ptr,
     return UMF_RESULT_ERROR_NOT_SUPPORTED;
 }
 
+static umf_result_t umfDefaultCtlHandle(void *provider, int operationType,
+                                        const char *name, void *arg,
+                                        size_t size,
+                                        umf_ctl_query_type_t queryType) {
+    (void)provider;
+    (void)operationType;
+    (void)name;
+    (void)arg;
+    (void)size;
+    (void)queryType;
+    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;
     }
 }
 
 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;
+    }
+    if (!ops->ext_ctl) {
+        ops->ext_ctl = umfDefaultCtlHandle;
     }
 }
 
-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;
-}
+#define CHECK_OP(ops, fn)                                                      \
+    if (!(ops)->fn) {                                                          \
+        LOG_ERR("missing function pointer: %s\n", #fn);                        \
+        return false;                                                          \
+    }
 
-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);
-}
+static bool validateOps(const umf_memory_provider_ops_t *ops) {
+    // 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;
+    }
 
-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);
-}
+    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;
+    }
 
-static bool validateOps(const umf_memory_provider_ops_t *ops) {
-    return validateOpsMandatory(ops) && validateOpsExt(&(ops->ext)) &&
-           validateOpsIpc(&(ops->ipc));
+    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)) {
@@ -193,11 +235,18 @@ umf_result_t umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops,
     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
@@ -252,7 +301,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) {
     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(
@@ -271,7 +320,7 @@ umf_result_t umfMemoryProviderPurgeLazy(umf_memory_provider_handle_t hProvider,
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     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;
 }
@@ -281,7 +330,7 @@ umf_result_t umfMemoryProviderPurgeForce(umf_memory_provider_handle_t hProvider,
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     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;
 }
@@ -300,7 +349,7 @@ 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(
+    umf_result_t res = hProvider->ops.ext_allocation_split(
         hProvider->provider_priv, ptr, totalSize, firstSize);
     checkErrorAndSetLastProvider(res, hProvider);
     return res;
@@ -318,7 +367,7 @@ 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(
+    umf_result_t res = hProvider->ops.ext_allocation_merge(
         hProvider->provider_priv, lowPtr, highPtr, totalSize);
     checkErrorAndSetLastProvider(res, hProvider);
     return res;
@@ -329,7 +378,7 @@ 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,
+    return hProvider->ops.ext_get_ipc_handle_size(hProvider->provider_priv,
                                                   size);
 }
 
@@ -340,7 +389,7 @@ umfMemoryProviderGetIPCHandle(umf_memory_provider_handle_t hProvider,
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     UMF_CHECK((ptr != NULL), 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,
+    return hProvider->ops.ext_get_ipc_handle(hProvider->provider_priv, ptr,
                                              size, providerIpcData);
 }
 
@@ -349,7 +398,7 @@ 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,
+    return hProvider->ops.ext_put_ipc_handle(hProvider->provider_priv,
                                              providerIpcData);
 }
 
@@ -359,7 +408,7 @@ 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,
+    return hProvider->ops.ext_open_ipc_handle(hProvider->provider_priv,
                                               providerIpcData, ptr);
 }
 
@@ -368,6 +417,6 @@ 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,
+    return hProvider->ops.ext_close_ipc_handle(hProvider->provider_priv, ptr,
                                                size);
 }
diff --git a/src/memory_provider_internal.h b/src/memory_provider_internal.h
index dd1111a23..4b4ec8b2d 100644
--- a/src/memory_provider_internal.h
+++ b/src/memory_provider_internal.h
@@ -14,18 +14,24 @@
 
 #include <umf/memory_provider.h>
 
+#include "ctl/ctl.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);
 
+extern umf_ctl_node_t CTL_NODE(provider)[];
+extern umf_ctl_node_t CTL_NODE(pool)[];
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/memspace.c b/src/memspace.c
index 1cd80e1fa..31b52e26f 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
@@ -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,
diff --git a/src/memspaces/memspace_highest_bandwidth.c b/src/memspaces/memspace_highest_bandwidth.c
index 93fede2cd..d0beb2bb6 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
@@ -102,10 +102,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);
+        }
     }
 }
 
diff --git a/src/memspaces/memspace_lowest_latency.c b/src/memspaces/memspace_lowest_latency.c
index 5ca369fee..a463dd41a 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
@@ -98,10 +98,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)
diff --git a/src/memtargets/memtarget_numa.c b/src/memtargets/memtarget_numa.c
index 88d8ac2a4..a0a1e592a 100644
--- a/src/memtargets/memtarget_numa.c
+++ b/src/memtargets/memtarget_numa.c
@@ -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/pool/CMakeLists.txt b/src/pool/CMakeLists.txt
deleted file mode 100644
index 22aeab783..000000000
--- a/src/pool/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-# Copyright (C) 2023-2025 Intel Corporation
-# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-if(UMF_BUILD_SHARED_LIBRARY)
-    set(POOL_EXTRA_SRCS ${BA_SOURCES})
-    set(POOL_EXTRA_LIBS $<BUILD_INTERFACE:umf_utils>)
-endif()
-
-set(POOL_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS})
diff --git a/src/pool/pool_disjoint.c b/src/pool/pool_disjoint.c
index ca4d2fab7..9885a6a68 100644
--- a/src/pool/pool_disjoint.c
+++ b/src/pool/pool_disjoint.c
@@ -12,11 +12,13 @@
 #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.h"
 #include "pool_disjoint_internal.h"
 #include "provider/provider_tracking.h"
 #include "uthash/utlist.h"
@@ -25,6 +27,62 @@
 #include "utils_log.h"
 #include "utils_math.h"
 
+static char *DEFAULT_NAME = "disjoint";
+
+/* Disjoint pool CTL implementation */
+struct ctl disjoint_ctl_root;
+static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT;
+
+static int CTL_READ_HANDLER(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) {
+    (void)source, (void)indexes, (void)queryType, (void)extra_name;
+    disjoint_pool_t *pool = (disjoint_pool_t *)ctx;
+
+    if (arg == NULL) {
+        return -1;
+    }
+
+    strncpy((char *)arg, pool->params.name, size);
+    return 0;
+}
+
+static const struct ctl_argument CTL_ARG(name) = CTL_ARG_STRING(255);
+
+static int CTL_WRITE_HANDLER(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) {
+    (void)source, (void)indexes, (void)queryType, (void)size, (void)extra_name;
+    disjoint_pool_t *pool = (disjoint_pool_t *)ctx;
+    if (arg == NULL) {
+        return -1;
+    }
+
+    strncpy(pool->params.name, (char *)arg, sizeof(pool->params.name) - 1);
+    return 0;
+}
+
+static const umf_ctl_node_t CTL_NODE(disjoint)[] = {CTL_LEAF_RW(name),
+                                                    CTL_NODE_END};
+
+static void initialize_disjoint_ctl(void) {
+    CTL_REGISTER_MODULE(&disjoint_ctl_root, disjoint);
+}
+
+umf_result_t disjoint_pool_ctl(void *hPool, int operationType, const char *name,
+                               void *arg, size_t size,
+                               umf_ctl_query_type_t queryType) {
+    (void)operationType;
+    utils_init_once(&ctl_initialized, initialize_disjoint_ctl);
+
+    return ctl_query(&disjoint_ctl_root, hPool, CTL_QUERY_PROGRAMMATIC, name,
+                     queryType, arg, size);
+}
+
 // 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 +198,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 +289,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,15 +626,26 @@ 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);
+    }
+}
+
 umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
-                                      void *params, void **ppPool) {
+                                      const void *params, void **ppPool) {
     // TODO set defaults when user pass the NULL as params
     if (!provider || !params || !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 = params;
 
     // min_bucket_size parameter must be a power of 2 for bucket sizes
     // to generate correctly.
@@ -598,7 +665,7 @@ umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
     disjoint_pool->provider = provider;
     disjoint_pool->params = *dp_params;
 
-    disjoint_pool->known_slabs = critnib_new();
+    disjoint_pool->known_slabs = critnib_new(free_slab, NULL);
     if (disjoint_pool->known_slabs == NULL) {
         goto err_free_disjoint_pool;
     }
@@ -793,7 +860,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,17 +868,22 @@ 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) {
+size_t disjoint_pool_malloc_usable_size(void *pool, const void *ptr) {
     disjoint_pool_t *disjoint_pool = (disjoint_pool_t *)pool;
     if (ptr == NULL) {
         return 0;
     }
 
     // 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
+        if (ref_slab) {
+            critnib_release(disjoint_pool->known_slabs, ref_slab);
+        }
+
         umf_alloc_info_t allocInfo = {NULL, 0, NULL};
         umf_result_t ret = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
         if (ret != UMF_RESULT_SUCCESS) {
@@ -820,6 +892,7 @@ size_t disjoint_pool_malloc_usable_size(void *pool, void *ptr) {
 
         return allocInfo.baseSize;
     }
+
     // 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 +900,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_t size = slab->bucket->size - diff;
+
+    assert(ref_slab);
+    critnib_release(disjoint_pool->known_slabs, ref_slab);
+
+    return size;
 }
 
 umf_result_t disjoint_pool_free(void *pool, void *ptr) {
@@ -837,12 +915,16 @@ 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
+        if (ref_slab) {
+            critnib_release(disjoint_pool->known_slabs, ref_slab);
+        }
+
         umf_alloc_info_t allocInfo = {NULL, 0, NULL};
         umf_result_t ret = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
         if (ret != UMF_RESULT_SUCCESS) {
@@ -885,6 +967,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 +995,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);
     }
@@ -922,11 +1007,24 @@ void disjoint_pool_finalize(void *pool) {
     }
 
     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;
+}
+
+const char *disjoint_pool_get_name(void *pool) {
+    disjoint_pool_t *hPool = (disjoint_pool_t *)pool;
+    if (pool == NULL) {
+        return DEFAULT_NAME;
+    }
+    return hPool->params.name;
 }
 
 static umf_memory_pool_ops_t UMF_DISJOINT_POOL_OPS = {
@@ -940,9 +1038,11 @@ 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,
+    .ext_get_name = disjoint_pool_get_name,
+    .ext_ctl = disjoint_pool_ctl,
 };
 
-umf_memory_pool_ops_t *umfDisjointPoolOps(void) {
+const umf_memory_pool_ops_t *umfDisjointPoolOps(void) {
     return &UMF_DISJOINT_POOL_OPS;
 }
 
@@ -958,15 +1058,14 @@ umfDisjointPoolSharedLimitsCreate(size_t max_size) {
     return ptr;
 }
 
-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;
@@ -987,11 +1086,11 @@ umfDisjointPoolParamsCreate(umf_disjoint_pool_params_handle_t *hParams) {
         .cur_pool_size = 0,
         .pool_trace = 0,
         .shared_limits = NULL,
-        .name = {*DEFAULT_NAME},
     };
 
-    *hParams = params;
+    strncpy(params->name, DEFAULT_NAME, sizeof(params->name) - 1);
 
+    *hParams = params;
     return UMF_RESULT_SUCCESS;
 }
 
diff --git a/src/pool/pool_jemalloc.c b/src/pool/pool_jemalloc.c
index 10e00dea5..8d6a2daf2 100644
--- a/src/pool/pool_jemalloc.c
+++ b/src/pool/pool_jemalloc.c
@@ -6,6 +6,7 @@
 */
 
 #include <assert.h>
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -22,7 +23,26 @@
 
 #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;
+}
 
 #else
 
@@ -30,9 +50,14 @@ umf_memory_pool_ops_t *umfJemallocPoolOps(void) { return NULL; }
 
 #define MALLOCX_ARENA_MAX (MALLCTL_ARENAS_ALL - 1)
 
+typedef struct umf_jemalloc_pool_params_t {
+    size_t n_arenas;
+} 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
+    size_t n_arenas;
+    unsigned int arena_index[];
 } jemalloc_memory_pool_t;
 
 static __TLS umf_result_t TLS_last_allocation_error;
@@ -47,6 +72,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
@@ -285,12 +318,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 +386,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 +407,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 =
@@ -381,71 +425,126 @@ static void *op_aligned_alloc(void *pool, size_t size, size_t alignment) {
 }
 
 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 n_arenas_set_from_params = 0;
     int err;
+    const umf_jemalloc_pool_params_t *jemalloc_params = params;
 
-    jemalloc_memory_pool_t *pool =
-        umf_ba_global_alloc(sizeof(jemalloc_memory_pool_t));
-    if (!pool) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    size_t n_arenas = 0;
+    if (jemalloc_params) {
+        n_arenas = jemalloc_params->n_arenas;
+        n_arenas_set_from_params = 1;
     }
 
-    pool->provider = provider;
-
-    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;
+    if (n_arenas == 0) {
+        n_arenas = utils_get_num_cores() * 4;
+        if (n_arenas > MALLOCX_ARENA_MAX) {
+            n_arenas = MALLOCX_ARENA_MAX;
+        }
     }
 
-    // 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 > MALLOCX_ARENA_MAX) {
+        LOG_ERR("Number of arenas %zu exceeds the limit (%i).", n_arenas,
+                MALLOCX_ARENA_MAX);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    pool->arena_index = arena_index;
-    pool_by_arena_index[arena_index] = pool;
+    jemalloc_memory_pool_t *pool = umf_ba_global_alloc(
+        sizeof(*pool) + n_arenas * sizeof(*pool->arena_index));
+    if (!pool) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
 
+    pool->provider = provider;
+    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;
+        }
+
+        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] = 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;
+        }
+    }
     *out_pool = (umf_memory_pool_handle_t)pool;
 
     VALGRIND_DO_CREATE_MEMPOOL(pool, 0, 0);
 
     return UMF_RESULT_SUCCESS;
 
-err_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 = pool->arena_index[i];
+        snprintf(cmd, sizeof(cmd), "arena.%u.destroy", arena);
+        (void)je_mallctl(cmd, NULL, 0, NULL, 0);
+    }
     umf_ba_global_free(pool);
     return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
 }
 
-static void op_finalize(void *pool) {
+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;
+        }
+    }
     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 size_t op_malloc_usable_size(void *pool, const void *ptr) {
     (void)pool; // not used
-    return je_malloc_usable_size(ptr);
+    // Remove the 'const' qualifier because the je_malloc_usable_size
+    // function requires a non-const pointer.
+    return je_malloc_usable_size((void *)ptr);
 }
 
 static umf_result_t op_get_last_allocation_error(void *pool) {
@@ -466,7 +565,36 @@ static umf_memory_pool_ops_t UMF_JEMALLOC_POOL_OPS = {
     .get_last_allocation_error = op_get_last_allocation_error,
 };
 
-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));
+    *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;
+}
+
 #endif /* UMF_POOL_JEMALLOC_ENABLED */
diff --git a/src/pool/pool_proxy.c b/src/pool/pool_proxy.c
index eedddb0ac..208b46d4c 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);
@@ -107,7 +110,7 @@ static umf_result_t proxy_free(void *pool, void *ptr) {
     return umfMemoryProviderFree(hPool->hProvider, ptr, size);
 }
 
-static size_t proxy_malloc_usable_size(void *pool, void *ptr) {
+static size_t proxy_malloc_usable_size(void *pool, const void *ptr) {
     assert(pool);
 
     (void)pool;
@@ -134,4 +137,6 @@ static umf_memory_pool_ops_t UMF_PROXY_POOL_OPS = {
     .free = proxy_free,
     .get_last_allocation_error = proxy_get_last_allocation_error};
 
-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 8a9fd88c1..fa63351c2 100644
--- a/src/pool/pool_scalable.c
+++ b/src/pool/pool_scalable.c
@@ -13,6 +13,8 @@
 #include <stdio.h>
 #include <string.h>
 
+#include <ctl/ctl.h>
+#include <memory_pool_internal.h>
 #include <umf/memory_pool.h>
 #include <umf/memory_pool_ops.h>
 #include <umf/memory_provider.h>
@@ -114,6 +116,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);
@@ -260,7 +266,7 @@ umfScalablePoolParamsSetKeepAllMemory(umf_scalable_pool_params_handle_t hParams,
 }
 
 static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
-                                        void *params, void **pool) {
+                                        const void *params, void **pool) {
     tbb_mem_pool_policy_t policy = {.pAlloc = tbb_raw_alloc_wrapper,
                                     .pFree = tbb_raw_free_wrapper,
                                     .granularity = DEFAULT_GRANULARITY,
@@ -270,8 +276,7 @@ static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
                                     .reserved = 0};
 
     if (params) {
-        umf_scalable_pool_params_handle_t scalable_params =
-            (umf_scalable_pool_params_handle_t)params;
+        const umf_scalable_pool_params_t *scalable_params = params;
         policy.granularity = scalable_params->granularity;
         policy.keep_all_memory = scalable_params->keep_all_memory;
     }
@@ -308,10 +313,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 +405,10 @@ 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 size_t tbb_malloc_usable_size(void *pool, const void *ptr) {
     tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
-    return tbb_callbacks.pool_msize(pool_data->tbb_pool, ptr);
+    // Remove the 'const' qualifier because the TBB pool_msize function requires a non-const pointer.
+    return tbb_callbacks.pool_msize(pool_data->tbb_pool, (void *)ptr);
 }
 
 static umf_result_t tbb_get_last_allocation_error(void *pool) {
@@ -405,6 +416,21 @@ static umf_result_t tbb_get_last_allocation_error(void *pool) {
     return TLS_last_allocation_error;
 }
 
+static umf_result_t pool_ctl(void *hPool, int operationType, const char *name,
+                             void *arg, size_t size,
+                             umf_ctl_query_type_t query_type) {
+    (void)operationType; // unused
+    umf_memory_pool_handle_t pool_provider = (umf_memory_pool_handle_t)hPool;
+    utils_init_once(&ctl_initialized, NULL);
+    return ctl_query(&pool_scallable_ctl_root, pool_provider->pool_priv,
+                     CTL_QUERY_PROGRAMMATIC, name, query_type, arg, size);
+}
+
+static const char *scalable_get_name(void *pool) {
+    (void)pool; // unused
+    return "scalable";
+}
+
 static umf_memory_pool_ops_t UMF_SCALABLE_POOL_OPS = {
     .version = UMF_POOL_OPS_VERSION_CURRENT,
     .initialize = tbb_pool_initialize,
@@ -415,8 +441,11 @@ 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,
+    .ext_get_name = scalable_get_name,
+};
 
-umf_memory_pool_ops_t *umfScalablePoolOps(void) {
+const umf_memory_pool_ops_t *umfScalablePoolOps(void) {
     return &UMF_SCALABLE_POOL_OPS;
 }
diff --git a/src/provider/provider_ctl_stats_impl.h b/src/provider/provider_ctl_stats_impl.h
new file mode 100644
index 000000000..565ed78b0
--- /dev/null
+++ b/src/provider/provider_ctl_stats_impl.h
@@ -0,0 +1,113 @@
+/*
+ * 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.h"
+#include "utils/utils_assert.h"
+
+static int CTL_READ_HANDLER(peak_memory)(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) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)size, (void)indexes, (void)extra_name, (void)query_type;
+
+    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 0;
+}
+
+static int CTL_READ_HANDLER(allocated_memory)(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) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)size, (void)indexes, (void)extra_name, (void)query_type;
+
+    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 0;
+}
+
+static int CTL_RUNNABLE_HANDLER(reset)(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) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)arg, (void)size, (void)extra_name,
+        (void)query_type;
+
+    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 0;
+}
+
+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_LEAF_RUNNABLE(reset), 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
diff --git a/src/provider/provider_ctl_stats_type.h b/src/provider/provider_ctl_stats_type.h
new file mode 100644
index 000000000..309b253b1
--- /dev/null
+++ b/src/provider/provider_ctl_stats_type.h
@@ -0,0 +1,25 @@
+/*
+ * 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
diff --git a/src/provider/provider_cuda.c b/src/provider/provider_cuda.c
index dd12d9184..9f0dc6d98 100644
--- a/src/provider/provider_cuda.c
+++ b/src/provider/provider_cuda.c
@@ -25,62 +25,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)
@@ -353,14 +298,13 @@ umf_result_t umfCUDAMemoryProviderParamsSetAllocFlags(
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t cu_memory_provider_initialize(void *params,
+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) {
@@ -425,8 +369,9 @@ static umf_result_t cu_memory_provider_initialize(void *params,
     return UMF_RESULT_SUCCESS;
 }
 
-static void cu_memory_provider_finalize(void *provider) {
+static umf_result_t cu_memory_provider_finalize(void *provider) {
     umf_ba_global_free(provider);
+    return UMF_RESULT_SUCCESS;
 }
 
 /*
@@ -613,7 +558,7 @@ static void cu_memory_provider_get_last_native_error(void *provider,
 }
 
 static umf_result_t cu_memory_provider_get_min_page_size(void *provider,
-                                                         void *ptr,
+                                                         const void *ptr,
                                                          size_t *pageSize) {
     (void)ptr;
 
@@ -744,20 +689,75 @@ 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,
 };
 
-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;
+}
+
+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_devdax_memory.c b/src/provider/provider_devdax_memory.c
index 8e8197190..fdd8ad9b9 100644
--- a/src/provider/provider_devdax_memory.c
+++ b/src/provider/provider_devdax_memory.c
@@ -21,7 +21,7 @@
 
 #if defined(_WIN32) || defined(UMF_NO_HWLOC)
 
-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;
@@ -128,7 +128,7 @@ static void devdax_store_last_native_error(int32_t native_error,
 }
 
 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 +148,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");
@@ -266,12 +265,19 @@ 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,
@@ -327,7 +333,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
 
@@ -418,7 +424,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 =
@@ -539,17 +545,17 @@ 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};
+
+const umf_memory_provider_ops_t *umfDevDaxMemoryProviderOps(void) {
     return &UMF_DEVDAX_MEMORY_PROVIDER_OPS;
 }
 
diff --git a/src/provider/provider_file_memory.c b/src/provider/provider_file_memory.c
index 12a923322..b4ff44f8a 100644
--- a/src/provider/provider_file_memory.c
+++ b/src/provider/provider_file_memory.c
@@ -22,7 +22,7 @@
 
 #if defined(_WIN32) || defined(UMF_NO_HWLOC)
 
-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;
@@ -153,7 +153,7 @@ static void file_store_last_native_error(int32_t native_error,
 }
 
 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 +185,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");
@@ -275,14 +274,14 @@ static umf_result_t file_initialize(void *params, void **provider) {
         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;
@@ -306,25 +305,32 @@ static umf_result_t file_initialize(void *params, void **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,
@@ -594,7 +600,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
 
@@ -645,7 +651,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 +699,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 +742,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 +752,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;
@@ -864,17 +872,17 @@ 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};
+
+const umf_memory_provider_ops_t *umfFileMemoryProviderOps(void) {
     return &UMF_FILE_MEMORY_PROVIDER_OPS;
 }
 
diff --git a/src/provider/provider_fixed_memory.c b/src/provider/provider_fixed_memory.c
index eeeb8b702..c30044946 100644
--- a/src/provider/provider_fixed_memory.c
+++ b/src/provider/provider_fixed_memory.c
@@ -20,6 +20,7 @@
 #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"
@@ -30,6 +31,7 @@ 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;
 } fixed_memory_provider_t;
 
 // Fixed Memory provider settings struct
@@ -52,6 +54,16 @@ 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 void initialize_fixed_ctl(void) {
+    CTL_REGISTER_MODULE(&fixed_memory_ctl_root, stats);
+}
+
 static const char *Native_error_str[] = {
     [_UMF_FIXED_RESULT_SUCCESS] = "success",
     [_UMF_FIXED_RESULT_ERROR_PURGE_FORCE_FAILED] = "force purging failed"};
@@ -81,15 +93,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));
@@ -142,10 +153,11 @@ static umf_result_t fixed_initialize(void *params, void **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,7 +165,14 @@ 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,
@@ -201,7 +220,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
 
@@ -250,7 +269,22 @@ 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_ctl(void *provider, int operationType,
+                              const char *name, void *arg, size_t size,
+                              umf_ctl_query_type_t query_type) {
+    utils_init_once(&ctl_initialized, initialize_fixed_ctl);
+    return ctl_query(&fixed_memory_ctl_root, provider, operationType, name,
+                     query_type, arg, size);
 }
 
 static umf_memory_provider_ops_t UMF_FIXED_MEMORY_PROVIDER_OPS = {
@@ -263,17 +297,18 @@ 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;
 }
 
diff --git a/src/provider/provider_level_zero.c b/src/provider/provider_level_zero.c
index af81e84bc..ca91ac2a0 100644
--- a/src/provider/provider_level_zero.c
+++ b/src/provider/provider_level_zero.c
@@ -27,89 +27,7 @@ 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"
@@ -211,11 +129,37 @@ 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) {
 #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
     // The Level Zero shared library should be already loaded by the user
     // of the Level Zero provider. UMF just want to reuse it
@@ -425,7 +369,7 @@ static umf_result_t ze_memory_provider_alloc(void *provider, size_t size,
     ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)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,
@@ -535,21 +479,21 @@ static umf_result_t query_min_page_size(ze_memory_provider_t *ze_provider,
     return ze2umf_result(ze_result);
 }
 
-static void ze_memory_provider_finalize(void *provider) {
+static umf_result_t ze_memory_provider_finalize(void *provider) {
     ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)provider;
     umf_ba_global_free(ze_provider->resident_device_handles);
 
     umf_ba_global_free(provider);
+    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");
@@ -585,7 +529,7 @@ static umf_result_t ze_memory_provider_initialize(void *params,
 
     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->min_page_size = 0;
@@ -652,7 +596,7 @@ static void ze_memory_provider_get_last_native_error(void *provider,
 }
 
 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;
 
@@ -853,19 +797,101 @@ 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,
 };
 
-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;
+}
+
+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;
+}
+
+#endif // !UMF_BUILD_LEVEL_ZERO_PROVIDER
diff --git a/src/provider/provider_os_memory.c b/src/provider/provider_os_memory.c
index f0cd3abae..7c5eed59d 100644
--- a/src/provider/provider_os_memory.c
+++ b/src/provider/provider_os_memory.c
@@ -6,21 +6,25 @@
 */
 
 #include <assert.h>
+#include <ctl/ctl.h>
 #include <errno.h>
 #include <limits.h>
+
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #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>
 
+#include "utils_assert.h"
 // OS Memory Provider requires HWLOC
 #if defined(UMF_NO_HWLOC)
 
-umf_memory_provider_ops_t *umfOsMemoryProviderOps(void) { return NULL; }
+const umf_memory_provider_ops_t *umfOsMemoryProviderOps(void) { return NULL; }
 
 umf_result_t umfOsMemoryProviderParamsCreate(
     umf_os_memory_provider_params_handle_t *hParams) {
@@ -98,6 +102,9 @@ umf_result_t umfOsMemoryProviderParamsSetPartitions(
 #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
@@ -166,6 +173,34 @@ 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 int CTL_READ_HANDLER(ipc_enabled)(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) {
+    /* suppress unused-parameter errors */
+    (void)source, (void)indexes, (void)ctx, (void)extra_name, (void)query_type,
+        (void)size;
+
+    int *arg_out = arg;
+    os_memory_provider_t *os_provider = (os_memory_provider_t *)ctx;
+    *arg_out = os_provider->IPC_enabled;
+    return 0;
+}
+
+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 +264,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 +322,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 +373,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;
 
@@ -407,7 +444,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 +471,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 +497,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 +538,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 +607,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) {
@@ -610,7 +648,7 @@ static umf_result_t os_initialize(void *params, void **provider) {
         goto err_destroy_hwloc_topology;
     }
 
-    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;
@@ -664,7 +702,7 @@ static umf_result_t os_initialize(void *params, void **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) {
@@ -684,6 +722,7 @@ static void os_finalize(void *provider) {
     }
     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 +1119,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 +1135,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,6 +1147,8 @@ 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;
 }
 
@@ -1155,7 +1197,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
 
@@ -1205,7 +1247,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 +1281,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 +1326,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;
@@ -1401,6 +1443,14 @@ static umf_result_t os_close_ipc_handle(void *provider, void *ptr,
     return UMF_RESULT_SUCCESS;
 }
 
+static umf_result_t os_ctl(void *hProvider, int operationType, const char *name,
+                           void *arg, size_t size,
+                           umf_ctl_query_type_t query_type) {
+    utils_init_once(&ctl_initialized, initialize_os_ctl);
+    return ctl_query(&os_memory_ctl_root, hProvider, operationType, name,
+                     query_type, arg, size);
+}
+
 static umf_memory_provider_ops_t UMF_OS_MEMORY_PROVIDER_OPS = {
     .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = os_initialize,
@@ -1411,17 +1461,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;
 }
 
diff --git a/src/provider/provider_os_memory_internal.h b/src/provider/provider_os_memory_internal.h
index 4a603b1da..4d2e8e217 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,8 @@ typedef struct os_memory_provider_t {
     size_t partitions_weight_sum;
 
     hwloc_topology_t topo;
+
+    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 c5a4b5f1f..252316ea6 100644
--- a/src/provider/provider_tracking.c
+++ b/src/provider/provider_tracking.c
@@ -50,6 +50,9 @@ typedef struct tracker_alloc_info_t {
     // 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;
 
 typedef struct tracker_ipc_info_t {
@@ -65,45 +68,92 @@ 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;
         }
 
+        if (rvalue == NULL) {
+            if (ref_value) {
+                critnib_release(hTracker->alloc_segments_map[level], ref_value);
+            }
+            parent_value = NULL;
+            parent_key = 0;
+            rkey = 0;
+            rsize = 0;
+            level = 0;
+            found = 0;
+            ref_value = NULL;
+            ref_parent_value = NULL;
+            continue;
+        }
+
         utils_atomic_load_acquire_u64((uint64_t *)&rvalue->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;
+            }
 
-        if (found && (uintptr_t)ptr < rkey + rsize) {
-            if (rvalue->n_children) {
-                if (level == MAX_LEVELS_OF_ALLOC_SEGMENT_MAP - 1) {
-                    break;
-                }
-                level++;
+            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 +164,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 +179,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;
@@ -139,8 +193,11 @@ umfMemoryTrackerAddAtLevel(umf_memory_tracker_handle_t hTracker, int level,
     }
 
     value->pool = pool;
-    utils_atomic_store_release_u64(&value->size, size);
+    value->size = size;
     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 +208,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,
+                n_children, (void *)hTracker, level - 1,
                 (void *)parent_value->pool, (void *)parent_key,
                 parent_value->size);
+            assert(ref_parent_value);
+            critnib_release(hTracker->alloc_segments_map[level - 1],
+                            ref_parent_value);
         }
         return UMF_RESULT_SUCCESS;
     }
@@ -179,26 +240,52 @@ 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;
         }
 
+        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->size, &rsize);
 
         if ((uintptr_t)ptr < rkey + rsize) {
@@ -219,17 +306,24 @@ static umf_result_t umfMemoryTrackerAdd(umf_memory_tracker_handle_t hTracker,
             }
             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 +341,49 @@ 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->pool, ptr, value->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->pool,
+            (void *)parent_key, parent_value->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;
 }
@@ -302,13 +414,14 @@ umfMemoryTrackerAddIpcSegment(umf_memory_tracker_handle_t hTracker,
     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 +437,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,9 +449,11 @@ 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;
 }
@@ -374,26 +490,66 @@ umf_result_t umfMemoryTrackerGetAllocInfo(const void *ptr,
     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) {
+        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;
+            top_most_key = 0;
+            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->size, &rsize);
+        utils_atomic_load_acquire_size_t(&rvalue->n_children, &n_children);
+        if (found && (uintptr_t)ptr < rkey + rsize) {
             top_most_key = rkey;
             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;
@@ -403,6 +559,9 @@ umf_result_t umfMemoryTrackerGetAllocInfo(const void *ptr,
     pAllocInfo->baseSize = top_most_value->size;
     pAllocInfo->pool = top_most_value->pool;
 
+    assert(ref_top_most_value);
+    critnib_release(TRACKER->alloc_segments_map[ref_level], ref_top_most_value);
+
     return UMF_RESULT_SUCCESS;
 }
 
@@ -424,13 +583,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 +603,10 @@ umf_result_t umfMemoryTrackerGetIpcInfo(const void *ptr,
     pIpcInfo->baseSize = rvalue->size;
     pIpcInfo->provider = rvalue->provider;
 
+    if (ref_value) {
+        critnib_release(TRACKER->ipc_segments_map, ref_value);
+    }
+
     return UMF_RESULT_SUCCESS;
 }
 
@@ -504,28 +673,20 @@ 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;
@@ -545,41 +706,35 @@ 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->size, firstSize);
+    critnib_release(provider->hTracker->alloc_segments_map[level], ref_value);
+
     utils_mutex_unlock(&provider->hTracker->splitMergeMutex);
 
     LOG_DEBUG(
@@ -590,9 +745,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 +760,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 +769,92 @@ 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) {
         LOG_FATAL("pool mismatch");
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_assert;
+        goto err_fatal;
     }
     if (lowValue->size + highValue->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->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 +883,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 +894,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 +911,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 +920,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 +946,20 @@ 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->pool == pool) || pool == NULL)) {
                 n_items++;
+                LOG_DEBUG(
+                    "found abandoned allocation in the tracking provider: "
+                    "pool=%p, ptr=%p, size=%zu",
+                    (void *)rvalue->pool, (void *)rkey, (size_t)rvalue->size);
+            }
+
+            if (ref_value) {
+                critnib_release(hTracker->alloc_segments_map[i], ref_value);
             }
 
             last_key = rkey;
@@ -829,7 +988,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,6 +997,7 @@ 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,
@@ -855,7 +1015,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;
@@ -900,13 +1060,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 +1131,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 +1275,24 @@ 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;
 }
 
 umf_memory_provider_ops_t UMF_TRACKING_MEMORY_PROVIDER_OPS = {
@@ -1137,15 +1305,22 @@ 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};
+
+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 +1334,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,6 +1362,22 @@ void umfTrackingMemoryProviderGetUpstreamProvider(
     *hUpstream = p->hUpstream;
 }
 
+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_memory_tracker_handle_t umfMemoryTrackerCreate(void) {
     umf_memory_tracker_handle_t handle =
         umf_ba_global_alloc(sizeof(struct umf_memory_tracker_t));
@@ -1211,7 +1402,8 @@ umf_memory_tracker_handle_t umfMemoryTrackerCreate(void) {
 
     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]) {
             goto err_destroy_alloc_segments_map;
         }
@@ -1223,7 +1415,8 @@ umf_memory_tracker_handle_t umfMemoryTrackerCreate(void) {
         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) {
         goto err_destroy_ipc_info_allocator;
     }
diff --git a/src/proxy_lib/CMakeLists.txt b/src/proxy_lib/CMakeLists.txt
index d6b07902d..494ef1ef2 100644
--- a/src/proxy_lib/CMakeLists.txt
+++ b/src/proxy_lib/CMakeLists.txt
@@ -1,56 +1,46 @@
-# Copyright (C) 2023-2024 Intel Corporation
+# Copyright (C) 2023-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 include(${UMF_CMAKE_SOURCE_DIR}/cmake/helpers.cmake)
 
-set(PROXY_SOURCES proxy_lib.c)
+set(UMF_PROXY_SOURCES_COMMON proxy_lib.c)
+set(UMF_PROXY_SOURCES_LINUX proxy_lib_linux.c)
+set(UMF_PROXY_SOURCES_WINDOWS proxy_lib_windows.c)
 
-set(PROXY_SOURCES_LINUX proxy_lib_linux.c)
-
-set(PROXY_SOURCES_WINDOWS proxy_lib_windows.c)
-
-set(PROXY_SOURCES_MACOSX proxy_lib_linux.c)
-
-if(LINUX)
-    set(PROXY_SOURCES ${PROXY_SOURCES} ${PROXY_SOURCES_LINUX})
+if(LINUX OR MACOSX)
+    set(UMF_PROXY_SOURCES ${UMF_PROXY_SOURCES_COMMON}
+                          ${UMF_PROXY_SOURCES_LINUX})
 elseif(WINDOWS)
-    set(PROXY_SOURCES ${PROXY_SOURCES} ${PROXY_SOURCES_WINDOWS})
-
+    set(UMF_PROXY_SOURCES ${UMF_PROXY_SOURCES_COMMON}
+                          ${UMF_PROXY_SOURCES_WINDOWS})
     # Add resource file needed for Windows to fill metadata in binary files
     configure_file("${CMAKE_CURRENT_SOURCE_DIR}/proxy_lib.rc.in"
                    "${CMAKE_CURRENT_BINARY_DIR}/proxy_lib.rc" IMMEDIATE @ONLY)
-    set(PROXY_SOURCES ${PROXY_SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/proxy_lib.rc)
-elseif(MACOSX)
-    set(PROXY_SOURCES ${PROXY_SOURCES} ${PROXY_SOURCES_MACOSX})
+    set(UMF_PROXY_SOURCES ${UMF_PROXY_SOURCES_COMMON}
+                          ${CMAKE_CURRENT_BINARY_DIR}/proxy_lib.rc)
 endif()
 
 add_umf_library(
     NAME umf_proxy
     TYPE SHARED
-    SRCS ${BA_SOURCES} ${PROXY_SOURCES}
-    LIBS umf_utils ${PROXY_LIBS}
+    SRCS ${UMF_PROXY_SOURCES}
+    LIBS umf umf_utils umf_ba
     LINUX_MAP_FILE ${CMAKE_CURRENT_SOURCE_DIR}/proxy_lib.map
     WINDOWS_DEF_FILE ${CMAKE_CURRENT_SOURCE_DIR}/proxy_lib.def)
-set_target_properties(umf_proxy PROPERTIES SOVERSION ${PROJECT_VERSION_MAJOR})
-
-add_library(${PROJECT_NAME}::proxy ALIAS umf_proxy)
 
-target_link_directories(umf_proxy PRIVATE ${LIBHWLOC_LIBRARY_DIRS})
-
-target_compile_definitions(umf_proxy PRIVATE ${UMF_COMMON_COMPILE_DEFINITIONS})
+set_target_properties(umf_proxy PROPERTIES SOVERSION ${PROJECT_VERSION_MAJOR})
 
 if(PROXY_LIB_USES_SCALABLE_POOL)
-    target_compile_definitions(umf_proxy PRIVATE PROXY_LIB_USES_SCALABLE_POOL=1)
+    target_compile_definitions(umf_proxy
+                               PRIVATE "PROXY_LIB_USES_SCALABLE_POOL=1")
 elseif(PROXY_LIB_USES_JEMALLOC_POOL)
-    target_compile_definitions(umf_proxy PRIVATE PROXY_LIB_USES_JEMALLOC_POOL=1)
+    target_compile_definitions(umf_proxy
+                               PRIVATE "PROXY_LIB_USES_JEMALLOC_POOL=1")
 endif()
 
 target_include_directories(
-    umf_proxy
-    PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
-           $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src/utils>
-           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-           $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
+    umf_proxy PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc
+                      ${UMF_CMAKE_SOURCE_DIR}/src/ravl)
 
 install(TARGETS umf_proxy EXPORT ${PROJECT_NAME}-targets)
diff --git a/src/utils/CMakeLists.txt b/src/utils/CMakeLists.txt
index 976a2cb62..7125d2603 100644
--- a/src/utils/CMakeLists.txt
+++ b/src/utils/CMakeLists.txt
@@ -6,32 +6,12 @@ include(${UMF_CMAKE_SOURCE_DIR}/cmake/helpers.cmake)
 include(FindThreads)
 
 set(UMF_UTILS_SOURCES_COMMON utils_common.c utils_log.c utils_load_library.c)
-
 set(UMF_UTILS_SOURCES_POSIX utils_posix_common.c utils_posix_concurrency.c)
-
 set(UMF_UTILS_SOURCES_LINUX utils_linux_common.c)
-
 set(UMF_UTILS_SOURCES_MACOSX utils_macosx_common.c)
-
 set(UMF_UTILS_SOURCES_WINDOWS utils_windows_common.c
                               utils_windows_concurrency.c)
 
-if(UMF_USE_VALGRIND)
-    if(UMF_USE_ASAN
-       OR UMF_USE_TSAN
-       OR UMF_USE_UBSAN
-       OR UMF_USE_MSAN)
-        message(FATAL_ERROR "Cannot use valgrind and sanitizers together")
-    endif()
-
-    if(PkgConfig_FOUND)
-        pkg_check_modules(VALGRIND valgrind)
-    endif()
-    if(NOT VALGRIND_FOUND)
-        find_package(VALGRIND REQUIRED valgrind)
-    endif()
-endif()
-
 if(LINUX OR MACOSX)
     set(UMF_UTILS_SOURCES ${UMF_UTILS_SOURCES_COMMON}
                           ${UMF_UTILS_SOURCES_POSIX})
@@ -48,24 +28,12 @@ elseif(WINDOWS)
                           ${UMF_UTILS_SOURCES_WINDOWS})
 endif()
 
-add_library(umf_utils INTERFACE)
-add_library(${PROJECT_NAME}::utils ALIAS umf_utils)
-
-target_sources(umf_utils INTERFACE ${UMF_UTILS_SOURCES})
-target_link_libraries(umf_utils INTERFACE ${CMAKE_THREAD_LIBS_INIT}
-                                          ${UMF_UTILS_LIBS})
+add_umf_library(
+    NAME umf_utils
+    TYPE STATIC
+    SRCS ${UMF_UTILS_SOURCES}
+    LIBS ${UMF_UTILS_LIBS} ${CMAKE_THREAD_LIBS_INIT})
 
-target_include_directories(
-    umf_utils
-    INTERFACE ${VALGRIND_INCLUDE_DIRS}
-              $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
-              $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
-
-if(UMF_USE_VALGRIND)
-    set(UMF_UTILS_INTERFACE_DEFS "UMF_VG_ENABLED=1")
+if(NOT UMF_BUILD_SHARED_LIBRARY)
+    install(TARGETS umf_utils EXPORT ${PROJECT_NAME}-targets)
 endif()
-
-set(UMF_UTILS_INTERFACE_DEFS ${UMF_UTILS_INTERFACE_DEFS}
-                             ${UMF_COMMON_COMPILE_DEFINITIONS})
-
-target_compile_definitions(umf_utils INTERFACE ${UMF_UTILS_INTERFACE_DEFS})
diff --git a/src/utils/utils_common.h b/src/utils/utils_common.h
index fff44f390..0fa860a0e 100644
--- a/src/utils/utils_common.h
+++ b/src/utils/utils_common.h
@@ -115,6 +115,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 31e5793b9..14d7fe54e 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"
 
@@ -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,17 +171,6 @@ 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;
-    }
-}
-
 #else // !defined(_WIN32)
 
 static inline void utils_atomic_load_acquire_u64(uint64_t *ptr, uint64_t *out) {
@@ -172,6 +180,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 +192,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) {
@@ -224,6 +243,43 @@ static inline bool utils_compare_exchange_u64(uint64_t *ptr, uint64_t *expected,
 
 #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 f5a42b0fa..6daab3e69 100644
--- a/src/utils/utils_level_zero.cpp
+++ b/src/utils/utils_level_zero.cpp
@@ -141,7 +141,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_posix_common.c b/src/utils/utils_posix_common.c
index 613b8ea41..da051695b 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_windows_common.c b/src/utils/utils_windows_common.c
index b6c5b0b4e..7aa8f7684 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
@@ -22,20 +22,27 @@
 
 #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(); }
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 20f982c65..bda44ea04 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -29,6 +29,7 @@ enable_testing()
 
 set(UMF_TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(UMF_UTILS_DIR ${UMF_CMAKE_SOURCE_DIR}/src/utils)
+set(UMF_BA_DIR ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc)
 
 function(build_umf_test)
     # Parameters:
@@ -50,13 +51,14 @@ function(build_umf_test)
 
     set(LIB_DIRS ${LIB_DIRS} ${LIBHWLOC_LIBRARY_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})
+        set(LIB_DIRS ${LIB_DIRS} ${ZE_LOADER_LIBRARY_DIRS})
     endif()
 
     if(NOT UMF_DISABLE_HWLOC)
@@ -71,12 +73,7 @@ function(build_umf_test)
         set(CPL_DEFS ${CPL_DEFS} UMF_POOL_SCALABLE_ENABLED=1)
     endif()
 
-    set(TEST_LIBS
-        umf_test_common
-        ${ARG_LIBS}
-        GTest::gtest_main
-        ${LIBS_OPTIONAL}
-        umf)
+    set(TEST_LIBS umf_test_common ${ARG_LIBS} GTest::gtest_main umf)
 
     add_umf_executable(
         NAME ${TEST_TARGET_NAME}
@@ -150,27 +147,21 @@ function(add_umf_test)
             "${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()
 
 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,28 +183,31 @@ if(UMF_BUILD_SHARED_LIBRARY)
     endif()
 endif()
 
-if(UMF_BUILD_SHARED_LIBRARY)
-    # if build as shared library, ba symbols won't be visible in tests
-    set(BA_SOURCES_FOR_TEST ${BA_SOURCES})
-endif()
-
 add_umf_test(NAME base SRCS base.cpp)
+
 add_umf_test(
     NAME memoryPool
-    SRCS memoryPoolAPI.cpp malloc_compliance_tests.cpp ${BA_SOURCES_FOR_TEST}
-    LIBS ${UMF_UTILS_FOR_TEST})
+    SRCS memoryPoolAPI.cpp malloc_compliance_tests.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+
 add_umf_test(
     NAME memoryProvider
-    SRCS memoryProviderAPI.cpp ${BA_SOURCES_FOR_TEST}
-    LIBS ${UMF_UTILS_FOR_TEST})
+    SRCS memoryProviderAPI.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+
 add_umf_test(
     NAME logger
     SRCS utils/utils_log.cpp ${UMF_UTILS_SOURCES}
     LIBS ${UMF_LOGGER_LIBS})
 
 add_umf_test(
-    NAME ctl
-    SRCS ctl/test.cpp ctl/ctl_debug.c ../src/ctl/ctl.c ${BA_SOURCES_FOR_TEST}
+    NAME ctl_unittest
+    SRCS ctl/ctl_unittest.cpp ctl/ctl_debug.c ../src/ctl/ctl.c
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+
+add_umf_test(
+    NAME ctl_api
+    SRCS ctl/ctl_api.cpp
     LIBS ${UMF_UTILS_FOR_TEST})
 
 add_umf_test(
@@ -230,26 +224,31 @@ endif()
 
 add_umf_test(
     NAME coarse_lib
-    SRCS coarse_lib.cpp ${BA_SOURCES_FOR_TEST}
-    LIBS ${UMF_UTILS_FOR_TEST} coarse)
+    SRCS coarse_lib.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} umf_coarse)
 
 add_umf_test(
     NAME disjoint_pool
     SRCS pools/disjoint_pool.cpp malloc_compliance_tests.cpp
+    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 c_api_disjoint_pool
-    SRCS c_api/disjoint_pool.c ${BA_SOURCES_FOR_TEST}
+    SRCS c_api/disjoint_pool.c
     LIBS ${UMF_UTILS_FOR_TEST})
 
 if(LINUX AND (NOT UMF_DISABLE_HWLOC))
     # this test uses the file provider
     add_umf_test(
         NAME disjoint_pool_file_prov
-        SRCS disjoint_pool_file_prov.cpp ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        SRCS disjoint_pool_file_prov.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 endif()
 
 if(UMF_POOL_JEMALLOC_ENABLED
@@ -262,16 +261,14 @@ if(UMF_POOL_JEMALLOC_ENABLED AND (NOT UMF_DISABLE_HWLOC))
     add_umf_test(
         NAME jemalloc_pool
         SRCS pools/jemalloc_pool.cpp malloc_compliance_tests.cpp
-             ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 endif()
 
 if(UMF_POOL_SCALABLE_ENABLED AND (NOT UMF_DISABLE_HWLOC))
     add_umf_test(
         NAME scalable_pool
         SRCS pools/scalable_pool.cpp malloc_compliance_tests.cpp
-             ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 endif()
 
 if(LINUX AND (NOT UMF_DISABLE_HWLOC)) # OS-specific functions are implemented
@@ -285,40 +282,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 +333,42 @@ if(LINUX AND (NOT UMF_DISABLE_HWLOC)) # OS-specific functions are implemented
     add_umf_test(
         NAME provider_devdax_memory
         SRCS provider_devdax_memory.cpp
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_devdax_memory_ipc
-        SRCS provider_devdax_memory_ipc.cpp ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        SRCS provider_devdax_memory_ipc.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_file_memory
         SRCS provider_file_memory.cpp
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_file_memory_ipc
-        SRCS provider_file_memory_ipc.cpp ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        SRCS provider_file_memory_ipc.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_fixed_memory
         SRCS provider_fixed_memory.cpp
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_tracking
         SRCS provider_tracking.cpp
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_tracking_fixture_tests
         SRCS provider_tracking_fixture_tests.cpp malloc_compliance_tests.cpp
-             ${BA_SOURCES_FOR_TEST}
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 
     # This test requires Linux-only file memory provider
     if(UMF_POOL_JEMALLOC_ENABLED)
         add_umf_test(
             NAME jemalloc_coarse_file
             SRCS pools/jemalloc_coarse_file.cpp malloc_compliance_tests.cpp
-                 ${BA_SOURCES_FOR_TEST}
-            LIBS ${UMF_UTILS_FOR_TEST})
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
         add_umf_test(
             NAME jemalloc_coarse_devdax
             SRCS pools/jemalloc_coarse_devdax.cpp malloc_compliance_tests.cpp
-                 ${BA_SOURCES_FOR_TEST}
-            LIBS ${UMF_UTILS_FOR_TEST})
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     endif()
 
     # This test requires Linux-only file memory provider
@@ -376,59 +376,57 @@ 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})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 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)
 endif()
@@ -448,28 +446,25 @@ if(UMF_BUILD_GPU_TESTS AND UMF_BUILD_CUDA_PROVIDER)
         add_umf_test(
             NAME provider_cuda
             SRCS providers/provider_cuda.cpp providers/cuda_helpers.cpp
-                 ${BA_SOURCES_FOR_TEST}
-            LIBS ${UMF_UTILS_FOR_TEST} cuda)
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} cuda)
 
         add_umf_test(
             NAME provider_cuda_dlopen_global
             SRCS providers/provider_cuda.cpp providers/cuda_helpers.cpp
-                 ${BA_SOURCES_FOR_TEST}
-            LIBS ${UMF_UTILS_FOR_TEST})
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
         target_compile_definitions(test_provider_cuda_dlopen_global
                                    PUBLIC USE_DLOPEN=1 OPEN_CU_LIBRARY_GLOBAL=1)
 
         add_umf_test(
             NAME provider_cuda_dlopen_local
             SRCS providers/provider_cuda.cpp providers/cuda_helpers.cpp
-                 ${BA_SOURCES_FOR_TEST}
-            LIBS ${UMF_UTILS_FOR_TEST})
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
         target_compile_definitions(test_provider_cuda_dlopen_local
                                    PUBLIC USE_DLOPEN=1 OPEN_CU_LIBRARY_GLOBAL=0)
     else()
         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 +478,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 +510,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)
@@ -569,16 +562,6 @@ function(add_umf_ipc_test)
     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(LINUX)
@@ -626,7 +609,7 @@ if(LINUX)
 
     # TODO add IPC tests for CUDA
 
-    if(UMF_BUILD_GPU_TESTS AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
+    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
@@ -697,7 +680,7 @@ if(LINUX
         )
     endif()
 
-    if(LIBNUMA_LIBRARIES)
+    if(LIBNUMA_FOUND)
         set(EXAMPLES ${EXAMPLES} memspace_hmat memspace_numa)
     else()
         message(
@@ -706,7 +689,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 +698,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 +709,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(
@@ -774,15 +755,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 b529497c8..905835160 100644
--- a/test/c_api/disjoint_pool.c
+++ b/test/c_api/disjoint_pool.c
@@ -48,8 +48,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/coarse_lib.cpp b/test/coarse_lib.cpp
index 761183389..ceb4cd514 100644
--- a/test/coarse_lib.cpp
+++ b/test/coarse_lib.cpp
@@ -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,8 +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);
+    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);
@@ -636,7 +637,7 @@ TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_free_cb_fails) {
 
     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_delete(ch);
     umfMemoryProviderDestroy(malloc_memory_provider);
@@ -669,34 +670,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 +706,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 +750,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 +758,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 +809,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 +838,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 +865,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 +897,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 +958,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 +966,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 +989,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 +1004,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 +1035,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 +1046,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 +1055,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 +1070,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 +1087,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 +1130,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 +1205,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 +1250,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 +1264,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 +1274,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 +1290,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 +1319,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 +1333,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 +1343,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 +1359,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 +1397,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 +1405,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/ipc_common.c b/test/common/ipc_common.c
index bf116a677..5e9b911be 100644
--- a/test/common/ipc_common.c
+++ b/test/common/ipc_common.c
@@ -111,9 +111,11 @@ int consumer_connect(int port) {
     return ret;
 }
 
-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];
     int producer_socket = -1;
     int ret = -1;
@@ -327,9 +329,11 @@ int producer_connect(int port) {
     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;
diff --git a/test/common/ipc_common.h b/test/common/ipc_common.h
index 89303899b..c46c9a064 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/pool.hpp b/test/common/pool.hpp
index 558b9d665..d9873810a 100644
--- a/test/common/pool.hpp
+++ b/test/common/pool.hpp
@@ -28,8 +28,8 @@
 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 +83,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,6 +101,7 @@ bool isAlignedAllocSupported(umf_memory_pool_handle_t hPool) {
     } else {
         throw std::runtime_error("AlignedMalloc failed with unexpected error");
     }
+#endif
 }
 
 typedef struct pool_base_t {
@@ -107,7 +112,7 @@ typedef struct pool_base_t {
     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; }
+    size_t malloc_usable_size(const void *) noexcept { return 0; }
     umf_result_t free(void *) noexcept { return UMF_RESULT_SUCCESS; }
     umf_result_t get_last_allocation_error() noexcept {
         return UMF_RESULT_SUCCESS;
@@ -133,13 +138,13 @@ struct malloc_pool : public pool_base_t {
         return ::aligned_alloc(alignment, size);
 #endif
     }
-    size_t malloc_usable_size(void *ptr) noexcept {
+    size_t malloc_usable_size(const void *ptr) noexcept {
 #ifdef _WIN32
-        return _msize(ptr);
+        return _msize((void *)ptr);
 #elif __APPLE__
-        return ::malloc_size(ptr);
+        return ::malloc_size((void *)ptr);
 #else
-        return ::malloc_usable_size(ptr);
+        return ::malloc_usable_size((void *)ptr);
 #endif
     }
     umf_result_t free(void *ptr) noexcept {
diff --git a/test/common/pool_null.c b/test/common/pool_null.c
index 40d662679..a44f3c4ab 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,7 +49,7 @@ static void *nullAlignedMalloc(void *pool, size_t size, size_t alignment) {
     return NULL;
 }
 
-static size_t nullMallocUsableSize(void *pool, void *ptr) {
+static size_t nullMallocUsableSize(void *pool, const void *ptr) {
     (void)ptr;
     (void)pool;
     return 0;
diff --git a/test/common/pool_trace.c b/test/common/pool_trace.c
index 9a9e01019..e4479548f 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,7 +69,7 @@ static void *traceAlignedMalloc(void *pool, size_t size, size_t alignment) {
                                 alignment);
 }
 
-static size_t traceMallocUsableSize(void *pool, void *ptr) {
+static size_t traceMallocUsableSize(void *pool, const void *ptr) {
     trace_pool_t *trace_pool = (trace_pool_t *)pool;
 
     trace_pool->params.trace_handler(trace_pool->params.trace_context,
diff --git a/test/common/provider.hpp b/test/common/provider.hpp
index 38fe7336e..a393a77c6 100644
--- a/test/common/provider.hpp
+++ b/test/common/provider.hpp
@@ -48,50 +48,51 @@ typedef struct provider_base_t {
                               [[maybe_unused]] size_t *pageSize) noexcept {
         return UMF_RESULT_ERROR_UNKNOWN;
     }
-    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;
     }
     const char *get_name() noexcept { return "base"; }
-    umf_result_t purge_lazy([[maybe_unused]] void *ptr,
-                            [[maybe_unused]] size_t size) noexcept {
+    umf_result_t ext_purge_lazy([[maybe_unused]] void *ptr,
+                                [[maybe_unused]] size_t size) noexcept {
         return UMF_RESULT_ERROR_UNKNOWN;
     }
-    umf_result_t purge_force([[maybe_unused]] void *ptr,
-                             [[maybe_unused]] size_t size) noexcept {
+    umf_result_t ext_purge_force([[maybe_unused]] void *ptr,
+                                 [[maybe_unused]] size_t size) noexcept {
         return UMF_RESULT_ERROR_UNKNOWN;
     }
 
-    umf_result_t allocation_merge([[maybe_unused]] void *lowPtr,
-                                  [[maybe_unused]] void *highPtr,
-                                  [[maybe_unused]] size_t totalSize) {
+    umf_result_t ext_allocation_merge([[maybe_unused]] void *lowPtr,
+                                      [[maybe_unused]] void *highPtr,
+                                      [[maybe_unused]] size_t totalSize) {
         return UMF_RESULT_ERROR_UNKNOWN;
     }
 
-    umf_result_t allocation_split([[maybe_unused]] void *ptr,
-                                  [[maybe_unused]] size_t totalSize,
-                                  [[maybe_unused]] size_t firstSize) {
+    umf_result_t ext_allocation_split([[maybe_unused]] void *ptr,
+                                      [[maybe_unused]] size_t totalSize,
+                                      [[maybe_unused]] size_t firstSize) {
         return UMF_RESULT_ERROR_UNKNOWN;
     }
-    umf_result_t get_ipc_handle_size([[maybe_unused]] size_t *size) noexcept {
+    umf_result_t
+    ext_get_ipc_handle_size([[maybe_unused]] size_t *size) noexcept {
         return UMF_RESULT_ERROR_UNKNOWN;
     }
     umf_result_t
-    get_ipc_handle([[maybe_unused]] const void *ptr,
-                   [[maybe_unused]] size_t size,
-                   [[maybe_unused]] void *providerIpcData) noexcept {
+    ext_get_ipc_handle([[maybe_unused]] const void *ptr,
+                       [[maybe_unused]] size_t size,
+                       [[maybe_unused]] void *providerIpcData) noexcept {
         return UMF_RESULT_ERROR_UNKNOWN;
     }
     umf_result_t
-    put_ipc_handle([[maybe_unused]] void *providerIpcData) noexcept {
+    ext_put_ipc_handle([[maybe_unused]] void *providerIpcData) noexcept {
         return UMF_RESULT_ERROR_UNKNOWN;
     }
-    umf_result_t open_ipc_handle([[maybe_unused]] void *providerIpcData,
-                                 [[maybe_unused]] void **ptr) noexcept {
+    umf_result_t ext_open_ipc_handle([[maybe_unused]] void *providerIpcData,
+                                     [[maybe_unused]] void **ptr) 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_close_ipc_handle([[maybe_unused]] void *ptr,
+                                      [[maybe_unused]] size_t size) noexcept {
         return UMF_RESULT_ERROR_UNKNOWN;
     }
     virtual ~provider_base_t() = default;
@@ -133,7 +134,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;
     }
@@ -152,7 +153,7 @@ struct provider_mock_out_of_mem : public provider_base_t {
     const char *get_name() noexcept { return "mock_out_of_mem"; }
 };
 
-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 b4e54f976..8c1602be7 100644
--- a/test/common/provider_null.c
+++ b/test/common/provider_null.c
@@ -8,13 +8,16 @@
 #include "provider_null.h"
 #include <umf/memory_provider_ops.h>
 
-static umf_result_t nullInitialize(void *params, void **pool) {
+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) {
@@ -47,8 +50,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;
@@ -139,13 +141,13 @@ 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,
 };
diff --git a/test/common/provider_trace.c b/test/common/provider_trace.c
index 20f44e868..6be80c0de 100644
--- a/test/common/provider_trace.c
+++ b/test/common/provider_trace.c
@@ -9,7 +9,7 @@
 #include <umf/memory_provider.h>
 #include <umf/memory_provider_ops.h>
 
-static umf_result_t traceInitialize(void *params, void **pool) {
+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 +17,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 +28,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,
@@ -77,8 +82,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;
@@ -200,13 +204,13 @@ 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,
 };
diff --git a/test/ctl/config.txt b/test/ctl/config.txt
index 5d4f9c62b..52c8febad 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 000000000..8bbb9d820
--- /dev/null
+++ b/test/ctl/ctl_api.cpp
@@ -0,0 +1,392 @@
+/*
+ *
+ * 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 <exception>
+#include <functional> // For std::ref
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <type_traits>
+#include <vector>
+
+#include <umf.h>
+#include <umf/base.h>
+#include <umf/memory_pool.h>
+#include <umf/memory_provider.h>
+#include <umf/pools/pool_disjoint.h>
+#include <umf/pools/pool_scalable.h>
+#include <umf/providers/provider_fixed_memory.h>
+#include <umf/providers/provider_os_memory.h>
+
+#include "../common/base.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", hProvider,
+                    &ipc_enabled, sizeof(ipc_enabled));
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(ipc_enabled, 0);
+
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+    umfMemoryProviderDestroy(hProvider);
+}
+
+class Pool {
+  public:
+    Pool() : provider(NULL), pool(NULL) {}
+
+    int instantiatePool(const umf_memory_pool_ops_t *pool_ops,
+                        const void *pool_params,
+                        umf_pool_create_flags_t flags = 0) {
+        freeResources();
+        provider = create_memory_provider();
+        if (provider == NULL) {
+            return -1; // Provider not supported
+        }
+        int ret = umfPoolCreate(pool_ops, provider, pool_params, flags, &pool);
+        if (ret != UMF_RESULT_SUCCESS) {
+            umfMemoryProviderDestroy(provider);
+            provider = NULL;
+            return -2; // Failed to create memory pool
+        }
+        return 0; // Success
+    }
+
+    // Template specialization for different types of reference value
+    template <typename T> T getReferenceValue() {
+        if constexpr (std::is_arithmetic_v<T>) {
+            return 0xBAD;
+        } else if constexpr (std::is_same_v<T, std::string>) {
+            return "0xBAD";
+        }
+    }
+
+    template <typename T>
+    void validateQuery(std::function<umf_result_t(const char *name, void *ctx,
+                                                  void *arg, size_t)>
+                           ctlApiFunction,
+                       const char *name, T expectedValue, umf_result_t expected,
+                       bool disableContext = 0) {
+        T value = getReferenceValue<T>();
+        umf_result_t ret;
+        char ret_buf[256] = {0};
+        if constexpr (std::is_same_v<T, std::string>) {
+            strncpy(ret_buf, value.c_str(), sizeof(ret_buf) - 1);
+            ret_buf[sizeof(ret_buf) - 1] = '\0'; // Ensure null-termination
+            ret = ctlApiFunction(name, disableContext ? nullptr : pool,
+                                 (void *)ret_buf, sizeof(ret_buf));
+        } else if constexpr (std::is_arithmetic_v<T>) {
+            std::string value_str = std::to_string(value);
+            strncpy(ret_buf, value_str.c_str(), sizeof(ret_buf) - 1);
+            ret_buf[sizeof(ret_buf) - 1] = '\0'; // Ensure null-termination
+            ret = ctlApiFunction(name, disableContext ? nullptr : pool,
+                                 (void *)ret_buf, sizeof(ret_buf));
+        } else {
+            ret = ctlApiFunction(name, disableContext ? nullptr : pool, &value,
+                                 sizeof(value));
+        }
+
+        ASSERT_EQ(ret, expected);
+        if (ret == UMF_RESULT_SUCCESS) {
+            ASSERT_EQ(ret_buf, expectedValue);
+        }
+    }
+
+    template <typename T>
+    void executeQuery(std::function<umf_result_t(const char *name, void *ctx,
+                                                 void *arg, size_t)>
+                          ctlApiFunction,
+                      const char *name, T value, bool disableContext = 0) {
+        size_t value_len;
+        if constexpr (std::is_arithmetic_v<T>) {
+            value_len = sizeof(value);
+        } else if constexpr (std::is_same_v<T, std::string>) {
+            value_len = strlen(value.c_str());
+        } else if constexpr (std::is_same_v<T, const char *>) {
+            value_len = strlen(value);
+        } else {
+            throw std::runtime_error("Unsupported type for value");
+        }
+        umf_result_t ret = ctlApiFunction(name, disableContext ? nullptr : pool,
+                                          (void *)value, value_len);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    }
+
+    void freeResources() {
+        if (pool) {
+            umfPoolDestroy(pool);
+            pool = NULL;
+        }
+        if (provider) {
+            umfMemoryProviderDestroy(provider);
+            provider = NULL;
+        }
+        if (data) {
+            free(data);
+            data = nullptr;
+        }
+    }
+
+    umf_memory_provider_handle_t provider;
+    umf_memory_pool_handle_t pool;
+    void *data = nullptr;
+
+  private:
+    // Create a memory provider
+    umf_memory_provider_handle_t create_memory_provider() {
+        const umf_memory_provider_ops_t *provider_ops =
+            umfFixedMemoryProviderOps();
+        umf_fixed_memory_provider_params_handle_t params = NULL;
+
+        data = malloc(1024 * 1024);
+        int ret =
+            umfFixedMemoryProviderParamsCreate(&params, data, 1024 * 1024);
+        if (ret != UMF_RESULT_SUCCESS) {
+            return 0;
+        }
+
+        ret = umfMemoryProviderCreate(provider_ops, params, &provider);
+        umfFixedMemoryProviderParamsDestroy(params);
+        if (ret != UMF_RESULT_SUCCESS) {
+            return 0;
+        }
+
+        return provider;
+    }
+};
+
+class CtlTest : public ::testing::Test {
+  public:
+    CtlTest() {}
+
+    void SetUp() override {}
+
+    void TearDown() override {}
+
+  private:
+};
+
+/* Case: default settings
+ * This test sets a default value and then retrieves it */
+TEST_F(CtlTest, ctlDefault) {
+    void *ctx = NULL;
+    const char *arg = "default_name";
+
+    auto res = umfCtlSet("umf.pool.default.some_pool.some_path", ctx,
+                         (void *)arg, strlen(arg));
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    char output[64] = {1};
+    res = umfCtlGet("umf.pool.default.some_pool.some_path", ctx, (void *)output,
+                    sizeof(output));
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    ASSERT_STREQ(output, arg);
+}
+
+/* Case: umfCtlSet negative test */
+TEST_F(CtlTest, ctlSetInvalid) {
+    void *valid_ctx = (void *)0xBABE;
+    const char *valid_arg = "default_name";
+    const char *valid_path = "umf.pool.default.some_pool.some_path";
+    // umfCtlSet - invalid path
+    auto res = umfCtlSet(NULL, valid_ctx, (void *)valid_arg, strlen(valid_arg));
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // umfCtlSet - invalid size
+    res = umfCtlSet(valid_path, NULL, (void *)valid_arg, 0);
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // umfCtlSet - invalid arg
+    res = umfCtlSet(valid_path, valid_ctx, NULL, strlen(valid_arg));
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+/* Case: umfCtlGet negative test */
+TEST_F(CtlTest, ctlGetInvalid) {
+    void *valid_ctx = (void *)0xBABE;
+    const char *valid_arg = "default_name";
+    const char *valid_path = "umf.pool.default.some_pool.some_path";
+
+    // umfCtlGet - invalid path
+    auto res = umfCtlGet(NULL, valid_ctx, (void *)valid_arg, strlen(valid_arg));
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // umfCtlGet - invalid arg
+    res = umfCtlGet(valid_path, valid_ctx, 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) {
+    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(), NULL, (void *)predefined_value,
+                          strlen(predefined_value));
+                std::atomic_fetch_add(&totalRecords, 1UL);
+            }
+        });
+    }
+    for (auto &thread : threads) {
+        thread.join();
+    }
+
+    // Check if all threads set the value correctly
+    // and retrieve it
+    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);
+        auto status =
+            umfCtlGet(name.c_str(), nullptr, (void *)output, sizeof(output));
+        ASSERT_EQ(status, UMF_RESULT_SUCCESS);
+        ASSERT_EQ(std::string(output), std::string(predefined_value));
+    }
+}
+
+/* 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) {
+    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));
+        umfCtlSet(name.c_str(), NULL, (void *)values.back().c_str(),
+                  values.back().size());
+    }
+
+    char output[100] = {0};
+    umf_result_t status =
+        umfCtlGet(name.c_str(), NULL, (void *)output, sizeof(output));
+    ASSERT_EQ(status, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(std::string(output), values.back());
+}
+
+TEST_F(CtlTest, ctlNameValidation) {
+    std::string name = "umf.pool.default.disjoint.name";
+    std::string value = "new_disjoint_pool_name";
+    umf_disjoint_pool_params_handle_t params = NULL;
+
+    Pool p;
+    try {
+        p.executeQuery(umfCtlSet, name.c_str(), value.c_str(), true);
+        umf_result_t res = umfDisjointPoolParamsCreate(&params);
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+        auto ret = p.instantiatePool(umfDisjointPoolOps(), params);
+        ASSERT_EQ(ret, 0);
+
+        p.validateQuery(umfCtlGet, "umf.pool.by_handle.disjoint.name",
+                        std::move(value), UMF_RESULT_SUCCESS);
+    } catch (...) {
+        GTEST_FAIL() << "Unknown exception!";
+    }
+    umfDisjointPoolParamsDestroy(params);
+    p.freeResources();
+}
+
+TEST_F(CtlTest, ctlSizeValidation) {
+    std::string name = "umf.pool.default.disjoint.name";
+    std::string value = "1234567890";
+    umf_disjoint_pool_params_handle_t params = NULL;
+
+    Pool p;
+    try {
+        p.executeQuery(umfCtlSet, name.c_str(), value.c_str(), true);
+        umf_result_t res = umfDisjointPoolParamsCreate(&params);
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+        auto ret = p.instantiatePool(umfDisjointPoolOps(), params);
+        ASSERT_EQ(ret, 0);
+
+        char output[100] = {0};
+        umfCtlGet("umf.pool.default.disjoint.name", NULL, output,
+                  sizeof(output));
+        ASSERT_EQ(std::string(output), value);
+
+        memset(output, 0, sizeof(output));
+        umfCtlGet("umf.pool.default.disjoint.name", NULL, output,
+                  value.size() / 2);
+        auto half_value = value.substr(0, value.size() / 2);
+        ASSERT_EQ(half_value, std::string(output));
+    } catch (...) {
+        GTEST_FAIL() << "Unknown exception!";
+    }
+    umfDisjointPoolParamsDestroy(params);
+    p.freeResources();
+}
+
+TEST_F(CtlTest, ctlExecInvalidSize) {
+    std::string name = "umf.pool.default.disjoint.name";
+    ASSERT_EQ(umfCtlSet(name.c_str(), NULL, (void *)"test_value", 0),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(umfCtlSet(name.c_str(), NULL, NULL, 10),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+#ifdef PROVIDER_DEFAULTS_NOT_IMPLEMENTED_YET
+TEST_F(CtlTest, ctlDefaultMultithreadedProvider) {
+    std::vector<std::thread> threads;
+    std::atomic<size_t> totalRecords = 0;
+    const char *predefined_value = "xyzzyx";
+    std::string name_prefix = "umf.provider.default.some_pool.";
+    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(), NULL, (void *)predefined_value,
+                              strlen(predefined_value));
+                    std::atomic_fetch_add(&totalRecords, 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);
+        auto status =
+            umfCtlGet(name.c_str(), nullptr, (void *)output, sizeof(output));
+        ASSERT_EQ(status, UMF_RESULT_SUCCESS);
+        ASSERT_EQ(std::string(output), std::string(predefined_value));
+    }
+}
+#endif
diff --git a/test/ctl/ctl_debug.c b/test/ctl/ctl_debug.c
index 711cb5e17..965e4871c 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
@@ -13,23 +13,26 @@
 
 #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) {
+                                            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) {
     /* suppress unused-parameter errors */
-    (void)source, (void)indexes, (void)ctx;
+    (void)source, (void)indexes, (void)ctx, (void)extra_name, (void)query_type,
+        (void)size;
 
     int arg_in = *(int *)arg;
     alloc_pattern = arg_in;
@@ -40,11 +43,14 @@ static int CTL_WRITE_HANDLER(alloc_pattern)(void *ctx,
  * 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) {
+                                           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) {
     /* suppress unused-parameter errors */
-    (void)source, (void)indexes, (void)ctx;
+    (void)source, (void)indexes, (void)ctx, (void)extra_name, (void)query_type,
+        (void)size;
 
     int *arg_out = arg;
     *arg_out = alloc_pattern;
@@ -52,11 +58,14 @@ static int CTL_READ_HANDLER(alloc_pattern)(void *ctx,
 }
 
 static int CTL_WRITE_HANDLER(enable_logging)(void *ctx,
-                                             enum ctl_query_source source,
-                                             void *arg,
-                                             struct ctl_index_utlist *indexes) {
+                                             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) {
     /* suppress unused-parameter errors */
-    (void)source, (void)indexes, (void)ctx;
+    (void)source, (void)indexes, (void)ctx, (void)extra_name, (void)query_type,
+        (void)size;
 
     int arg_in = *(int *)arg;
     enable_logging = arg_in;
@@ -64,33 +73,43 @@ static int CTL_WRITE_HANDLER(enable_logging)(void *ctx,
 }
 
 static int CTL_READ_HANDLER(enable_logging)(void *ctx,
-                                            enum ctl_query_source source,
-                                            void *arg,
-                                            struct ctl_index_utlist *indexes) {
+                                            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) {
     /* suppress unused-parameter errors */
-    (void)source, (void)indexes, (void)ctx;
+    (void)source, (void)indexes, (void)ctx, (void)extra_name, (void)query_type,
+        (void)size;
 
     int *arg_out = arg;
     *arg_out = enable_logging;
     return 0;
 }
 
-static int CTL_WRITE_HANDLER(log_level)(void *ctx, enum ctl_query_source source,
-                                        void *arg,
-                                        struct ctl_index_utlist *indexes) {
+static int CTL_WRITE_HANDLER(log_level)(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) {
     /* suppress unused-parameter errors */
-    (void)source, (void)indexes, (void)ctx;
+    (void)source, (void)indexes, (void)ctx, (void)extra_name, (void)query_type,
+        (void)size;
 
     int arg_in = *(int *)arg;
     log_level = arg_in;
     return 0;
 }
 
-static int CTL_READ_HANDLER(log_level)(void *ctx, enum ctl_query_source source,
-                                       void *arg,
-                                       struct ctl_index_utlist *indexes) {
+static int CTL_READ_HANDLER(log_level)(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) {
     /* suppress unused-parameter errors */
-    (void)source, (void)indexes, (void)ctx;
+    (void)source, (void)indexes, (void)ctx, (void)extra_name, (void)query_type,
+        (void)size;
 
     int *arg_out = arg;
     *arg_out = log_level;
@@ -103,24 +122,19 @@ 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_node CTL_NODE(heap)[] = {CTL_LEAF_RW(alloc_pattern),
-                                                 CTL_LEAF_RW(enable_logging),
-                                                 CTL_LEAF_RW(log_level),
+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 struct ctl_node CTL_NODE(debug)[] = {CTL_CHILD(heap),
+static const umf_ctl_node_t CTL_NODE(debug)[] = {CTL_CHILD(heap),
 
-                                                  CTL_NODE_END};
+                                                 CTL_NODE_END};
 
 /*
  * debug_ctl_register -- registers ctl nodes for "debug" module
  */
 void debug_ctl_register(struct ctl *ctl) { CTL_REGISTER_MODULE(ctl, debug); }
 
-void initialize_debug_ctl(void) {
-    ctl_debug = ctl_new();
-    debug_ctl_register(ctl_debug);
-}
-
-void deinitialize_debug_ctl(void) { ctl_delete(ctl_debug); }
+void initialize_debug_ctl(void) { debug_ctl_register(&ctl_debug); }
diff --git a/test/ctl/test.cpp b/test/ctl/ctl_unittest.cpp
similarity index 90%
rename from test/ctl/test.cpp
rename to test/ctl/ctl_unittest.cpp
index c35759c67..f98825bd4 100644
--- a/test/ctl/test.cpp
+++ b/test/ctl/ctl_unittest.cpp
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -21,35 +21,39 @@ TEST_F(test, ctl_debug_read_from_string) {
 
     int value = 0;
     ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
-              "debug.heap.alloc_pattern", CTL_QUERY_READ, &value);
+              "debug.heap.alloc_pattern", CTL_QUERY_READ, &value,
+              sizeof(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);
+              "debug.heap.alloc_pattern", CTL_QUERY_READ, &value,
+              sizeof(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);
+              "debug.heap.alloc_pattern", CTL_QUERY_READ, &value,
+              sizeof(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),
+                        "debug.heap.non_existent", CTL_QUERY_READ, &value,
+                        sizeof(value)),
               0);
 
     // Negative test: invalid path
     ASSERT_NE(ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
-                        "invalid.path.alloc_pattern", CTL_QUERY_READ, &value),
+                        "invalid.path.alloc_pattern", CTL_QUERY_READ, &value,
+                        sizeof(value)),
               0);
 
     debug_ctl_register(ctl_handler);
-    deinitialize_debug_ctl();
 }
 
 int ctl_config_write_to_file(const char *filename, const char *data) {
@@ -74,20 +78,19 @@ TEST_F(test, ctl_debug_read_from_file) {
 
     int value = 0;
     ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
-              "debug.heap.alloc_pattern", CTL_QUERY_READ, &value);
+              "debug.heap.alloc_pattern", CTL_QUERY_READ, &value, 0);
     ASSERT_EQ(value, 321);
 
     value = 0;
     ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC, "debug.heap.log_level",
-              CTL_QUERY_READ, &value);
+              CTL_QUERY_READ, &value, 0);
     ASSERT_EQ(value, 5);
 
     value = 0;
     ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
-              "debug.heap.enable_logging", CTL_QUERY_READ, &value);
+              "debug.heap.enable_logging", CTL_QUERY_READ, &value, 0);
     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 58e15f571..08fad03e2 100644
--- a/test/disjoint_pool_file_prov.cpp
+++ b/test/disjoint_pool_file_prov.cpp
@@ -129,9 +129,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) {
@@ -202,9 +205,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 {
@@ -358,6 +364,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 360184c73..a4936ff5f 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/ipcAPI.cpp b/test/ipcAPI.cpp
index c0642dd76..15e995acd 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,16 @@ 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 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 +73,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 +105,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;
diff --git a/test/ipcFixtures.hpp b/test/ipcFixtures.hpp
index cf31ff758..4c1e5e714 100644
--- a/test/ipcFixtures.hpp
+++ b/test/ipcFixtures.hpp
@@ -60,8 +60,8 @@ 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 *>;
 
@@ -166,11 +166,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 +437,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 +547,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,9 +673,9 @@ 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);
 }
 
@@ -721,6 +721,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_negative.cpp b/test/ipc_negative.cpp
index 5c4cccf22..7cbeb3668 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 b91bde1f6..e59dc4f4e 100644
--- a/test/malloc_compliance_tests.cpp
+++ b/test/malloc_compliance_tests.cpp
@@ -119,7 +119,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/memoryPoolAPI.cpp b/test/memoryPoolAPI.cpp
index e8071a2d8..8df9735a2 100644
--- a/test/memoryPoolAPI.cpp
+++ b/test/memoryPoolAPI.cpp
@@ -42,7 +42,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 +71,43 @@ 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);
+    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);
 
     if (manuallyDestroyProvider) {
@@ -349,6 +349,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> {};
 
@@ -366,7 +385,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;
         }
     };
diff --git a/test/memoryProviderAPI.cpp b/test/memoryProviderAPI.cpp
index 720f11b41..e35fc5282 100644
--- a/test/memoryProviderAPI.cpp
+++ b/test/memoryProviderAPI.cpp
@@ -14,7 +14,7 @@
 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);
@@ -30,47 +30,47 @@ TEST_F(test, memoryProviderTrace) {
     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);
+    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["name"], 1UL);
     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 +78,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 +104,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 +117,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 +138,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 +169,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 +238,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 +246,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 +254,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 +262,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 +270,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 +278,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 +286,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);
@@ -330,7 +335,7 @@ INSTANTIATE_TEST_SUITE_P(
 
 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;
         }
     };
diff --git a/test/memspaces/mempolicy.cpp b/test/memspaces/mempolicy.cpp
index 7b9c4891d..2cde749be 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_highest_bandwidth.cpp b/test/memspaces/memspace_highest_bandwidth.cpp
index 5c30696a8..d4d3cd8a9 100644
--- a/test/memspaces/memspace_highest_bandwidth.cpp
+++ b/test/memspaces/memspace_highest_bandwidth.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,6 +7,7 @@
 #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) {
@@ -49,3 +50,80 @@ INSTANTIATE_TEST_SUITE_P(memspaceLowestLatencyProviderTest,
                          ::testing::Values(memspaceGetParams{
                              canQueryBandwidth,
                              umfMemspaceHighestBandwidthGet}));
+
+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_numa.cpp b/test/memspaces/memspace_numa.cpp
index 068df6886..be961fb89 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
 
@@ -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/poolFixtures.hpp b/test/poolFixtures.hpp
index 5f39e021d..23f519ecc 100644
--- a/test/poolFixtures.hpp
+++ b/test/poolFixtures.hpp
@@ -8,6 +8,7 @@
 #include <array>
 #include <cstring>
 #include <functional>
+#include <list>
 #include <random>
 #include <string>
 #include <thread>
@@ -28,8 +29,8 @@ 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 *,
+    std::tuple<const umf_memory_pool_ops_t *, pfnPoolParamsCreate,
+               pfnPoolParamsDestroy, const umf_memory_provider_ops_t *,
                pfnProviderParamsCreate, pfnProviderParamsDestroy>;
 
 umf_test::pool_unique_handle_t poolCreateExtUnique(poolCreateExtParams params) {
@@ -687,4 +688,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", pool_get,
+                         &alloc_count, sizeof(alloc_count));
+    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", pool_get,
+                        &alloc_count, sizeof(alloc_count));
+        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", pool_get,
+                    &alloc_count, sizeof(alloc_count));
+    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", pool_get,
+                            &alloc_count, sizeof(alloc_count));
+            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", pool_get,
+                        &alloc_count, sizeof(alloc_count));
+        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", pool_get,
+                        &alloc_count, sizeof(alloc_count));
+        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", pool_get,
+                            &alloc_count, sizeof(alloc_count));
+            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", pool_get,
+                        &alloc_count, sizeof(alloc_count));
+        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", pool_get,
+                            &alloc_count, sizeof(alloc_count));
+            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", pool_get,
+                        &alloc_count, sizeof(alloc_count));
+        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 9bdef4f13..7780846ce 100644
--- a/test/pools/disjoint_pool.cpp
+++ b/test/pools/disjoint_pool.cpp
@@ -4,6 +4,8 @@
 
 #include <memory>
 
+#include <umf/base.h>
+#include <umf/memory_pool.h>
 #include <umf/pools/pool_disjoint.h>
 
 #include "pool.hpp"
@@ -33,7 +35,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 +58,14 @@ 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);
     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 +97,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;
 
@@ -243,8 +245,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 +255,7 @@ TEST_F(test, sharedLimits) {
     }
 
     EXPECT_EQ(MaxSize / SlabMinSize * 2, numAllocs);
-    EXPECT_EQ(0, numFrees);
+    EXPECT_EQ((size_t)0, numFrees);
 
     ptrs.clear();
 
@@ -327,6 +329,33 @@ 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_provider_handle_t provider_handle = nullptr;
+    umf_memory_pool_handle_t pool = NULL;
+
+    struct memory_provider : public umf_test::provider_base_t {};
+
+    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 =
+        umfPoolCreate(umfDisjointPoolOps(), provider_handle, params, 0, &pool);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+    const char *name = umfPoolGetName(pool);
+    EXPECT_STREQ(name, "disjoint");
+
+    umfPoolDestroy(pool);
+    umfDisjointPoolParamsDestroy(params);
+}
+
 INSTANTIATE_TEST_SUITE_P(disjointPoolTests, umfPoolTest,
                          ::testing::Values(poolCreateExtParams{
                              umfDisjointPoolOps(), defaultDisjointPoolConfig,
diff --git a/test/pools/disjoint_pool_ctl.cpp b/test/pools/disjoint_pool_ctl.cpp
new file mode 100644
index 000000000..e683b9bc0
--- /dev/null
+++ b/test/pools/disjoint_pool_ctl.cpp
@@ -0,0 +1,151 @@
+// 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/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 "base.hpp"
+#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, disjointCtlName) {
+    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!";
+    }
+
+    // Set default name
+    const char *val = "disjoint_new_name";
+    ASSERT_SUCCESS(umfCtlSet("umf.pool.default.disjoint.name", NULL,
+                             (void *)val, strlen(val)));
+
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    ASSERT_SUCCESS(umfDisjointPoolParamsCreate(&params));
+    PoolWrapper poolWrapper(providerWrapper.get(), umfDisjointPoolOps(),
+                            params);
+
+    // Check that the default name is correctly set
+    const char *name = umfPoolGetName(poolWrapper.get());
+    ASSERT_STREQ(name, val);
+
+    // Clean up
+    ASSERT_SUCCESS(umfDisjointPoolParamsDestroy(params));
+    ASSERT_SUCCESS(umfOsMemoryProviderParamsDestroy(os_memory_provider_params));
+}
+
+TEST_F(test, disjointCtlChangeNameTwice) {
+    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!";
+    }
+    // Set default name
+    const char *val = "disjoint_new_name";
+    const char *val2 = "another_name";
+    ASSERT_SUCCESS(umfCtlSet("umf.pool.default.disjoint.name", NULL,
+                             (void *)val, strlen(val)));
+    ASSERT_SUCCESS(umfCtlSet("umf.pool.default.disjoint.name", NULL,
+                             (void *)val2, strlen(val2)));
+
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    ASSERT_SUCCESS(umfDisjointPoolParamsCreate(&params));
+    PoolWrapper poolWrapper(providerWrapper.get(), umfDisjointPoolOps(),
+                            params);
+
+    // Check that the default name is correctly set
+    const char *name = umfPoolGetName(poolWrapper.get());
+    ASSERT_STREQ(name, val2);
+
+    // Clean up
+    ASSERT_SUCCESS(umfDisjointPoolParamsDestroy(params));
+    ASSERT_SUCCESS(umfOsMemoryProviderParamsDestroy(os_memory_provider_params));
+}
diff --git a/test/pools/jemalloc_pool.cpp b/test/pools/jemalloc_pool.cpp
index 8112f36bf..69c4cf1a8 100644
--- a/test/pools/jemalloc_pool.cpp
+++ b/test/pools/jemalloc_pool.cpp
@@ -55,16 +55,39 @@ 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}));
 
 // this test makes sure that jemalloc does not use
 // memory provider to allocate metadata (and hence
@@ -119,3 +142,48 @@ 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);
+}
diff --git a/test/pools/pool_base_alloc.cpp b/test/pools/pool_base_alloc.cpp
index 441ab37ec..574803fd3 100644
--- a/test/pools/pool_base_alloc.cpp
+++ b/test/pools/pool_base_alloc.cpp
@@ -31,7 +31,7 @@ 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 {
+    size_t malloc_usable_size(const void *ptr) noexcept {
         return umf_ba_global_malloc_usable_size(ptr);
     }
     umf_result_t free(void *ptr) noexcept {
diff --git a/test/pools/scalable_pool.cpp b/test/pools/scalable_pool.cpp
index 54c0128a4..5f392da46 100644
--- a/test/pools/scalable_pool.cpp
+++ b/test/pools/scalable_pool.cpp
@@ -43,7 +43,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 +57,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 =
@@ -166,3 +166,24 @@ INSTANTIATE_TEST_SUITE_P(
     testing::Combine(testing::Values(2 * 1024 * 1024, 3 * 1024 * 1024,
                                      4 * 1024 * 1024, 5 * 1024 * 1024),
                      testing::Values(false, true)));
+
+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 = umfPoolGetName(pool);
+    EXPECT_STREQ(name, "scalable");
+
+    umfPoolDestroy(pool);
+    umfMemoryProviderDestroy(provider);
+    umfOsMemoryProviderParamsDestroy(provider_params);
+}
diff --git a/test/provider_devdax_memory.cpp b/test/provider_devdax_memory.cpp
index 6efeef90c..41724fd91 100644
--- a/test/provider_devdax_memory.cpp
+++ b/test/provider_devdax_memory.cpp
@@ -43,7 +43,8 @@ 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 *>;
+using providerCreateExtParams =
+    std::tuple<const umf_memory_provider_ops_t *, void *>;
 
 static void providerCreateExt(providerCreateExtParams params,
                               umf_test::provider_unique_handle_t *handle) {
@@ -234,7 +235,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);
diff --git a/test/provider_devdax_memory_not_impl.cpp b/test/provider_devdax_memory_not_impl.cpp
index 3b97443a0..4687825d3 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
 
@@ -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 bcc9d2645..244544731 100644
--- a/test/provider_file_memory.cpp
+++ b/test/provider_file_memory.cpp
@@ -39,7 +39,8 @@ 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 *>;
+using providerCreateExtParams =
+    std::tuple<const umf_memory_provider_ops_t *, void *>;
 
 static void providerCreateExt(providerCreateExtParams params,
                               umf_test::provider_unique_handle_t *handle) {
diff --git a/test/provider_file_memory_ipc.cpp b/test/provider_file_memory_ipc.cpp
index 90623a179..0408b2fe2 100644
--- a/test/provider_file_memory_ipc.cpp
+++ b/test/provider_file_memory_ipc.cpp
@@ -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(),
@@ -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(),
diff --git a/test/provider_file_memory_not_impl.cpp b/test/provider_file_memory_not_impl.cpp
index c82b8163c..c0bde74e2 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
 
@@ -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 dac651435..83727de2b 100644
--- a/test/provider_fixed_memory.cpp
+++ b/test/provider_fixed_memory.cpp
@@ -38,7 +38,8 @@ 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 *>;
+using providerCreateExtParams =
+    std::tuple<const umf_memory_provider_ops_t *, void *>;
 
 static void providerCreateExt(providerCreateExtParams params,
                               umf_test::provider_unique_handle_t *handle) {
@@ -239,6 +240,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) {
@@ -333,11 +339,105 @@ TEST_F(test, create_with_zero_size) {
     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(
+        &params, memory_buffer1, memory_size1);
+    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(
+        &valid_params, memory_buffer, memory_size);
+    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;
@@ -437,14 +537,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) {
@@ -490,12 +592,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 f3552b923..96396c18f 100644
--- a/test/provider_os_memory.cpp
+++ b/test/provider_os_memory.cpp
@@ -44,7 +44,8 @@ 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 *>;
+using providerCreateExtParams =
+    std::tuple<const umf_memory_provider_ops_t *, void *>;
 
 static void providerCreateExt(providerCreateExtParams params,
                               umf_test::provider_unique_handle_t *handle) {
@@ -461,14 +462,40 @@ 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
 };
 
diff --git a/test/provider_os_memory_not_impl.cpp b/test/provider_os_memory_not_impl.cpp
index 13c123fb7..127ba32e4 100644
--- a/test/provider_os_memory_not_impl.cpp
+++ b/test/provider_os_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
 
@@ -41,6 +41,6 @@ TEST_F(test, os_provider_not_implemented) {
     umf_result = umfOsMemoryProviderParamsSetPartitions(params, partitions, 1);
     EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
 
-    umf_memory_provider_ops_t *ops = umfOsMemoryProviderOps();
+    const umf_memory_provider_ops_t *ops = umfOsMemoryProviderOps();
     EXPECT_EQ(ops, nullptr);
 }
diff --git a/test/provider_tracking.cpp b/test/provider_tracking.cpp
index 55acc452c..b41ff6012 100644
--- a/test/provider_tracking.cpp
+++ b/test/provider_tracking.cpp
@@ -19,7 +19,8 @@ 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 *>;
+using providerCreateExtParams =
+    std::tuple<const umf_memory_provider_ops_t *, void *>;
 
 static void providerCreateExt(providerCreateExtParams params,
                               umf_test::provider_unique_handle_t *handle) {
@@ -151,8 +152,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 +186,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 +217,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 +259,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 +296,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 +337,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 +378,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 d81d4f8b1..8ab708275 100644
--- a/test/provider_tracking_fixture_tests.cpp
+++ b/test/provider_tracking_fixture_tests.cpp
@@ -21,11 +21,12 @@
 
 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 {
+    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 {
diff --git a/test/providers/provider_cuda.cpp b/test/providers/provider_cuda.cpp
index a7e5dbe5a..00d8e9d8f 100644
--- a/test/providers/provider_cuda.cpp
+++ b/test/providers/provider_cuda.cpp
@@ -383,6 +383,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);
diff --git a/test/providers/provider_cuda_not_impl.cpp b/test/providers/provider_cuda_not_impl.cpp
index 4054c26a8..9ddea2048 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 47b62cc94..e30500d9d 100644
--- a/test/providers/provider_level_zero.cpp
+++ b/test/providers/provider_level_zero.cpp
@@ -116,7 +116,7 @@ INSTANTIATE_TEST_SUITE_P(, LevelZeroProviderInit,
                                            UMF_MEMORY_TYPE_SHARED));
 
 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 +146,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 +171,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();
@@ -196,7 +196,7 @@ TEST_F(LevelZeroProviderInit, FailNonNullDevice) {
 }
 
 TEST_F(test, FailMismatchedResidentHandlesCount) {
-    umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
+    const umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
     ASSERT_NE(ops, nullptr);
 
     umf_level_zero_memory_provider_params_handle_t hParams = nullptr;
diff --git a/test/providers/provider_level_zero_not_impl.cpp b/test/providers/provider_level_zero_not_impl.cpp
index 4948bd66f..dfbd4a2b2 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/supp/drd-test_disjoint_pool.supp b/test/supp/drd-test_disjoint_pool.supp
deleted file mode 100644
index 2a5548d27..000000000
--- 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 fbdbd0183..e55b2ee8d 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 fbdbd0183..e55b2ee8d 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 8d8746861..cb6179f87 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 8d8746861..cb6179f87 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 9883001f7..2252cb021 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 65dfdd2c7..917237d7e 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 25ae87ea4..fb17fd7a0 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 25ae87ea4..fb17fd7a0 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 2f4980f51..98d748fea 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 2f4980f51..98d748fea 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 11791e4ed..63e7d626c 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 3f8371d8d..07c8cd979 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 e6141c135..14409bbfc 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 4cf789000..cba8a4fb3 100644
--- a/test/test_installation.py
+++ b/test/test_installation.py
@@ -125,6 +125,9 @@ def _create_match_list(self) -> List[str]:
                 )
                 lib.append(f"lib/{lib_prefix}umf.{self.umf_version}.{lib_ext_shared}")
         else:
+            lib.append(f"lib/{lib_prefix}umf_ba.{lib_ext_static}")
+            lib.append(f"lib/{lib_prefix}umf_coarse.{lib_ext_static}")
+            lib.append(f"lib/{lib_prefix}umf_utils.{lib_ext_static}")
             lib.append(f"lib/{lib_prefix}umf.{lib_ext_static}")
             if self.umfd_lib and platform.system() == "Windows":
                 lib.append(f"lib/{lib_prefix}umfd.{lib_ext_static}")
@@ -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_valgrind.sh b/test/test_valgrind.sh
index 2e4f655f6..cff45bdec 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"
 	;;
@@ -150,6 +158,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 037c633c1..ae18d7b1b 100644
--- a/test/utils/cpp_helpers.hpp
+++ b/test/utils/cpp_helpers.hpp
@@ -68,7 +68,10 @@ 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));
@@ -82,22 +85,25 @@ template <typename T> umf_memory_pool_ops_t poolOpsBase() {
 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_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, 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);
     return ops;
 }
 } // namespace detail
@@ -109,7 +115,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 +129,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 +143,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 +156,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/third_party/requirements.txt b/third_party/requirements.txt
index 467ea1e03..1893e962d 100644
--- a/third_party/requirements.txt
+++ b/third_party/requirements.txt
@@ -1,10 +1,11 @@
 # Python requirements modules
 # Formatting the source code
+bandit==1.8.3
+black==24.3.0
 clang-format==15.0.7
 cmake-format==0.6.13
-black==24.3.0
 # Tests
-packaging==24.2
+packaging==25.0
 # Generating HTML documentation
 pygments==2.19.1
 sphinxcontrib_applehelp==2.0.0
@@ -16,5 +17,6 @@ breathe==4.36.0
 sphinx==8.1.3
 sphinx_book_theme==1.1.3
 # Spelling check in documentation
+codespell==2.4.1
 pyenchant==3.2.2
 sphinxcontrib-spelling==8.0.1