diff --git a/.cmake-format b/.cmake-format
index 57ad821ef..ed478467a 100644
--- a/.cmake-format
+++ b/.cmake-format
@@ -9,31 +9,33 @@ with section("parse"):
       "pargs": 0,
       "flags": [],
       'kwargs': {
-        'NAME': '*', 
-        'SRCS': '*', 
-        'LIBS': '*' , 
-        'LIBDIRS': '*'}},
+        'NAME': '*',
+        'SRCS': '*',
+        'LIBS': '*' ,
+        'LIBDIRS': '*',
+        'TESTARGS': '*'}},
     'add_umf_executable': {
       "pargs": 0,
       "flags": [],
       'kwargs': {
-        'NAME': '*', 
-        'SRCS': '*', 
+        'NAME': '*',
+        'SRCS': '*',
         'LIBS': '*'}},
     'add_umf_test': {
       "pargs": 0,
       "flags": [],
       'kwargs': {
-        'NAME': '*', 
-        'SRCS': '*', 
-        'LIBS': '*'}},
+        'NAME': '*',
+        'SRCS': '*',
+        'LIBS': '*',
+        'ENVS': '*'}},
     'add_umf_library': {
       "pargs": 0,
       "flags": [],
       'kwargs': {
-        'NAME': '*', 
-        'TYPE': '*', 
-        'SRCS': '*', 
+        'NAME': '*',
+        'TYPE': '*',
+        'SRCS': '*',
         'LIBS': '*',
         'LINUX_MAP_FILE': '*',
         'WINDOWS_DEF_FILE': '*'}},
@@ -43,7 +45,20 @@ with section("parse"):
       'kwargs': {
         'LABELS': '*', 
         'PASS_REGULAR_EXPRESSION': '*'}},
-  }    
+    'build_umf_test': {
+      "pargs": 0,
+      "flags": [],
+      'kwargs': {
+        'NAME': '*',
+        'SRCS': '*',
+        'LIBS': '*' }},
+    'add_umf_ipc_test': {
+      "pargs": 0,
+      "flags": [],
+      'kwargs': {
+        'TEST': '*',
+        'SRC_DIR': '*'}},
+  }
 
   # Override configurations per-command where available
   override_spec = {}
diff --git a/.github/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 069deeac9..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="\
-	libjemalloc-dev \
-	libhwloc-dev \
-	libtbb-dev"
+# Hwloc installation dependencies
+ARG HWLOC_DEPS="\
+	libtool"
 
 # Dependencies for tests (optional)
 ARG TEST_DEPS="\
-	libnuma-dev"
+	libnuma-dev \
+	libtbb-dev \
+	valgrind"
 
 # Miscellaneous for our builds/CI (optional)
 ARG MISC_DEPS="\
+	automake \
 	clang \
 	g++-7 \
+	lcov \
 	python3-pip \
 	sudo \
 	whois"
 
+# libhwloc-dev is required - installed via script because hwloc version is too old on this OS
+COPY .github/scripts/install_hwloc.sh /opt/umf/install_hwloc.sh
+
 # Update and install required packages
 RUN apt-get update \
  && apt-get install -y --no-install-recommends \
 	${BASE_DEPS} \
-	${UMF_DEPS} \
 	${TEST_DEPS} \
 	${MISC_DEPS} \
+	${HWLOC_DEPS} \
+ && /opt/umf/install_hwloc.sh \
  && rm -rf /var/lib/apt/lists/* \
  && apt-get clean all
 
 # Prepare a dir (accessible by anyone)
-RUN mkdir --mode 777 /opt/umf/
+RUN mkdir -p --mode 777 /opt/umf/
 
 # Additional dependencies (installed via pip)
+# It's actively used and tested only on selected distros. Be aware
+# they may not work, because pip packages list differ from OS to OS.
 COPY third_party/requirements.txt /opt/umf/requirements.txt
-RUN pip3 install --no-cache-dir -r /opt/umf/requirements.txt
 
 # Add a new (non-root) 'test_user'
 ENV USER test_user
 ENV USERPASS pass
-RUN useradd -m "${USER}" -g sudo -p "$(mkpasswd ${USERPASS})"
+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 08d546083..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="\
-	libjemalloc-dev \
-	libhwloc-dev \
-	libtbb-dev"
+	libhwloc-dev"
 
 # Dependencies for tests (optional)
 ARG TEST_DEPS="\
-	libnuma-dev"
+	libnuma-dev \
+	libtbb-dev \
+	valgrind"
 
 # Miscellaneous for our builds/CI (optional)
 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/pull_request_template.md b/.github/pull_request_template.md
index 89e814856..35a7f05b6 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -36,3 +36,4 @@ Before checking all the boxes please mark the PR as draft.
 - [ ] All newly added source files have a license
 - [ ] All newly added source files are referenced in CMake files
 - [ ] Logger (with debug/info/... messages) is used
+- [ ] All API changes are reflected in docs and def/map files, and are tested
diff --git a/.github/scripts/get_system_info.sh b/.github/scripts/get_system_info.sh
index 595d5e31a..573c7195d 100755
--- a/.github/scripts/get_system_info.sh
+++ b/.github/scripts/get_system_info.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
-# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -7,7 +7,7 @@
 
 function check_L0_version {
     if command -v dpkg &> /dev/null; then
-        dpkg -l | grep level-zero && return
+        dpkg -l | grep -iE "level-zero|libze|Compute Runtime|Level Zero" && return
     fi
 
     if command -v rpm &> /dev/null; then
@@ -15,7 +15,7 @@ function check_L0_version {
     fi
 
     if command -v zypper &> /dev/null; then
-        zypper se level-zero && return
+        zypper -n se level-zero || true
     fi
 
     echo "level-zero not installed"
@@ -26,32 +26,32 @@ function system_info {
 	cat /etc/os-release | grep -oP "PRETTY_NAME=\K.*"
 	cat /proc/version
 
-	# echo "**********SYCL-LS**********"
-	# source /opt/intel/oneapi/setvars.sh
-	# sycl-ls
+	echo "**********SYCL-LS**********"
+	source /opt/intel/oneapi/setvars.sh
+	sycl-ls
 
 	echo "**********numactl topology**********"
 	numactl -H
 
 	echo "**********VGA info**********"
-	lspci | grep -i VGA
+	lspci | grep -iE "vga|display|gpu"
 
-	# echo "**********CUDA Version**********"
-	# if command -v nvidia-smi &> /dev/null; then
-	# 	nvidia-smi
-	# else
-	# 	echo "CUDA not installed"
-	# fi
+	echo "**********CUDA Version**********"
+	if command -v nvidia-smi &> /dev/null; then
+		nvidia-smi
+	else
+		echo "CUDA not installed"
+	fi
 
 	echo "**********L0 Version**********"
 	check_L0_version
 
-	# echo "**********ROCm Version**********"
-	# if command -v rocminfo &> /dev/null; then
-	# 	rocminfo
-	# else
-	# 	echo "ROCm not installed"
-	# fi
+	echo "**********ROCm Version**********"
+	if command -v rocminfo &> /dev/null; then
+		rocminfo
+	else
+		echo "ROCm not installed"
+	fi
 
 	echo "******OpenCL*******"
 	# The driver version of OpenCL Graphics is the compute-runtime version
@@ -67,11 +67,15 @@ function system_info {
 	cat /proc/meminfo
 
 	echo "**********env variables**********"
-	echo "PATH=${PATH}"
-	echo "CPATH=${CPATH}"
-	echo "LD_LIBRARY_PATH=${LD_LIBRARY_PATH}"
-	echo "LIBRARY_PATH=${LIBRARY_PATH}"
-	echo "PKG_CONFIG_PATH=${PKG_CONFIG_PATH}"
+	echo "PATH=$PATH"
+	echo
+	echo "CPATH=$CPATH"
+	echo
+	echo "LD_LIBRARY_PATH=$LD_LIBRARY_PATH"
+	echo
+	echo "LIBRARY_PATH=$LIBRARY_PATH"
+	echo
+	echo "PKG_CONFIG_PATH=$PKG_CONFIG_PATH"
 	echo
 
 	echo "******build tools versions*******"
diff --git a/.github/scripts/install_oneAPI.sh b/.github/scripts/install_oneAPI.sh
new file mode 100755
index 000000000..f2331e2eb
--- /dev/null
+++ b/.github/scripts/install_oneAPI.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+# Copyright (C) 2025 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+# install_oneAPI.sh - Script for installing Intel oneAPI from the official repository
+
+apt-get update
+apt-get install -y gpg-agent gnupg wget
+wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB | gpg --dearmor -o /usr/share/keyrings/oneapi-archive-keyring.gpg
+echo 'deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main' > /etc/apt/sources.list.d/oneAPI.list
+apt-get update
+apt-get install -y intel-oneapi-ippcp-devel intel-oneapi-ipp-devel intel-oneapi-common-oneapi-vars intel-oneapi-compiler-dpcpp-cpp
diff --git a/.github/scripts/run-codespell.py b/.github/scripts/run-codespell.py
new file mode 100644
index 000000000..b87bf37bd
--- /dev/null
+++ b/.github/scripts/run-codespell.py
@@ -0,0 +1,40 @@
+"""
+ Copyright (C) 2024 Intel Corporation
+
+ Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""
+
+import subprocess  # nosec B404
+import logging
+import sys
+
+logging.basicConfig(
+    level=logging.INFO, format="[%(levelname)s]: [%(asctime)s] %(message)s"
+)
+
+
+def codespell_scan():
+    try:
+        codespell_result = subprocess.run(  # nosec
+            [
+                "codespell",
+                "-H",
+                "--quiet-level=3",
+                "--skip=./.git,./.venv,./.github/workflows/.spellcheck-conf.toml",
+            ],
+            text=True,
+            stdout=subprocess.PIPE,
+        )
+        if codespell_result.returncode != 0:
+            for line in codespell_result.stdout.splitlines():
+                logging.error(line.strip())
+            sys.exit(1)
+        else:
+            logging.info("No spelling errors found")
+    except subprocess.CalledProcessError as ex:
+        logging.error(ex)
+        sys.exit(1)
+
+
+codespell_scan()
diff --git a/.github/workflows/.spellcheck-conf.toml b/.github/workflows/.spellcheck-conf.toml
index 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/bandit.yml b/.github/workflows/bandit.yml
deleted file mode 100644
index 80b383665..000000000
--- a/.github/workflows/bandit.yml
+++ /dev/null
@@ -1,35 +0,0 @@
-# Bandit static analysis (for Python code)
-name: Bandit
-on:
-  push:
-    branches-ignore:
-      - 'dependabot/**'
-  pull_request:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-
-jobs:
-  bandit:
-    name: Bandit
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest]
-    runs-on: ${{matrix.os}}
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      with:
-        fetch-depth: 0
-
-    - name: Install Bandit
-      run: python3 -m pip install bandit
-
-    # Run Bandit recursively, but omit _deps directory (with 3rd party code)
-    - name: Run Bandit
-      run: python3 -m bandit -r . -x '/_deps/'
diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml
index de48173bf..6f540ae39 100644
--- a/.github/workflows/benchmarks.yml
+++ b/.github/workflows/benchmarks.yml
@@ -1,79 +1,45 @@
-# Executes benchmarks implemented in this repository
-name: Benchmarks
-
-on: workflow_call
+name: Compute Benchmarks
+
+on:
+  workflow_dispatch:
+    inputs:
+      pr_no:
+        description: PR number (if 0, it'll run on the main)
+        type: number
+      bench_script_params:
+        # If you want to save the results of the manual run in 'benchmark-results' branch,
+        # you have to pass '--save XXX', where XXX is the label of your results.
+        description: Parameters passed to script executing benchmark
+        type: string
+        required: false
+        default: ''
+      bench_script_compare:
+        description: Compare label, passed to script executing benchmark as '--compare <label>'
+        type: choice
+        required: false
+        default: 'Baseline_PVC'
+        options:
+          - 'Baseline_PVC'
+      runner:
+        description: Runner
+        type: choice
+        required: true
+        default: 'L0_PERF_PVC'
+        options:
+          - L0_PERF_PVC
 
 permissions:
   contents: read
 
-env:
-  BUILD_DIR : "${{github.workspace}}/build"
-  INSTL_DIR : "${{github.workspace}}/../install-dir"
-
 jobs:
-  benchmarks:
-    name: Benchmarks
-    env:
-      VCPKG_PATH: "${{github.workspace}}/build/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows"
-    strategy:
-      matrix:
-        os: ['ubuntu-latest', 'windows-latest']
-        include: 
-          # Windows doesn't recognize 'CMAKE_BUILD_TYPE', it uses '--config' param in build command to determine the build type
-          - os: ubuntu-latest
-            extra_build_option: '-DCMAKE_BUILD_TYPE=Release'
-    runs-on: ${{matrix.os}}
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-        with:
-          fetch-depth: 0
-
-      - name: Install apt packages
-        if: matrix.os == 'ubuntu-latest'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y cmake libhwloc-dev libnuma-dev libjemalloc-dev libtbb-dev
-
-      - name: Initialize vcpkg
-        if: matrix.os == 'windows-latest'
-        uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
-        with:
-          vcpkgGitCommitId: 3dd44b931481d7a8e9ba412621fa810232b66289
-          vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
-          vcpkgJsonGlob: '**/vcpkg.json'
-
-      - name: Install vcpkg packages
-        if: matrix.os == 'windows-latest'
-        run: vcpkg install
-        shell: pwsh # Specifies PowerShell as the shell for running the script.
-
-      - name: Configure build
-        run: >
-          cmake
-          -B ${{env.BUILD_DIR}}
-          ${{matrix.extra_build_option}}
-          -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
-          -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
-          -DUMF_BUILD_SHARED_LIBRARY=ON
-          -DUMF_BUILD_BENCHMARKS=ON
-          -DUMF_BUILD_BENCHMARKS_MT=ON
-          -DUMF_BUILD_TESTS=OFF
-          -DUMF_FORMAT_CODE_STYLE=OFF
-          -DUMF_DEVELOPER_MODE=OFF
-          -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
-          -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
-          -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
-
-      - name: Build UMF on Linux
-        if: matrix.os == 'ubuntu-latest'
-        run: cmake --build ${{env.BUILD_DIR}} -j $(nproc)
-
-      - name: Build UMF on Windows
-        if: matrix.os == 'windows-latest'
-        run: cmake --build ${{env.BUILD_DIR}} --config Release -j $Env:NUMBER_OF_PROCESSORS
-
-      - name: Run benchmarks
-        working-directory: ${{env.BUILD_DIR}}
-        run: ctest -V --test-dir benchmark -C Release
+  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 }}
+      bench_script_compare: ${{ inputs.bench_script_compare }}
+      runner: ${{ inputs.runner }}
diff --git a/.github/workflows/coverity.yml b/.github/workflows/coverity.yml
index f6fe2ad26..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,10 +18,12 @@ permissions:
 jobs:
   coverity:
     name: Coverity
+    # 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
@@ -29,15 +31,17 @@ jobs:
     - name: Install apt packages
       run: |
         sudo apt-get update
-        sudo apt-get install -y cmake hwloc libhwloc-dev libjemalloc-dev libnuma-dev libtbb-dev
+        sudo apt-get install -y cmake hwloc libhwloc-dev libnuma-dev libtbb-dev
 
     - name: Download Coverity
-      run: |
-        wget -nv https://scan.coverity.com/download/linux64 --post-data "token=${{ secrets.COVERITY_SCAN_TOKEN }}&project=oneapi-src%2Funified-memory-framework" -O coverity_tool.tgz
+      run: >
+        wget
+        -O coverity_tool.tgz
+        -nv https://scan.coverity.com/download/linux64
+        --post-data "token=${{ secrets.COVERITY_SCAN_TOKEN }}&project=oneapi-src%2Funified-memory-framework"
 
     - name: Extract Coverity
-      run: |
-        tar xzf coverity_tool.tgz
+      run: tar xzf coverity_tool.tgz
 
     - name: Configure CMake
       run: >
@@ -47,7 +51,6 @@ jobs:
         -DUMF_FORMAT_CODE_STYLE=OFF
         -DUMF_DEVELOPER_MODE=OFF
         -DUMF_TESTS_FAIL_ON_SKIP=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
 
     - name: Build
@@ -59,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..4c1c9d4bf
--- /dev/null
+++ b/.github/workflows/detect_changes.yml
@@ -0,0 +1,45 @@
+name: DetectChanges
+
+on:
+  pull_request:
+    paths:
+      - '.github/docker/*.Dockerfile'
+      - '.github/scripts/*'
+  push:
+    paths:
+      - '.github/docker/*.Dockerfile'
+      - '.github/scripts/*'
+
+permissions:
+  contents: read
+  packages: read
+
+jobs:
+  DetectChanges:
+    runs-on: ubuntu-latest
+    outputs:
+      changed_files: ${{ steps.changed-files.outputs.all_changed_files }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@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 4fdd89766..196fae109 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -4,6 +4,7 @@ name: GitHubPages
 on:
   push:
     branches: ["main"]
+  workflow_dispatch:
 
 # Cancel previous in-progress workflow, only the latest run is relevant
 concurrency:
@@ -14,36 +15,14 @@ permissions:
   contents: read
 
 jobs:
-  build:
-    name: Build docs
-    runs-on: ubuntu-latest
+  DocsBuild:
+    uses: ./.github/workflows/reusable_docs_build.yml
+    with:
+      upload: true
 
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      with:
-        fetch-depth: 0
-
-    - name: Install doxygen
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y doxygen
-
-    - name: Install pip requirements
-      run: python3 -m pip install -r third_party/requirements.txt
-
-    - name: Build the documentation
-      working-directory: scripts
-      run: python3 generate_docs.py
-
-    - name: Upload artifact
-      uses: actions/upload-pages-artifact@0252fc4ba7626f0298f0cf00902a25c6afc77fa8 # v3.0.0
-      with:
-        path: docs/html
-
-  deploy:
+  DocsDeploy:
     name: Deploy docs to GitHub Pages
-    needs: build
+    needs: DocsBuild
 
     permissions:
       pages: write
@@ -53,9 +32,9 @@ jobs:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}
 
-    runs-on: ubuntu-latest
+    runs-on: ${{ github.repository_owner == 'oneapi-src' && 'intel-ubuntu-22.04' || 'ubuntu-latest' }}
 
     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/gpu.yml b/.github/workflows/gpu.yml
deleted file mode 100644
index 3024b9f7e..000000000
--- a/.github/workflows/gpu.yml
+++ /dev/null
@@ -1,102 +0,0 @@
-# This workflow builds and tests providers using GPU memory. It requires 
-# "level_zero" labeled self-hosted runners installed on systems with the 
-# appropriate GPU and drivers.
-name: GPU
-
-on: [workflow_call]
-
-permissions:
-  contents: read
-
-env:
-  BUILD_DIR : "${{github.workspace}}/build"
-  INSTL_DIR : "${{github.workspace}}/../install-dir"
-
-jobs:
-  gpu:
-    name: Build
-    env:
-      BUILD_TYPE: Release
-      VCPKG_PATH: "${{github.workspace}}/../../../../vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/../../../../vcpkg/packages/tbb_x64-windows;${{github.workspace}}/../../../../vcpkg/packages/jemalloc_x64-windows"
-    # run only on upstream; forks will not have the HW
-    if: github.repository == 'oneapi-src/unified-memory-framework'
-    strategy:
-      matrix:
-        shared_library: ['ON', 'OFF']
-        os: ['Ubuntu', 'Windows']
-        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-LEVEL_ZERO", "DSS-${{matrix.os}}"]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-        with:
-          fetch-depth: 0
-
-      - name: Get information about platform
-        if: matrix.os == 'Ubuntu'
-        run: .github/scripts/get_system_info.sh
-
-      - name: Configure build for Win
-        if: matrix.os == 'Windows'
-        run: >
-          cmake
-          -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
-          -B ${{env.BUILD_DIR}}
-          -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
-          -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
-          -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
-          -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
-          -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}}
-          -DUMF_BUILD_BENCHMARKS=ON
-          -DUMF_BUILD_TESTS=ON
-          -DUMF_BUILD_GPU_TESTS=ON
-          -DUMF_BUILD_GPU_EXAMPLES=ON
-          -DUMF_FORMAT_CODE_STYLE=OFF
-          -DUMF_DEVELOPER_MODE=ON
-          -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
-          -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
-          -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
-          -DUMF_TESTS_FAIL_ON_SKIP=ON
-      
-      - name: Configure build for Ubuntu
-        if: matrix.os == 'Ubuntu'
-        run: >
-          cmake
-          -B ${{env.BUILD_DIR}}
-          -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
-          -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
-          -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
-          -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
-          -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}}
-          -DUMF_BUILD_BENCHMARKS=ON
-          -DUMF_BUILD_TESTS=ON
-          -DUMF_BUILD_GPU_TESTS=ON
-          -DUMF_BUILD_GPU_EXAMPLES=ON
-          -DUMF_FORMAT_CODE_STYLE=OFF
-          -DUMF_DEVELOPER_MODE=ON
-          -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
-          -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
-          -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
-          -DUMF_TESTS_FAIL_ON_SKIP=ON
-
-      - name: Build UMF
-        run: cmake --build ${{env.BUILD_DIR}} --config ${{env.BUILD_TYPE}} -j ${{matrix.number_of_processors}}
-
-      - name: Run tests
-        working-directory: ${{env.BUILD_DIR}}
-        run: ctest -C ${{env.BUILD_TYPE}} --output-on-failure --test-dir test
-
-      - name: Run examples
-        working-directory: ${{env.BUILD_DIR}}
-        run: ctest --output-on-failure --test-dir examples -C ${{env.BUILD_TYPE}}
-
-      - name: Run benchmarks
-        working-directory: ${{env.BUILD_DIR}}
-        run: ctest --output-on-failure --test-dir benchmark -C ${{env.BUILD_TYPE}} --exclude-regex umf-bench-multithreaded
diff --git a/.github/workflows/multi_numa.yml b/.github/workflows/multi_numa.yml
deleted file mode 100644
index a9433018e..000000000
--- a/.github/workflows/multi_numa.yml
+++ /dev/null
@@ -1,61 +0,0 @@
-# Runs tests on multi-numa machine
-name: MultiNuma
-
-on: [workflow_call]
-
-permissions:
-  contents: read
-
-jobs:
-  multi_numa:
-    name: ${{matrix.os}}
-    # 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]
-    runs-on:  ["DSS-MULTI-NUMA", "DSS-${{matrix.os}}"]
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-        with:
-          fetch-depth: 0
-
-      - name: Get information about platform
-        run: .github/scripts/get_system_info.sh
-
-      - name: Configure build
-        run: >
-          cmake
-          -B ${{github.workspace}}/build
-          -DCMAKE_BUILD_TYPE=Debug
-          -DCMAKE_C_COMPILER=gcc
-          -DCMAKE_CXX_COMPILER=g++
-          -DUMF_BUILD_SHARED_LIBRARY=OFF
-          -DUMF_BUILD_BENCHMARKS=OFF
-          -DUMF_BUILD_TESTS=ON
-          -DUMF_DEVELOPER_MODE=ON
-          -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
-          -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
-          -DUMF_TESTS_FAIL_ON_SKIP=ON
-
-      - name: Build UMF
-        run: cmake --build ${{github.workspace}}/build -j $(nproc)
-
-      - name: Run tests
-        if: matrix.os != 'rhel-9.1'
-        working-directory: ${{github.workspace}}/build
-        run: ctest --output-on-failure --test-dir test
-
-        # On RHEL, hwloc version is just a little too low.
-        # Skip some tests until we upgrade hwloc and update CMake to properly handle local hwloc installation.
-        # TODO: fix issue #560
-      - name: Run tests (on RHEL)
-        if: matrix.os == 'rhel-9.1'
-        working-directory: ${{github.workspace}}/build
-        run: |
-          ctest --output-on-failure --test-dir test -E "umf-provider_os_memory_multiple_numa_nodes"
-          ./test/umf_test-provider_os_memory_multiple_numa_nodes \
-            --gtest_filter="-*checkModeLocal/*:*checkModePreferredEmptyNodeset/*:testNuma.checkModeInterleave"
diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
index f2bf8f08f..7a7eec9ec 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -1,73 +1,92 @@
 # Various non-standard tests, requiring e.g. longer run
 name: Nightly
 
-# This job is run at 00:00 UTC every day or on demand.
+# This job is run at 04:00 UTC every day or on demand.
 on:
   workflow_dispatch:
   schedule:
-    - cron:  '0 0 * * *'
+    - cron: '0 4 * * *'
 
 permissions:
   contents: read
+  pull-requests: read
+
+env:
+  BUILD_DIR : "${{github.workspace}}/build"
+  INSTALL_DIR: "${{github.workspace}}/build/install"
 
 jobs:
-  fuzz-test:
-      name: Fuzz test
-      strategy:
-        fail-fast: false
-        matrix:
-          build_type: [Debug, Release]
-          compiler: [{c: clang, cxx: clang++}]
-      
-      runs-on: ubuntu-latest
-
-      steps:
-      - name: Checkout repository
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-        with:
-          fetch-depth: 0
-
-      - name: Install apt packages
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y cmake hwloc libhwloc-dev libnuma-dev libtbb-dev
-
-      - name: Configure CMake
-        run: >
-          cmake
-          -B ${{github.workspace}}/build
-          -DCMAKE_BUILD_TYPE=${{matrix.build_type}}
-          -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
-          -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
-          -DUMF_TESTS_FAIL_ON_SKIP=ON
-          -DUMF_DEVELOPER_MODE=ON
-          -DUMF_BUILD_FUZZTESTS=ON
-
-      - name: Build
-        run: cmake --build ${{github.workspace}}/build --config ${{matrix.build_type}} --verbose -j$(nproc)
-
-      - 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
+  Fuzzing:
+    strategy:
+      fail-fast: false
+      matrix:
+        build_type: [Debug, Release]
+        compiler: [{c: clang, cxx: clang++}]
+    name: Fuzzing (ubuntu-latest, build_type=${{matrix.build_type}}, compilers=${{matrix.compiler.c}}/${{matrix.compiler.cxx}})
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      with:
+        fetch-depth: 0
+
+    - name: Install apt packages
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y cmake hwloc libhwloc-dev libnuma-dev libtbb-dev
+
+    - name: Find Clang fuzzer lib
+      run: |
+        CLANG_LIBS_DIR=$(find /usr/lib -name "libclang_rt.fuzzer_no_main-x86_64.a" -exec dirname {} \; | head -n 1)
+        echo "CLANG_LIBS_DIR=${CLANG_LIBS_DIR}" >> $GITHUB_ENV
+
+    - name: Configure CMake
+      run: >
+        cmake
+        -B ${{github.workspace}}/build
+        -DCMAKE_PREFIX_PATH=${{env.CLANG_LIBS_DIR}}
+        -DCMAKE_BUILD_TYPE=${{matrix.build_type}}
+        -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
+        -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_FUZZTESTS=ON
+
+    - name: Build
+      run: cmake --build ${{github.workspace}}/build --config ${{matrix.build_type}} --verbose -j$(nproc)
+
+    - name: 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:
     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
 
     - name: Install apt packages
       run: |
         sudo apt-get update
-        sudo apt-get install -y cmake hwloc libhwloc-dev libjemalloc-dev libnuma-dev libtbb-dev valgrind
+        sudo apt-get install -y cmake hwloc libhwloc-dev libnuma-dev libtbb-dev valgrind
 
     - name: Configure CMake
       run: >
@@ -75,10 +94,10 @@ jobs:
         -B ${{github.workspace}}/build
         -DCMAKE_BUILD_TYPE=Debug
         -DUMF_FORMAT_CODE_STYLE=OFF
-        -DUMF_DEVELOPER_MODE=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
+        -DUMF_DEVELOPER_MODE=OFF
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
+        -DUMF_BUILD_CUDA_PROVIDER=OFF
         -DUMF_USE_VALGRIND=1
         -DUMF_TESTS_FAIL_ON_SKIP=ON
 
@@ -87,3 +106,285 @@ jobs:
 
     - name: Run tests under valgrind
       run: ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{github.workspace}}/build ${{matrix.tool}}
+
+  # Build and test UMF with different CMake generators on Windows
+  Windows-generators:
+    strategy:
+      matrix:
+        build_type: [Debug, Release]
+        compiler: [{c: cl, cxx: cl}]
+        shared_library: ['ON', 'OFF']
+        static_hwloc: ['ON', 'OFF']
+        generator: ['Ninja', 'NMake Makefiles']
+        umfd_lib: ['ON', 'OFF']
+    name: Windows (generator=${{matrix.generator}}, compilers=${{matrix.compiler.c}}/${{matrix.compiler.cxx}}, build_type=${{matrix.build_type}}, shared_library=${{matrix.shared_library}}, static_hwloc=${{matrix.static_hwloc}}, umfd_lib=${{matrix.umfd_lib}})
+
+    runs-on: windows-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      with:
+        fetch-depth: 0
+
+    - name: Set VCPKG_PATH with hwloc
+      if: matrix.static_hwloc == 'OFF'
+      run: echo "VCPKG_PATH=${{github.workspace}}/build/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows" >> $env:GITHUB_ENV
+
+    - name: Set VCPKG_PATH without hwloc
+      if: matrix.static_hwloc == 'ON'
+      run: echo "VCPKG_PATH=${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows" >> $env:GITHUB_ENV
+
+    - name: Initialize vcpkg
+      uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
+      env: 
+        VCPKG_PATH: ${{env.VCPKG_PATH}}
+      with:
+        vcpkgGitCommitId: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
+        vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
+        vcpkgJsonGlob: '**/vcpkg.json'
+
+    - name: Install dependencies
+      run: vcpkg install --triplet x64-windows
+
+    - name: Install Ninja
+      if: matrix.generator == 'Ninja'
+      uses: seanmiddleditch/gha-setup-ninja@3b1f8f94a2f8254bd26914c4ab9474d4f0015f67 # v6
+
+    - name: Configure MSVC environment
+      uses: ilammy/msvc-dev-cmd@0b201ec74fa43914dc39ae48a89fd1d8cb592756 # v1.13.0
+
+    - name: Configure build
+      run: >
+        cmake
+        -B ${{env.BUILD_DIR}}
+        -DCMAKE_BUILD_TYPE=${{matrix.build_type}}
+        -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
+        -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
+        -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
+        -G "${{matrix.generator}}"
+        -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}}
+        -DUMF_LINK_HWLOC_STATICALLY=${{matrix.static_hwloc}}
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+        ${{ matrix.umfd_lib == 'ON' && '-DUMF_USE_DEBUG_POSTFIX=ON' || '' }}
+
+    - name: Build UMF
+      shell: cmd
+      run: cmake --build ${{env.BUILD_DIR}} --config ${{matrix.build_type}} -j %NUMBER_OF_PROCESSORS%
+
+    - name: Run tests
+      shell: cmd
+      working-directory: ${{env.BUILD_DIR}}
+      run: ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
+
+    - name: Get UMF version
+      run: |
+        $version = (git describe --tags --abbrev=0 | Select-String -Pattern '\d+\.\d+\.\d+').Matches.Value
+        echo "UMF_VERSION=$version" >> $env:GITHUB_ENV
+      shell: pwsh
+
+    - name: Test UMF installation and uninstallation
+      # The '--shared-library' parameter is added to the installation test when the UMF is built as a shared library
+      # The '--umfd-lib' parameter is added when the UMF is built with the umfd library
+      run: >
+        python3 ${{github.workspace}}/test/test_installation.py
+        --build-dir ${{env.BUILD_DIR}}
+        --install-dir ${{env.INSTALL_DIR}}
+        --build-type ${{matrix.build_type}}
+        --umf-version ${{env.UMF_VERSION}}
+        ${{ matrix.shared_library == 'ON' && '--proxy --shared-library' || '' }}
+        ${{ matrix.umfd_lib == 'ON' && '--umfd-lib' || ''}}
+        ${{ matrix.static_hwloc == 'ON' && '--hwloc' || '' }}
+
+  # Build and test UMF with Intel C++ Compiler (ICX) on Windows
+  Windows-icx:
+   env:
+     VCPKG_PATH: "${{github.workspace}}/build/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows"
+   strategy:
+     matrix:
+       os: ['windows-2022', 'windows-2025']
+       build_type: [Debug]
+       compiler: [{c: icx, cxx: icx}]
+       shared_library: ['ON', 'OFF']
+       include:
+         - os: windows-2022
+           build_type: Release
+           compiler: {c: icx, cxx: icx}
+           shared_library: 'ON'
+   name: ICX (${{matrix.os}}, build_type=${{matrix.build_type}}, compilers=${{matrix.compiler.c}}/${{matrix.compiler.cxx}}, shared_library=${{matrix.shared_library}})
+   runs-on: ${{matrix.os}}
+
+   steps:
+   - name: Checkout
+     uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+     with:
+       fetch-depth: 0
+
+   - name: Initialize vcpkg
+     uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
+     with:
+       vcpkgGitCommitId: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
+       vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
+       vcpkgJsonGlob: '**/vcpkg.json'
+
+   - name: Install dependencies
+     run: vcpkg install --triplet x64-windows
+
+   - name: Install Ninja
+     uses: seanmiddleditch/gha-setup-ninja@3b1f8f94a2f8254bd26914c4ab9474d4f0015f67 # v6
+
+   - name: Download icx compiler
+     env:
+       # Link source: https://www.intel.com/content/www/us/en/developer/tools/oneapi/dpc-compiler-download.html
+       CMPLR_LINK: "https://registrationcenter-download.intel.com/akdlm/IRC_NAS/15a35578-2f9a-4f39-804b-3906e0a5f8fc/w_dpcpp-cpp-compiler_p_2024.2.1.83_offline.exe"
+     run: |
+       Invoke-WebRequest -Uri "${{ env.CMPLR_LINK }}" -OutFile compiler_install.exe
+
+   - name: Install icx compiler
+     shell: cmd
+     run: |
+       start /b /wait .\compiler_install.exe -s -x -f extracted --log extract.log
+       extracted\bootstrapper.exe -s --action install --eula=accept -p=NEED_VS2017_INTEGRATION=0 ^
+         -p=NEED_VS2019_INTEGRATION=0 -p=NEED_VS2022_INTEGRATION=0 --log-dir=.
+
+   - name: Configure build
+     shell: cmd
+     run: |
+       call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+       call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
+       cmake ^
+         -B ${{env.BUILD_DIR}} ^
+         -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}" ^
+         -DCMAKE_C_COMPILER=${{matrix.compiler.c}} ^
+         -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}} ^
+         -G Ninja ^
+         -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}} ^
+         -DUMF_FORMAT_CODE_STYLE=OFF ^
+         -DUMF_DEVELOPER_MODE=ON ^
+         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON ^
+         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON ^
+         -DUMF_BUILD_CUDA_PROVIDER=ON ^
+         -DUMF_TESTS_FAIL_ON_SKIP=ON
+
+   - name: Build UMF
+     shell: cmd
+     run: |
+       call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+       call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
+       cmake --build ${{env.BUILD_DIR}} --config ${{matrix.build_type}} -j %NUMBER_OF_PROCESSORS%
+
+   - name: Run tests
+     shell: cmd
+     working-directory: ${{env.BUILD_DIR}}
+     run: |
+       call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+       call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
+       ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
+
+  # Scenarios where UMF_LINK_HWLOC_STATICALLY is set to OFF and hwloc is not installed in the system
+  # The hwloc library is fetched implicitly
+  Hwloc-fallback:
+    strategy:
+      matrix:
+        include:
+          - os: 'ubuntu-latest'
+            build_type: Release
+            number_of_processors: '$(nproc)'
+          - os: 'windows-latest'
+            build_type: Release
+            number_of_processors: '$Env:NUMBER_OF_PROCESSORS'
+    name: "Fallback to static hwloc build (${{matrix.os}}), build_type=${{matrix.build_type}})"
+    runs-on: ${{matrix.os}}
+
+    steps:
+    - name: Install dependencies
+      if: matrix.os == 'ubuntu-latest'
+      run: sudo apt-get install -y libnuma-dev
+
+    - name: Checkout
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      with:
+        fetch-depth: 0
+
+    - name: Configure build
+      run: >
+        cmake
+        -B ${{env.BUILD_DIR}}
+        -DCMAKE_BUILD_TYPE=${{matrix.build_type}}
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DUMF_BUILD_EXAMPLES=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_LINK_HWLOC_STATICALLY=OFF
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+
+    - name: Build UMF
+      run: >
+        cmake
+        --build ${{env.BUILD_DIR}}
+        --config ${{matrix.build_type}}
+        -j ${{matrix.number_of_processors}}
+
+    - name: Run tests
+      working-directory: ${{env.BUILD_DIR}}
+      run: ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
+
+  L0:
+    uses: ./.github/workflows/reusable_gpu.yml
+    with:
+      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:
+      provider: "CUDA"
+      runner: "CUDA"
+
+  # Full execution of QEMU tests
+  QEMU:
+    uses: ./.github/workflows/reusable_qemu.yml
+    with:
+      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-25.04']"
+
+  Benchmarks:
+    uses: ./.github/workflows/reusable_benchmarks.yml
+    permissions:
+      contents: write
+      pull-requests: write
+    with:
+      pr_no: '0'
+      bench_script_params: '--save Baseline_PVC'
+
+  # Run benchmarks with the latest SYCL (with the latest UMF copied into the SYCL)
+  # to verify the compatibility.
+  Benchmarks-sycl:
+    uses: ./.github/workflows/reusable_benchmarks.yml
+    permissions:
+      contents: write
+      pull-requests: write
+    with:
+      pr_no: '0'
+      bench_script_params: >-
+        --adapter level_zero_v2
+        --compute-runtime
+        --build-igc
+        --preset Minimal
+        --exit-on-failure
+      runner: 'L0_PERF_ARC'
+      compatibility: '1'
+
+  SYCL:
+    uses: ./.github/workflows/reusable_sycl.yml
diff --git a/.github/workflows/pr_push.yml b/.github/workflows/pr_push.yml
index c35664a56..8ad9c83c1 100644
--- a/.github/workflows/pr_push.yml
+++ b/.github/workflows/pr_push.yml
@@ -1,4 +1,5 @@
-# Checks required for a PR to merge. This workflow mostly call other workflows.
+# Run checks required for a PR to merge and verify if post-merge commit is valid.
+# This workflow only call other workflows.
 name: PR/push
 
 on:
@@ -13,93 +14,91 @@ concurrency:
 
 permissions:
   contents: read
+  packages: read
 
 jobs:
-  CodeStyle:
-    name: Coding style
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      with:
-        fetch-depth: 0
-
-    - name: Install apt packages
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y black cmake clang-format-15 cmake-format libhwloc-dev
-
-    - name: Configure CMake
-      run: >
-        cmake
-        -B ${{github.workspace}}/build
-        -DUMF_FORMAT_CODE_STYLE=ON
-        -DUMF_BUILD_TESTS=OFF
-        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
-        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=OFF
-
-    - name: Check C/C++ formatting
-      run: cmake --build build --target clang-format-check
-
-    - name: Check CMake formatting
-      run: |
-        cmake --build build --target cmake-format-apply
-        git diff --exit-code
-
-    - name: Check Python formatting
-      run: cmake --build build --target black-format-check
-
-  DocsBuild:
-    name: Build docs
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      with:
-        fetch-depth: 0
-
-    - name: Install doxygen
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y doxygen
-
-    - name: Install pip requirements
-      run: python3 -m pip install -r third_party/requirements.txt
-
-    - name: Build the documentation
-      working-directory: scripts
-      run: python3 generate_docs.py
-
-  Spellcheck:
-    uses: ./.github/workflows/spellcheck.yml
+  CodeChecks:
+    uses: ./.github/workflows/reusable_checks.yml
   FastBuild:
     name: Fast builds
-    needs: [Spellcheck, CodeStyle]
-    uses: ./.github/workflows/fast.yml
+    needs: [CodeChecks]
+    uses: ./.github/workflows/reusable_fast.yml
   Build:
     name: Basic builds
     needs: [FastBuild]
-    uses: ./.github/workflows/basic.yml
-  Sanitizers:
+    uses: ./.github/workflows/reusable_basic.yml
+  DevDax:
     needs: [FastBuild]
-    uses: ./.github/workflows/sanitizers.yml
-  Qemu:
+    uses: ./.github/workflows/reusable_dax.yml
+  MultiNuma:
     needs: [FastBuild]
-    uses: ./.github/workflows/qemu.yml
-  Benchmarks:
+    uses: ./.github/workflows/reusable_multi_numa.yml
+  L0:
     needs: [Build]
-    uses: ./.github/workflows/benchmarks.yml
-  ProxyLib:
+    uses: ./.github/workflows/reusable_gpu.yml
+    with:
+      provider: "LEVEL_ZERO"
+      runner: "L0"
+      shared_lib: "['ON']"
+  L0-BMG:
     needs: [Build]
-    uses: ./.github/workflows/proxy_lib.yml
-  GPU:
+    uses: ./.github/workflows/reusable_gpu.yml
+    with:
+      provider: "LEVEL_ZERO"
+      runner: "L0-BMG"
+      shared_lib: "['ON']"
+      os: "['Ubuntu']"
+  CUDA:
     needs: [Build]
-    uses: ./.github/workflows/gpu.yml
+    uses: ./.github/workflows/reusable_gpu.yml
+    with:
+      provider: "CUDA"
+      runner: "CUDA"
+      shared_lib: "['ON']"
+  Sanitizers:
+    needs: [FastBuild]
+    uses: ./.github/workflows/reusable_sanitizers.yml
+  QEMU:
+    needs: [FastBuild]
+    uses: ./.github/workflows/reusable_qemu.yml
+    with:
+      short_run: true
+  ProxyLib:
+    needs: [Build]
+    uses: ./.github/workflows/reusable_proxy_lib.yml
   Valgrind:
     needs: [Build]
-    uses: ./.github/workflows/valgrind.yml
-  MultiNuma:
+    uses: ./.github/workflows/reusable_valgrind.yml
+  Coverage:
+    # total coverage (on upstream only)
+    if: github.repository == 'oneapi-src/unified-memory-framework'
+    needs: [Build, DevDax, L0, CUDA, MultiNuma, QEMU, ProxyLib]
+    uses: ./.github/workflows/reusable_coverage.yml
+    secrets: inherit
+    with:
+      trigger: "${{github.event_name}}"
+  Coverage_partial:
+    # partial coverage (on forks)
+    if: github.repository != 'oneapi-src/unified-memory-framework'
+    needs: [Build, QEMU, ProxyLib]
+    uses: ./.github/workflows/reusable_coverage.yml
+  CodeQL:
+    needs: [Build]
+    permissions:
+      contents: read
+      security-events: write
+    uses: ./.github/workflows/reusable_codeql.yml
+  Trivy:
+    needs: [Build]
+    permissions:
+      contents: read
+      security-events: write
+    uses: ./.github/workflows/reusable_trivy.yml
+  Compatibility:
     needs: [Build]
-    uses: ./.github/workflows/multi_numa.yml
+    uses: ./.github/workflows/reusable_compatibility.yml
+    strategy:
+      matrix:
+        tag: ["v0.11.0-rc1"]
+    with:
+      tag: ${{matrix.tag}}
diff --git a/.github/workflows/proxy_lib.yml b/.github/workflows/proxy_lib.yml
deleted file mode 100644
index 8d73569f0..000000000
--- a/.github/workflows/proxy_lib.yml
+++ /dev/null
@@ -1,74 +0,0 @@
-# Builds libumf_proxy and runs tests with it
-name: Proxy library
-
-on: workflow_call
-
-permissions:
-  contents: read
-
-env:
-  BUILD_DIR : "${{github.workspace}}/build"
-  INSTL_DIR : "${{github.workspace}}/../install-dir"
-
-jobs:
-  proxy-ubuntu:
-    name: Ubuntu
-
-    strategy:
-      matrix:
-        os: ['ubuntu-22.04']
-        build_type: [Release, Debug]
-        compiler: [{c: gcc, cxx: g++}]
-        proxy_lib_pool: ['SCALABLE', 'JEMALLOC']
-    runs-on: ${{matrix.os}}
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-        with:
-          fetch-depth: 0
-
-      - name: Install apt packages
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y cmake libhwloc-dev libjemalloc-dev libtbb-dev
-
-      - name: Set ptrace value for IPC test
-        run: sudo bash -c "echo 0 > /proc/sys/kernel/yama/ptrace_scope"
-
-      - name: Configure build
-        run: >
-          cmake
-          -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}}
-          -DUMF_BUILD_SHARED_LIBRARY=ON
-          -DUMF_BUILD_BENCHMARKS=ON
-          -DUMF_BUILD_TESTS=ON
-          -DUMF_FORMAT_CODE_STYLE=OFF
-          -DUMF_DEVELOPER_MODE=OFF
-          -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
-          -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
-          -DUMF_TESTS_FAIL_ON_SKIP=ON
-          -DUMF_PROXY_LIB_BASED_ON_POOL=${{matrix.proxy_lib_pool}}
-
-      - name: Build UMF
-        run: cmake --build ${{env.BUILD_DIR}} -j $(nproc)
-
-      - name: Run "ctest --output-on-failure" with proxy library
-        working-directory: ${{env.BUILD_DIR}}
-        run: LD_PRELOAD=./lib/libumf_proxy.so ctest --output-on-failure
-
-      - name: Run "./test/umf_test-memoryPool" with proxy library
-        working-directory: ${{env.BUILD_DIR}}
-        run: LD_PRELOAD=./lib/libumf_proxy.so ./test/umf_test-memoryPool
-
-      - name: Run "/usr/bin/ls" with proxy library
-        working-directory: ${{env.BUILD_DIR}}
-        run: LD_PRELOAD=./lib/libumf_proxy.so /usr/bin/ls
-
-      - name: Run "/usr/bin/date" with proxy library
-        working-directory: ${{env.BUILD_DIR}}
-        run: LD_PRELOAD=./lib/libumf_proxy.so /usr/bin/date
diff --git a/.github/workflows/qemu.yml b/.github/workflows/qemu.yml
deleted file mode 100644
index f8916c7de..000000000
--- a/.github/workflows/qemu.yml
+++ /dev/null
@@ -1,112 +0,0 @@
-# Builds project on qemu with custom hmat settings
-name: Qemu
-
-on: workflow_call
-
-env:
-  CI_BRANCH: "${{ github.head_ref || github.ref_name }}"
-
-permissions:
-  contents: read
-
-jobs:
-  qemu-build:
-    name: Qemu
-    runs-on: ubuntu-22.04
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      with:
-        fetch-depth: 0
-
-    - name: Enable KVM
-      run: |
-        echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules
-        sudo udevadm control --reload-rules
-        sudo udevadm trigger --name-match=kvm
-    - name: Install qemu
-      run: |
-        sudo apt update && sudo apt install -y qemu-system genisoimage qemu-utils
-    - name: Install libvirt and script dependencies
-      run: |
-        sudo apt-get install -y libvirt-clients libvirt-daemon-system libvirt-daemon virtinst bridge-utils
-        pip install -r scripts/qemu/requirements.txt
-        sudo usermod -a -G kvm,libvirt $USER
-    - name: Run ssh-keygen
-      run: ssh-keygen -b 4096 -N '' -f ~/.ssh/id_rsa
-    - name: Generate iso with user info
-      run: |
-        pub_key=$(cat ~/.ssh/id_rsa.pub)
-
-        cat > user-data << EOF
-        #cloud-config
-
-        # Add a 'cxltest' user to the system with a password
-        users:
-          - default
-          - name: cxltest
-            gecos: CXL Test User
-            primary_group: wheel
-            groups: users
-            sudo: ALL=(ALL) NOPASSWD:ALL
-            lock_passwd: false
-            ssh-authorized-keys:
-              - $pub_key
-            shell: /usr/bin/bash
-
-        # Set local logins
-        chpasswd:
-          list: |
-            root:password
-            cxltest:password
-          expire: False
-        EOF
-
-        cat > meta-data << EOF
-        instance-id: cxl-test
-        local-hostname: cxl-test
-        EOF
-
-        sudo -Sk genisoimage -output ubuntu-cloud-init.iso -volid cidata -joliet -rock ./user-data ./meta-data
-    - name: Download ubuntu image
-      run: wget https://cloud-images.ubuntu.com/releases/lunar/release/ubuntu-23.04-server-cloudimg-amd64.img
-    - name: Resize image
-      run: qemu-img resize ./ubuntu-23.04-server-cloudimg-amd64.img +4G
-    - name: Build
-      run: |
-        scripts/qemu/start_qemu.sh scripts/qemu/configs/default.xml
-
-        if [ ${{ github.event_name }} = 'pull_request' ]; then
-            CI_REPO="${{ github.event.pull_request.head.repo.full_name }}"
-        else
-            CI_REPO="$GITHUB_REPOSITORY"
-        fi
-
-        scp -P 2222 ${{github.workspace}}/scripts/qemu/run-build.sh cxltest@127.0.0.1:/home/cxltest
-        scp -P 2222 ${{github.workspace}}/scripts/qemu/run-tests.sh cxltest@127.0.0.1:/home/cxltest
-        ssh cxltest@127.0.0.1 -p 2222 -t "bash /home/cxltest/run-build.sh https://github.com/$CI_REPO ${{env.CI_BRANCH}}"
-
-        ssh cxltest@127.0.0.1 -p 2222 -t "sudo shutdown -h now"
-
-    - name: Run tests
-      run: |
-        for config_file in scripts/qemu/configs/*.xml; do
-          config_name=$(basename $config_file .xml)
-
-          echo testing $config_name
-          while ps -aux | grep qemu-system-x86_64 | grep -q -v grep; do
-            echo "Waiting for QEMU to shut down..."
-            sleep 5
-          done
-          scripts/qemu/start_qemu.sh $config_file
-          
-          if [ ${{ github.event_name }} = 'pull_request' ]; then
-            CI_REPO="${{ github.event.pull_request.head.repo.full_name }}"
-          else
-            CI_REPO="$GITHUB_REPOSITORY"
-          fi
-
-          ssh cxltest@127.0.0.1 -p 2222 -t "bash /home/cxltest/run-tests.sh"
-          ssh cxltest@127.0.0.1 -p 2222 -t "sudo shutdown -h now"
-        done
diff --git a/.github/workflows/basic.yml b/.github/workflows/reusable_basic.yml
similarity index 51%
rename from .github/workflows/basic.yml
rename to .github/workflows/reusable_basic.yml
index 4652a7a1d..6a62f119a 100644
--- a/.github/workflows/basic.yml
+++ b/.github/workflows/reusable_basic.yml
@@ -5,125 +5,169 @@ on: workflow_call
 
 permissions:
   contents: read
+  packages: read
 
 env:
-  # for installation testing - it should match with version set in CMake
-  UMF_VERSION: 0.9.1
   BUILD_DIR : "${{github.workspace}}/build"
-  INSTL_DIR : "${{github.workspace}}/../install-dir"
+  INSTL_DIR : "${{github.workspace}}/install-dir"
+  COVERAGE_DIR : "${{github.workspace}}/coverage"
+  COVERAGE_NAME : "exports-coverage-basic"
 
 jobs:
   ubuntu-build:
-    name: Ubuntu
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/bb-ur/umf-${{ matrix.os }}:latest
+      options: --user test_user --cap-add=SYS_NICE --cap-add=SYS_PTRACE
+      volumes:
+        - ${{ github.workspace }}:${{ github.workspace }}
     strategy:
       matrix:
-        os: ['ubuntu-20.04', 'ubuntu-22.04']
+        os: ['ubuntu-22.04', 'ubuntu-24.04']
         build_type: [Debug, Release]
         compiler: [{c: gcc, cxx: g++}]
         shared_library: ['OFF']
         level_zero_provider: ['ON']
+        cuda_provider: ['ON']
         install_tbb: ['ON']
         disable_hwloc: ['OFF']
         link_hwloc_statically: ['OFF']
+        cmake_ver: ['default']
         include:
-          - os: 'ubuntu-20.04'
-            build_type: Release
-            compiler: {c: gcc-7, cxx: g++-7}
-            shared_library: 'OFF'
-            level_zero_provider: 'ON'
-            install_tbb: 'ON'
-          - os: 'ubuntu-22.04'
+          - os: ubuntu-22.04
             build_type: Release
             compiler: {c: clang, cxx: clang++}
             shared_library: 'OFF'
             level_zero_provider: 'ON'
+            cuda_provider: 'ON'
             install_tbb: 'ON'
-          - os: 'ubuntu-22.04'
+            disable_hwloc: 'OFF'
+            link_hwloc_statically: 'OFF'
+            # check minimum supported cmake version
+            cmake_ver: '3.14.0'
+          - os: ubuntu-22.04
             build_type: Release
             compiler: {c: gcc, cxx: g++}
             shared_library: 'ON'
             level_zero_provider: 'ON'
+            cuda_provider: 'ON'
             install_tbb: 'ON'
-          - os: 'ubuntu-22.04'
+            disable_hwloc: 'OFF'
+            link_hwloc_statically: 'OFF'
+            cmake_ver: '3.28.0'
+          - os: ubuntu-24.04
             build_type: Debug
             compiler: {c: gcc, cxx: g++}
             shared_library: 'ON'
             level_zero_provider: 'ON'
+            cuda_provider: 'ON'
             install_tbb: 'ON'
-          # test level_zero_provider='OFF'
-          - os: 'ubuntu-22.04'
+            disable_hwloc: 'OFF'
+            link_hwloc_statically: 'OFF'
+            cmake_ver: 'default'
+          # test level_zero_provider='OFF' and cuda_provider='OFF'
+          - os: ubuntu-22.04
             build_type: Release
             compiler: {c: gcc, cxx: g++}
             shared_library: 'OFF'
             level_zero_provider: 'OFF'
+            cuda_provider: 'OFF'
             install_tbb: 'ON'
+            disable_hwloc: 'OFF'
+            link_hwloc_statically: 'OFF'
+            cmake_ver: 'default'
           # test icx compiler
-          # - os: 'ubuntu-22.04'
-            # build_type: Release
-            # compiler: {c: icx, cxx: icpx}
-            # shared_library: 'ON'
-            # level_zero_provider: 'ON'
-            # cuda_provider: 'ON'
-            # install_tbb: 'ON'
-            # disable_hwloc: 'OFF'
-            # link_hwloc_statically: 'OFF'
+          - os: ubuntu-22.04
+            build_type: Release
+            compiler: {c: icx, cxx: icpx}
+            shared_library: 'ON'
+            level_zero_provider: 'ON'
+            cuda_provider: 'ON'
+            install_tbb: 'ON'
+            disable_hwloc: 'OFF'
+            link_hwloc_statically: 'OFF'
+            cmake_ver: 'default'
+          # test lld linker
+          - os: ubuntu-24.04
+            build_type: Release
+            compiler: {c: icx, cxx: icpx}
+            shared_library: 'ON'
+            level_zero_provider: 'ON'
+            cuda_provider: 'ON'
+            install_tbb: 'ON'
+            disable_hwloc: 'OFF'
+            link_hwloc_statically: 'OFF'
+            llvm_linker: '-DCMAKE_EXE_LINKER_FLAGS="-fuse-ld=lld" -DCMAKE_MODULE_LINKER_FLAGS="-fuse-ld=lld" -DCMAKE_SHARED_LINKER_FLAGS="-fuse-ld=lld"'
+            cmake_ver: 'default'
           # test without installing TBB
-          - os: 'ubuntu-22.04'
+          - os: ubuntu-22.04
             build_type: Release
             compiler: {c: gcc, cxx: g++}
             shared_library: 'ON'
             level_zero_provider: 'ON'
+            cuda_provider: 'ON'
             install_tbb: 'OFF'
-          - os: 'ubuntu-22.04'
+            disable_hwloc: 'OFF'
+            link_hwloc_statically: 'OFF'
+            cmake_ver: 'default'
+          - os: ubuntu-22.04
             build_type: Debug
             compiler: {c: gcc, cxx: g++}
             shared_library: 'ON'
             level_zero_provider: 'ON'
+            cuda_provider: 'ON'
             install_tbb: 'ON'
             disable_hwloc: 'ON'
-          - os: 'ubuntu-22.04'
+            link_hwloc_statically: 'OFF'
+            cmake_ver: 'default'
+          - os: ubuntu-22.04
             build_type: Release
             compiler: {c: gcc, cxx: g++}
             shared_library: 'ON'
             level_zero_provider: 'ON'
+            cuda_provider: 'ON'
             install_tbb: 'ON'
+            disable_hwloc: 'OFF'
             link_hwloc_statically: 'ON'
-    runs-on: ${{matrix.os}}
+            cmake_ver: 'default'
+    name: Basic (${{matrix.os}}, build_type=${{matrix.build_type}}, compilers=${{matrix.compiler.c}}/${{matrix.compiler.cxx}}, shared_library=${{matrix.shared_library}}, level_zero_provider=${{matrix.level_zero_provider}}, cuda_provider=${{matrix.cuda_provider}}, install_tbb=${{matrix.install_tbb}}, 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: |
-        sudo apt-get update
-        sudo apt-get install -y clang cmake libnuma-dev libjemalloc-dev 
-        
-    - name: Install TBB apt package
-      if: matrix.install_tbb == 'ON'
+        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: |
+        echo ${USERPASS} | sudo -Sk apt-get remove --purge -y '*hwloc*'
+        echo ${USERPASS} | sudo -Sk apt-get autoremove -y
+
+    - name: Uninstall TBB apt package
+      if: matrix.install_tbb == 'OFF'
       run: |
-        sudo apt-get install -y libtbb-dev
+        echo ${USERPASS} | sudo -Sk apt-get remove --purge -y '*tbb*'
+        echo ${USERPASS} | sudo -Sk apt-get autoremove -y
 
     - name: Install oneAPI basekit
       if: matrix.compiler.cxx == 'icpx'
       run: |
-        sudo apt-get install -y gpg-agent wget
-        wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB | gpg --dearmor | sudo tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null
-        echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" | sudo tee /etc/apt/sources.list.d/oneAPI.list
-        sudo apt-get update
-        sudo apt-get install -y intel-oneapi-ippcp-devel intel-oneapi-ipp-devel intel-oneapi-common-oneapi-vars intel-oneapi-compiler-dpcpp-cpp
-  
-    - name: Install g++-7
-      if: matrix.compiler.cxx == 'g++-7'
-      run: sudo apt-get install -y ${{matrix.compiler.cxx}}
-
-    - name: Install libhwloc
-      run: .github/scripts/install_hwloc.sh
-
-    - name: Set ptrace value for IPC test
-      run: sudo bash -c "echo 0 > /proc/sys/kernel/yama/ptrace_scope"
+        echo "${USERPASS}" | sudo -Sk ./.github/scripts/install_oneAPI.sh
+
+    - name: Get UMF version
+      run: |
+        git config --global --add safe.directory $GITHUB_WORKSPACE
+        VERSION=$(git describe --tags --abbrev=0 | grep -oP '\d+\.\d+\.\d+')
+        echo "UMF_VERSION=$VERSION" >> $GITHUB_ENV
 
     - name: Configure build
       run: >
@@ -136,92 +180,153 @@ jobs:
         -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
         -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=${{matrix.level_zero_provider}}
+        -DUMF_BUILD_CUDA_PROVIDER=${{matrix.cuda_provider}}
         -DUMF_FORMAT_CODE_STYLE=OFF
         -DUMF_DEVELOPER_MODE=ON
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
         -DUMF_TESTS_FAIL_ON_SKIP=ON
         -DUMF_DISABLE_HWLOC=${{matrix.disable_hwloc}}
         -DUMF_LINK_HWLOC_STATICALLY=${{matrix.link_hwloc_statically}}
+        ${{ matrix.build_type == 'Debug' && matrix.compiler.c == 'gcc' && '-DUMF_USE_COVERAGE=ON' || '' }}
+        ${{ matrix.llvm_linker || '' }}
 
     - name: Build UMF
-      run: cmake --build ${{env.BUILD_DIR}} -j $(nproc)
+      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}}
-      run: >
-        ${{ matrix.compiler.cxx == 'icpx' && '. /opt/intel/oneapi/setvars.sh &&' || ''}} 
-        ctest --output-on-failure --test-dir test
+      run: |
+        ${{ matrix.compiler.cxx == 'icpx' && '. /opt/intel/oneapi/setvars.sh' || true }}
+        LD_LIBRARY_PATH="${{env.BUILD_DIR}}/lib/:${LD_LIBRARY_PATH}" ctest --output-on-failure
+
+    - name: Check coverage
+      if:  ${{ matrix.build_type == 'Debug' && matrix.compiler.c == 'gcc' }}
+      working-directory: ${{env.BUILD_DIR}}
+      run: |
+        export COVERAGE_FILE_NAME=${{env.COVERAGE_NAME}}-${{matrix.os}}-shared-${{matrix.shared_library}}-no_hwloc-${{matrix.disable_hwloc}}
+        echo "COVERAGE_FILE_NAME: $COVERAGE_FILE_NAME"
+        ../scripts/coverage/coverage_capture.sh $COVERAGE_FILE_NAME
+        mkdir -p ${{env.COVERAGE_DIR}}
+        mv ./$COVERAGE_FILE_NAME ${{env.COVERAGE_DIR}}
+
+    - uses: actions/upload-artifact@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}}
+        path: ${{env.COVERAGE_DIR}}
 
     - name: Remove the installation directory
       run: rm -rf ${{env.INSTL_DIR}}
 
     - name: Test UMF installation and uninstallation
-      # The '--shared-library' parameter is added to the installation test when the UMF is built as a shared library
       run: >
         python3 ${{github.workspace}}/test/test_installation.py
         --build-dir ${{env.BUILD_DIR}}
         --install-dir ${{env.INSTL_DIR}}
         --build-type ${{matrix.build_type}}
-        --disjoint-pool
-        --jemalloc-pool
-        ${{ matrix.install_tbb == 'ON' && matrix.disable_hwloc != 'ON' && matrix.link_hwloc_statically != 'ON' && '--proxy' || '' }}
+        ${{ matrix.install_tbb == 'ON' && matrix.disable_hwloc != 'ON' && matrix.shared_library == 'ON' && '--proxy' || '' }}
         --umf-version ${{env.UMF_VERSION}}
         ${{ matrix.shared_library == 'ON' && '--shared-library' || '' }}
 
   windows-build:
-    name: Windows
     env:
       VCPKG_PATH: "${{github.workspace}}/build/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows"
+      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:
+      # TODO: add '3.14.0-win64-x64' CMake testing
       matrix:
-        os: ['windows-2019', 'windows-2022']
+        os: ['windows-2022', 'windows-2025']
         build_type: [Debug, Release]
         compiler: [{c: cl, cxx: cl}]
         shared_library: ['ON', 'OFF']
         level_zero_provider: ['ON']
+        cuda_provider: ['ON']
+        cmake_ver: ['default']
         include:
-          - os: 'windows-2022'
-            build_type: Release
+          # clang-cl works well with Ninja, Debug build
+          # For VS generator it produces build errors not related to UMF
+          - os: 'windows-2025'
+            build_type: Debug
             compiler: {c: clang-cl, cxx: clang-cl}
+            extra_build_options: '-G Ninja'
             shared_library: 'ON'
             level_zero_provider: 'ON'
-            toolset: "-T ClangCL"
-          - os: 'windows-2022'
+            cuda_provider: 'ON'
+            cmake_ver: 'default'
+          # Custom CMake and umfd enabled
+          - os: 'windows-2025'
             build_type: Release
             compiler: {c: cl, cxx: cl}
             shared_library: 'ON'
             level_zero_provider: 'ON'
-          - os: 'windows-2022'
+            cuda_provider: 'ON'
+            umfd_lib: 'ON'
+            cmake_ver: '3.28.0-windows-x86_64'
+          # L0/CUDA providers disabled
+          - os: 'windows-2025'
             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:
-        vcpkgGitCommitId: 3dd44b931481d7a8e9ba412621fa810232b66289
+        vcpkgGitCommitId: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
         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
-      shell: pwsh # Specifies PowerShell as the shell for running the script.
+      run: |
+        vcpkg install --triplet x64-windows
+        $env:Path = "${{env.VCPKG_PATH_BIN}};$env:Path"
+        echo "PATH=$env:Path" >> $env:GITHUB_ENV
+      shell: pwsh
+
+    - name: Get UMF version
+      run: |
+        $version = (git describe --tags --abbrev=0 | Select-String -Pattern '\d+\.\d+\.\d+').Matches.Value
+        echo "UMF_VERSION=$version" >> $env:GITHUB_ENV
+      shell: pwsh
 
     - name: Configure build
       run: >
         cmake
         -B ${{env.BUILD_DIR}}
-        ${{matrix.toolset}}
+        ${{matrix.extra_build_options || ''}}
         -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
         -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
         -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
@@ -229,30 +334,41 @@ jobs:
         -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}}
         -DUMF_FORMAT_CODE_STYLE=OFF
         -DUMF_DEVELOPER_MODE=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=${{matrix.level_zero_provider}}
+        -DUMF_BUILD_CUDA_PROVIDER=${{matrix.cuda_provider}}
         -DUMF_TESTS_FAIL_ON_SKIP=ON
+        -DUMF_USE_DEBUG_POSTFIX=${{matrix.umfd_lib}}
 
     - name: Build UMF
       run: cmake --build ${{env.BUILD_DIR}} --config ${{matrix.build_type}} -j $Env:NUMBER_OF_PROCESSORS
 
     - name: Run tests
       working-directory: ${{env.BUILD_DIR}}
-      run: ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
+      # 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
       run: >
         python3 ${{github.workspace}}/test/test_installation.py
         --build-dir ${{env.BUILD_DIR}}
         --install-dir ${{env.INSTL_DIR}}
         --build-type ${{matrix.build_type}}
-        --disjoint-pool
-        --jemalloc-pool
-        --proxy
+        ${{matrix.shared_library == 'ON' && '--proxy' || '' }}
         --umf-version ${{env.UMF_VERSION}}
         ${{ matrix.shared_library == 'ON' && '--shared-library' || ''}}
+        ${{ matrix.umfd_lib == 'ON' && '--umfd-lib' || ''}}
         
     - name: check /DEPENDENTLOADFLAG in umf.dll
       if: ${{matrix.shared_library == 'ON' && matrix.compiler.cxx == 'cl'}}
@@ -260,7 +376,7 @@ jobs:
       shell: pwsh
 
     - name: check /DEPENDENTLOADFLAG in umf_proxy.dll
-      if: ${{matrix.compiler.cxx == 'cl'}}
+      if: ${{matrix.shared_library == 'ON' && matrix.compiler.cxx == 'cl'}}
       run: ${{github.workspace}}/.github/scripts/check_dll_flags.ps1 ${{env.BUILD_DIR}}/src/proxy_lib/${{matrix.build_type}}/umf_proxy.dll
       shell: pwsh
 
@@ -270,11 +386,11 @@ jobs:
       matrix:
         build_type: [Release]
 
-    runs-on: 'windows-2022'
+    runs-on: 'windows-latest'
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
 
@@ -284,12 +400,12 @@ jobs:
         -B ${{env.BUILD_DIR}}
         -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
         -DUMF_BUILD_SHARED_LIBRARY=ON
-        -DUMF_BUILD_EXAMPLES=OFF
+        -DUMF_BUILD_EXAMPLES=ON
         -DUMF_FORMAT_CODE_STYLE=OFF
         -DUMF_DEVELOPER_MODE=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=OFF
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
         -DUMF_TESTS_FAIL_ON_SKIP=ON
         -DUMF_LINK_HWLOC_STATICALLY=ON
 
@@ -312,11 +428,11 @@ jobs:
       matrix:
         build_type: [Release]
 
-    runs-on: 'windows-2022'
+    runs-on: 'windows-latest'
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
 
@@ -326,12 +442,12 @@ jobs:
         -B ${{env.BUILD_DIR}}
         -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
         -DUMF_BUILD_SHARED_LIBRARY=OFF
-        -DUMF_BUILD_EXAMPLES=OFF
+        -DUMF_BUILD_EXAMPLES=ON
         -DUMF_FORMAT_CODE_STYLE=OFF
         -DUMF_DEVELOPER_MODE=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=OFF
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
         -DUMF_TESTS_FAIL_ON_SKIP=ON
         -DUMF_LINK_HWLOC_STATICALLY=ON
 
@@ -354,11 +470,11 @@ jobs:
       matrix:
         build_type: [Release]
 
-    runs-on: 'windows-2022'
+    runs-on: 'windows-latest'
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         fetch-depth: 0
 
@@ -393,25 +509,42 @@ jobs:
       run: ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
 
   macos-build:
-    name: MacOS
     strategy:
       matrix:
-        os: ['macos-12', 'macos-13']
+        os: ['macos-13', 'macos-14']
+        include:
+          - os: macos-14
+            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
 
-    - name: Install Python requirements
-      run: python3 -m pip install -r third_party/requirements.txt
+    # Latest distros do not allow global pip installation
+    - name: Install Python requirements in venv
+      run: |
+        python3 -m venv .venv
+        . .venv/bin/activate
+        echo "$PATH" >> $GITHUB_PATH
+        python3 -m pip install -r third_party/requirements.txt
+
+    - name: Install dependencies
+      run: brew install jemalloc tbb automake libtool
 
     - name: Install hwloc
-      run: brew install hwloc jemalloc tbb
+      if: ${{ !matrix.static_hwloc }}
+      run: brew install hwloc
+
+    - name: Get UMF version
+      run: |
+        VERSION=$(git describe --tags --abbrev=0 | grep -Eo '\d+\.\d+\.\d+')
+        echo "UMF_VERSION=$VERSION" >> $GITHUB_ENV
 
     - name: Configure build
       run: >
@@ -422,10 +555,11 @@ jobs:
         -DUMF_FORMAT_CODE_STYLE=OFF
         -DUMF_DEVELOPER_MODE=ON
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
         -DUMF_BUILD_SHARED_LIBRARY=ON
         -DUMF_TESTS_FAIL_ON_SKIP=ON
+        -DUMF_LINK_HWLOC_STATICALLY=${{matrix.static_hwloc}}
+        ${{matrix.static_hwloc}}
 
     - name: Build UMF
       run: cmake --build ${{env.BUILD_DIR}} -j $(sysctl -n hw.logicalcpu)
@@ -436,8 +570,6 @@ jobs:
         --build-dir ${{env.BUILD_DIR}}
         --install-dir ${{env.INSTL_DIR}}
         --build-type ${{env.BUILD_TYPE}}
-        --disjoint-pool
-        --jemalloc-pool
         --proxy
         --umf-version ${{env.UMF_VERSION}}
         --shared-library
diff --git a/.github/workflows/reusable_benchmarks.yml b/.github/workflows/reusable_benchmarks.yml
new file mode 100644
index 000000000..7bc507601
--- /dev/null
+++ b/.github/workflows/reusable_benchmarks.yml
@@ -0,0 +1,280 @@
+# Executes benchmarks implemented in this repository using scripts
+# for results visualization from intel/llvm.
+name: Benchmarks
+
+on:
+  workflow_call:
+    inputs:
+      pr_no:
+        # even though this is a number, this is a workaround for issues with
+        # reusable workflow calls that result in "Unexpected value '0'" error.
+        type: string
+        default: '0'
+      bench_script_params:
+        required: false
+        type: string
+        default: ''
+      bench_script_compare:
+        required: false
+        type: string
+        default: ''
+      runner:
+        required: false
+        type: string
+        default: 'L0_PERF_PVC'
+      compatibility:
+        required: false
+        type: string
+        default: '0'
+        description: |
+          Set it to 1 to run compatibility sycl benchmarks
+
+permissions:
+  contents: read
+  pull-requests: read
+
+env:
+  UMF_DIR: "${{github.workspace}}/umf-repo"
+  BUILD_DIR : "${{github.workspace}}/umf-repo/build"
+
+jobs:
+  benchmarks:
+    name: Benchmarks
+    # run only on upstream; forks will not have the HW
+    if: github.repository == 'oneapi-src/unified-memory-framework'
+    runs-on: ${{ inputs.runner }}
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+    - name: Establish bench params
+      run: |
+        params="${{ inputs.bench_script_params }}"
+        if [ -n "${{ inputs.bench_script_compare }}" ]; then
+          params="$params --compare '${{ inputs.bench_script_compare }}'"
+        fi
+
+        echo "params=$params"
+        echo "bench_params=$params" >> $GITHUB_ENV
+
+    - name: Add comment to PR
+      uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+      if: ${{ always() && inputs.pr_no != 0 }}
+      with:
+        script: |
+          const pr_no = '${{ inputs.pr_no }}';
+          const url = '${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}';
+          const params = `${{ env.bench_params }}`;
+          const body = `Compute Benchmarks run (with params: ${params}):\n${url}`;
+
+          github.rest.issues.createComment({
+            issue_number: pr_no,
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            body: body
+          })
+
+    - name: Checkout UMF
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      with:
+        path: ${{env.UMF_DIR}}
+        fetch-depth: 0
+
+    # We need to fetch special ref for proper PR's merge commit. Note, this ref may be absent if the PR is already merged.
+    - name: Fetch PR's merge commit
+      if: ${{ inputs.pr_no != 0 }}
+      working-directory: ${{env.UMF_DIR}}
+      env:
+        PR_NO: ${{ inputs.pr_no }}
+      run: |
+        git fetch -- https://github.com/${{github.repository}} +refs/pull/${PR_NO}/*:refs/remotes/origin/pr/${PR_NO}/*
+        git checkout origin/pr/${PR_NO}/merge
+        git rev-parse origin/pr/${PR_NO}/merge
+
+    - name: Configure UMF
+      run: >
+        cmake
+        -S ${{env.UMF_DIR}}
+        -B ${{env.BUILD_DIR}}
+        -DCMAKE_BUILD_TYPE=Release
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DUMF_BUILD_BENCHMARKS=ON
+        -DUMF_BUILD_BENCHMARKS_MT=ON
+        -DUMF_BUILD_TESTS=OFF
+        -DUMF_BUILD_EXAMPLES=OFF
+        -DUMF_DEVELOPER_MODE=OFF
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+
+    - name: Build UMF
+      run: cmake --build ${{env.BUILD_DIR}} -j $(nproc)
+
+    - name: Checkout UMF results branch
+      uses: actions/checkout@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
+        # 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: |
+        python3 -m venv .venv
+        source .venv/bin/activate
+        echo "$PATH" >> $GITHUB_PATH
+        pip install -r ${{github.workspace}}/sc/devops/scripts/benchmarks/requirements.txt
+
+    - name: Set core range and GPU mask
+      run: |
+        # On the L0_PERF_PVC runner, compute the core range for the second NUMA node;
+        # first node is for SYCL/UR jobs.
+        # Skip the first 4 cores - the kernel is likely to schedule more work on these.
+        CORES=$(lscpu | awk '
+          /NUMA node1 CPU|On-line CPU/ {line=$0}
+          END {
+            split(line, a, " ")
+            split(a[4], b, ",")
+            sub(/^0/, "4", b[1])
+            print b[1]
+          }')
+        echo "Selected core: $CORES"
+        echo "CORES=$CORES" >> $GITHUB_ENV
+
+        ZE_AFFINITY_MASK=${{ inputs.runner == 'L0_PERF_ARC' && '0' || '1' }}
+        echo "ZE_AFFINITY_MASK=$ZE_AFFINITY_MASK" >> $GITHUB_ENV
+
+    - name: Download latest sycl
+      if: inputs.compatibility == 1
+      run: |
+        llvm_tag=$(curl -s https://api.github.com/repos/intel/llvm/releases | awk -F'"' '/"tag_name": "nightly/ {print $4; exit}')
+        download_url="https://github.com/intel/llvm/releases/download/${llvm_tag}/sycl_linux.tar.gz"
+        echo "llvm tag: $llvm_tag"
+        wget --no-verbose $download_url -O sycl_linux.tar.gz
+
+    - name: Unpack sycl
+      if: inputs.compatibility == 1
+      run: |
+        mkdir -p sycl
+        tar -xzf sycl_linux.tar.gz -C sycl --strip-components=1
+        rm sycl_linux.tar.gz
+        echo "SYCL_DIR=${{ github.workspace }}/sycl" >> $GITHUB_ENV
+        echo "${{ github.workspace }}/sycl/bin" >> $GITHUB_PATH
+        echo "LD_LIBRARY_PATH=${{ github.workspace }}/sycl/lib:$LD_LIBRARY_PATH" >> $GITHUB_ENV
+
+    - name: Remove UMF libraries from sycl
+      if: inputs.compatibility == 1
+      run: rm -f ${{ env.SYCL_DIR }}/lib/libumf*
+
+    - name: Copy UMF libraries to sycl
+      if: inputs.compatibility == 1
+      run: |
+        cp ${{ env.BUILD_DIR }}/lib/libumf* ${{ env.SYCL_DIR }}/lib/
+
+    - name: Run sycl-ls
+      if: inputs.compatibility == 1
+      env:
+        LD_LIBRARY_PATH: ${{ env.SYCL_DIR }}/lib
+        SYCL_UR_TRACE: 1
+        SYCL_UR_USE_LEVEL_ZERO_V2: 1
+      run: ${{ env.SYCL_DIR }}/bin/sycl-ls
+
+    - name: Run benchmarks
+      id: benchmarks
+      env:
+        LD_LIBRARY_PATH: ${{ env.SYCL_DIR }}/lib
+        CPATH: ${{ env.SYCL_DIR }}/include
+      run: >
+        taskset -c ${{ env.CORES }} ./sc/devops/scripts/benchmarks/main.py
+        ~/bench_workdir_umf
+        --results-dir ${{ github.workspace }}/results-repo
+        --output-markdown
+        ${{ (inputs.compatibility == 0) && format('--umf {0} --timeout 3000 --output-html remote', env.BUILD_DIR) || '' }}
+        ${{ (inputs.compatibility == 1) && format('--sycl {0} --timeout 7200', env.SYCL_DIR) || '' }}
+        ${{ env.bench_params }}
+
+    # In case it failed to add a comment, we can still print the results.
+    - name: Print benchmark results
+      if: ${{ always() }}
+      run: cat ${{ github.workspace }}/benchmark_results.md || true
+
+    - name: Add comment to PR
+      uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+      if: ${{ always() && inputs.pr_no != 0 }}
+      with:
+        script: |
+          let markdown = ""
+          try {
+            const fs = require('fs');
+            markdown = fs.readFileSync('${{ github.workspace }}/benchmark_results.md', 'utf8');
+          } catch(err) {
+          }
+
+          const pr_no = '${{ inputs.pr_no }}';
+          const url = '${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}';
+          const test_status = '${{ steps.benchmarks.outcome }}';
+          const job_status = '${{ job.status }}';
+          const params = `${{ env.bench_params }}`;
+          const body = `Compute Benchmarks run (${params}):\n${url}\nJob status: ${job_status}. Test status: ${test_status}.\n ${markdown}`;
+
+          github.rest.issues.createComment({
+            issue_number: pr_no,
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            body: body
+          })
+
+    - name: Commit data.json 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
new file mode 100644
index 000000000..51d76d3d6
--- /dev/null
+++ b/.github/workflows/reusable_checks.yml
@@ -0,0 +1,75 @@
+# Basic checks on the code, incl. coding style, spelling, bandit analysis.
+# TODO: add license check
+name: Basic checks
+
+on: workflow_call
+
+permissions:
+  contents: read
+
+jobs:
+  CodeChecks:
+    name: Basic code checks
+    runs-on: ${{ github.repository_owner == 'oneapi-src' && 'intel-ubuntu-22.04' || 'ubuntu-latest' }}
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      with:
+        fetch-depth: 0
+
+    - name: Install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y cmake libhwloc-dev doxygen
+
+    # Latest distros do not allow global pip installation
+    - name: Install Python requirements in venv
+      run: |
+        python3 -m venv .venv
+        . .venv/bin/activate
+        echo "$PATH" >> $GITHUB_PATH
+        python3 -m pip install -r third_party/requirements.txt
+
+    - name: Configure CMake
+      run: >
+        cmake
+        -B ${{github.workspace}}/build
+        -DUMF_FORMAT_CODE_STYLE=ON
+        -DUMF_BUILD_TESTS=OFF
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
+        -DUMF_BUILD_CUDA_PROVIDER=OFF
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=OFF
+
+    - name: Check C/C++ formatting
+      run: cmake --build build --target clang-format-check
+
+    - name: Check CMake formatting
+      run: |
+        cmake --build build --target cmake-format-apply
+        git diff --exit-code
+
+    - name: Check Python formatting
+      run: cmake --build build --target black-format-check
+
+    - name: Run check-license
+      run: |
+        ./scripts/check_license/check_headers.sh . "Apache-2.0 WITH LLVM-exception" -v
+
+    - name: Run a spell check
+      uses: crate-ci/typos@b1ae8d918b6e85bd611117d3d9a3be4f903ee5e4 # v1.33.1
+      with:
+        config: ./.github/workflows/.spellcheck-conf.toml
+
+    - name: Run codespell
+      run: python3 ./.github/scripts/run-codespell.py
+
+    - name: Check spelling in docs
+      run: |
+        cmake -B build
+        cmake --build build --target docs
+        sphinx-build -b spelling ./build/docs_build/config ./build/docs_build/spelling_log -W
+
+    # Run Bandit recursively, but omit _deps directory (with 3rd party code) and python's venv
+    - name: Run Bandit
+      run: python3 -m bandit -r . -x '/_deps/,/.venv/'
diff --git a/.github/workflows/codeql.yml b/.github/workflows/reusable_codeql.yml
similarity index 58%
rename from .github/workflows/codeql.yml
rename to .github/workflows/reusable_codeql.yml
index b449eb23e..49bb4b66c 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/reusable_codeql.yml
@@ -1,26 +1,15 @@
 # CodeQL static analysis
 name: CodeQL
 
-# Due to lower score on Scorecard we're running this separately from
-# "PR/push" workflow. For some reason permissions weren't properly set
-# or recognized (by Scorecard). If Scorecard changes its behavior we can
-# go back to use 'workflow_call' trigger.
-on:
-  push:
-    branches-ignore:
-      - 'dependabot/**'
-  pull_request:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
+on: workflow_call
 
 permissions:
   contents: read
+  security-events: read
 
 env:
   BUILD_DIR : "${{github.workspace}}/build"
-  INSTL_DIR : "${{github.workspace}}/../install-dir"
+  INSTL_DIR : "${{github.workspace}}/install-dir"
 
 jobs:
   analyze:
@@ -42,36 +31,48 @@ 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@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@ce28f5bb42b7a9f2c824e633a3f6ee835bab6858 # v3.29.0
       with:
         languages: cpp
 
-    - name: Initialize vcpkg
-      if: ${{ matrix.os == 'windows-latest' }}
+    - name: "[Win] Initialize vcpkg"
+      if: matrix.os == 'windows-latest'
       uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
       with:
-        vcpkgGitCommitId: 3dd44b931481d7a8e9ba412621fa810232b66289
+        vcpkgGitCommitId: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
         vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
         vcpkgJsonGlob: '**/vcpkg.json'
 
-    - name: Install dependencies
-      if: ${{ matrix.os == 'windows-latest' }}
-      run: vcpkg install
-      shell: pwsh # Specifies PowerShell as the shell for running the script.
+    - name: "[Win] Install dependencies"
+      if: matrix.os == 'windows-latest'
+      run: |
+        vcpkg install --triplet x64-windows
+        python3 -m pip install -r third_party/requirements.txt
 
-    - name: Install apt packages
+    - name: "[Lin] Install apt packages"
       if: matrix.os == 'ubuntu-latest'
       run: |
         sudo apt-get update
-        sudo apt-get install -y cmake clang libhwloc-dev libnuma-dev libjemalloc-dev libtbb-dev
+        sudo apt-get install -y cmake clang libhwloc-dev libnuma-dev libtbb-dev
 
-    - name: Install pip packages
-      run: python3 -m pip install -r third_party/requirements.txt
+    # Latest distros do not allow global pip installation
+    - name: "[Lin] Install Python requirements in venv"
+      if: matrix.os == 'ubuntu-latest'
+      run: |
+        python3 -m venv .venv
+        . .venv/bin/activate
+        echo "$PATH" >> $GITHUB_PATH
+        python3 -m pip install -r third_party/requirements.txt
 
     - name: Configure CMake
       run: >
@@ -84,10 +85,11 @@ jobs:
         -DUMF_DEVELOPER_MODE=ON
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
         -DUMF_TESTS_FAIL_ON_SKIP=ON
 
     - name: Build
       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@ce28f5bb42b7a9f2c824e633a3f6ee835bab6858 # v3.29.0
diff --git a/.github/workflows/reusable_compatibility.yml b/.github/workflows/reusable_compatibility.yml
new file mode 100644
index 000000000..c44198aef
--- /dev/null
+++ b/.github/workflows/reusable_compatibility.yml
@@ -0,0 +1,367 @@
+# Workflow for checking the backward compatibility of UMF.
+# Test the latest UMF shared library with binaries compiled using the older UMF 
+# shared library.
+name: Compatibility 
+
+on:
+  workflow_call:
+    inputs:
+      tag:
+        description: Check backward compatibility with this tag
+        type: string
+        default: "v0.11.0-rc1"
+
+permissions:
+  contents: read
+
+jobs:
+  ubuntu:
+    name: Ubuntu
+    runs-on: 'ubuntu-22.04'
+
+    steps:
+    - name: Install apt packages
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y clang cmake hwloc libhwloc-dev libnuma-dev libtbb-dev
+
+    - name: Checkout "tag" UMF version
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      with:
+        fetch-depth: 0
+        ref: refs/tags/${{inputs.tag}}
+        path: ${{github.workspace}}/tag_version
+
+    - 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_INSTALL_PREFIX=_install
+        -DCMAKE_BUILD_TYPE=Debug
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DCMAKE_C_COMPILER=gcc
+        -DCMAKE_CXX_COMPILER=g++
+        -DUMF_BUILD_TESTS=OFF
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+
+    - name: Build latest UMF
+      working-directory: ${{github.workspace}}/latest_version
+      run: |
+        cmake --build ${{github.workspace}}/latest_version/build -j $(nproc)
+
+    - name: Install latest UMF
+      working-directory: ${{github.workspace}}/latest_version
+      run: sudo cmake --install ${{github.workspace}}/latest_version/build --config Debug
+
+    - name: Configure "tag" UMF build
+      working-directory: ${{github.workspace}}/tag_version
+      run: >
+        cmake
+        -B ${{github.workspace}}/tag_version/build
+        -DCMAKE_BUILD_TYPE=Debug
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DCMAKE_C_COMPILER=gcc
+        -DCMAKE_CXX_COMPILER=g++
+        -DUMF_BUILD_TESTS=ON
+        -DUMF_BUILD_EXAMPLES=ON
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+
+    - name: Build "tag" UMF
+      working-directory: ${{github.workspace}}/tag_version
+      run: |
+        cmake --build ${{github.workspace}}/tag_version/build -j $(nproc)
+
+    - name: Run "tag" UMF tests
+      working-directory: ${{github.workspace}}/tag_version/build
+      run: |
+        LD_LIBRARY_PATH=${{github.workspace}}/tag_version/build/lib/ ctest --output-on-failure
+
+    - name: Run "tag" UMF tests with latest UMF libs (warnings enabled)
+      working-directory: ${{github.workspace}}/tag_version/build
+      run: >
+        UMF_LOG="level:warning;flush:debug;output:stderr;pid:no"
+        LD_LIBRARY_PATH=${{github.workspace}}/latest_version/build/lib/
+        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-latest"
+
+    steps:
+    - name: Checkout "tag" UMF version
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      with:
+        fetch-depth: 0
+        ref: refs/tags/${{inputs.tag}}
+        path: ${{github.workspace}}/tag_version
+
+    - name: Initialize vcpkg
+      uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
+      with:
+        vcpkgGitCommitId: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
+        vcpkgDirectory: ${{github.workspace}}/vcpkg
+        vcpkgJsonGlob: '**/vcpkg.json'
+
+    # NOTE we use vcpkg setup from "tag" version
+    - name: Install dependencies
+      working-directory: ${{github.workspace}}/tag_version
+      run: vcpkg install --triplet x64-windows
+      shell: pwsh # Specifies PowerShell as the shell for running the script.
+
+    - name: Checkout latest UMF version
+      uses: actions/checkout@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: >
+        cmake
+        -B "${{github.workspace}}/tag_version/build"
+        -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
+        -DCMAKE_C_COMPILER=cl
+        -DCMAKE_CXX_COMPILER=cl
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DUMF_BUILD_TESTS=ON
+        -DUMF_BUILD_EXAMPLES=ON
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+
+    - name: Build "tag" UMF
+      run: cmake --build "${{github.workspace}}/tag_version/build" --config Debug -j $Env:NUMBER_OF_PROCESSORS
+
+    - name: Run "tag" UMF tests
+      working-directory: "${{github.workspace}}/tag_version/build"
+      run: ctest -C Debug --output-on-failure --test-dir test
+
+    - name: Run "tag" UMF tests with latest UMF libs (warnings enabled)
+      working-directory: ${{github.workspace}}/tag_version/build
+      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@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_INSTALL_PREFIX=_install
+        -DCMAKE_BUILD_TYPE=Debug
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DCMAKE_C_COMPILER=gcc
+        -DCMAKE_CXX_COMPILER=g++
+        -DUMF_BUILD_TESTS=OFF
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+
+    - name: Build latest UMF
+      working-directory: ${{github.workspace}}/latest_version
+      run: |
+        cmake --build ${{github.workspace}}/latest_version/build -j $(nproc)
+
+    - name: Install latest UMF
+      working-directory: ${{github.workspace}}/latest_version
+      run: cmake --install ${{github.workspace}}/latest_version/build --config Debug
+      
+    - name: Checkout "tag" UMF version
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      with:
+        fetch-depth: 0
+        ref: refs/tags/${{inputs.tag}}
+        path: ${{github.workspace}}/tag_version
+
+    - name: Configure "tag" UMF build
+      working-directory: ${{github.workspace}}/tag_version
+      run: >
+        cmake
+        -B ${{github.workspace}}/tag_version/build
+        -DCMAKE_BUILD_TYPE=Debug
+        -DUMF_BUILD_SHARED_LIBRARY=ON
+        -DCMAKE_C_COMPILER=gcc
+        -DCMAKE_CXX_COMPILER=g++
+        -DUMF_BUILD_TESTS=ON
+        -DUMF_BUILD_GPU_TESTS=ON
+        -DUMF_BUILD_EXAMPLES=ON
+        -DUMF_BUILD_GPU_EXAMPLES=ON
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
+        -DUMF_BUILD_CUDA_PROVIDER=OFF
+        -DUMF_BUILD_${{matrix.provider}}_PROVIDER=ON
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+
+    - name: Build "tag" UMF
+      working-directory: ${{github.workspace}}/tag_version
+      run: |
+        cmake --build ${{github.workspace}}/tag_version/build -j $(nproc)
+
+    - name: Run "tag" UMF tests
+      working-directory: ${{github.workspace}}/tag_version/build
+      run: >
+        LD_LIBRARY_PATH=${{github.workspace}}/tag_version/build/lib/
+        ctest --output-on-failure
+
+    - name: Run "tag" UMF tests with latest UMF libs (warnings enabled)
+      working-directory: ${{github.workspace}}/tag_version/build
+      run: >
+        UMF_LOG="level:warning;flush:debug;output:stderr;pid:no"
+        LD_LIBRARY_PATH=${{github.workspace}}/latest_version/build/lib/
+        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
new file mode 100644
index 000000000..b632b718d
--- /dev/null
+++ b/.github/workflows/reusable_coverage.yml
@@ -0,0 +1,71 @@
+# Coverage build - gather artifacts from other builds and merge them into a single report
+name: Coverage
+
+on:
+  workflow_call:
+    inputs:
+      trigger:
+        description: Type of workflow trigger
+        type: string
+        required: false
+
+permissions:
+  contents: read
+
+env:
+  COVERAGE_DIR : "${{github.workspace}}/coverage"
+
+jobs:
+  Coverage:
+    name: Coverage build
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y lcov
+
+      - name: Download all coverage artifacts
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        with:
+          pattern: exports-coverage-*
+          path: coverage
+          merge-multiple: true
+
+      - name: Compute coverage
+        working-directory: ${{env.COVERAGE_DIR}}
+        id: coverage
+        run: |
+          echo "DIR: $(pwd)" && ls -al
+          ../scripts/coverage/merge_coverage_files.sh exports-coverage total_coverage
+          genhtml --no-function-coverage -o html_report total_coverage 2>&1 | tee output.txt
+          mkdir coverage_report
+          mv html_report ./coverage_report/
+          tail -n2 output.txt >> $GITHUB_STEP_SUMMARY
+          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@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: coverage_html_report
+          path: coverage/coverage_report
+
+      # Only update the badge on push (event is passed only for total coverage)
+      - name: Update coverity badge
+        if: ${{ success() && inputs.trigger == 'push' }}
+        uses: Schneegans/dynamic-badges-action@e9a478b16159b4d31420099ba146cdc50f134483 # v1.7.0
+        with:
+          auth: ${{ secrets.BB_GIST_TOKEN }}
+          gistID: 3f66c77d7035df39aa75dda8a2ac75b3
+          filename: umf_coverage_badge.svg
+          label: Coverage
+          message: ${{ steps.coverage.outputs.COV_OUT }}%
+          valColorRange: ${{ steps.coverage.outputs.COV_OUT }}
+          minColorRange: 50 # <= this value = color: red
+          maxColorRange: 90 # >= this value = color: green
diff --git a/.github/workflows/reusable_dax.yml b/.github/workflows/reusable_dax.yml
new file mode 100644
index 000000000..3d059a07c
--- /dev/null
+++ b/.github/workflows/reusable_dax.yml
@@ -0,0 +1,149 @@
+#
+# This workflow builds and tests the DEVDAX memory provider
+# and the file memory provider with FSDAX.
+# It requires:
+# - a DAX device (e.g. /dev/dax0.0) and
+# - a FSDAX device (e.g. /dev/pmem1)
+# configured and mounted in the OS.
+#
+# The DAX device should be specified using the
+# UMF_TESTS_DEVDAX_PATH and UMF_TESTS_DEVDAX_SIZE environment variables.
+#
+# The FSDAX device should be mounted in the OS (e.g. /mnt/pmem1)
+# and the UMF_TESTS_FSDAX_PATH environment variable
+# should contain a path to a file on this FSDAX device.
+#
+
+name: Dax
+
+on: [workflow_call]
+
+permissions:
+  contents: read
+
+env:
+  DEVDAX_NAMESPACE : "0.0"
+  FSDAX_NAMESPACE : "1.0"
+  FSDAX_PMEM: "pmem1"
+  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"
+  COVERAGE_DIR : "${{github.workspace}}/coverage"
+  COVERAGE_NAME : "exports-coverage-dax"
+  DAX_TESTS: "./test/test_provider_file_memory ./test/test_provider_devdax_memory"
+
+jobs:
+  dax:
+    # 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: |
+          echo DEVDAX_NAMESPACE="${{env.DEVDAX_NAMESPACE}}"
+          ndctl list --namespace=namespace${{env.DEVDAX_NAMESPACE}} --device-dax
+          ls -al /dev/dax${{env.DEVDAX_NAMESPACE}}
+          echo UMF_TESTS_DEVDAX_PATH="/dev/dax${{env.DEVDAX_NAMESPACE}}"
+          echo UMF_TESTS_DEVDAX_SIZE="$(ndctl list --namespace=namespace${{env.DEVDAX_NAMESPACE}} | grep size | cut -d':' -f2 | cut -d',' -f1)"
+
+      - name: Check configuration of the FSDAX
+        run: |
+          echo FSDAX_NAMESPACE="${{env.FSDAX_NAMESPACE}}"
+          echo UMF_TESTS_FSDAX_PATH="${{env.UMF_TESTS_FSDAX_PATH}}"
+          echo UMF_TESTS_FSDAX_PATH_2="${{env.UMF_TESTS_FSDAX_PATH_2}}"
+          ndctl list --namespace=namespace${{env.FSDAX_NAMESPACE}}
+          ls -al /dev/${{env.FSDAX_PMEM}} /mnt/${{env.FSDAX_PMEM}}
+          mount | grep -e "/dev/${{env.FSDAX_PMEM}}"
+          touch ${{env.UMF_TESTS_FSDAX_PATH}} ${{env.UMF_TESTS_FSDAX_PATH_2}}
+          rm -f ${{env.UMF_TESTS_FSDAX_PATH}} ${{env.UMF_TESTS_FSDAX_PATH_2}}
+
+      - name: Checkout
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+
+      - name: Configure build
+        run: >
+          cmake
+          -B ${{env.BUILD_DIR}}
+          -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
+          -DCMAKE_BUILD_TYPE=${{matrix.build_type}}
+          -DCMAKE_C_COMPILER=gcc
+          -DCMAKE_CXX_COMPILER=g++
+          -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}}
+          -DUMF_BUILD_BENCHMARKS=OFF
+          -DUMF_BUILD_TESTS=ON
+          -DUMF_BUILD_GPU_TESTS=OFF
+          -DUMF_BUILD_GPU_EXAMPLES=OFF
+          -DUMF_FORMAT_CODE_STYLE=OFF
+          -DUMF_DEVELOPER_MODE=ON
+          -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+          -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
+          -DUMF_TESTS_FAIL_ON_SKIP=ON
+          ${{ matrix.build_type == 'Debug' && '-DUMF_USE_COVERAGE=ON' || '' }}
+
+      - name: Build UMF
+        run: cmake --build ${{env.BUILD_DIR}} --config ${{matrix.build_type}} -j $(nproc)
+
+      - name: Run the DEVDAX tests
+        working-directory: ${{env.BUILD_DIR}}
+        run: >
+          UMF_TESTS_DEVDAX_PATH="/dev/dax${{env.DEVDAX_NAMESPACE}}"
+          UMF_TESTS_DEVDAX_SIZE="$(ndctl list --namespace=namespace${{env.DEVDAX_NAMESPACE}} | grep size | cut -d':' -f2 | cut -d',' -f1)"
+          ctest -C ${{matrix.build_type}} -V -R devdax
+
+      - name: Run the FSDAX tests
+        working-directory: ${{env.BUILD_DIR}}
+        run: >
+          UMF_TESTS_FSDAX_PATH=${{env.UMF_TESTS_FSDAX_PATH}}
+          UMF_TESTS_FSDAX_PATH_2=${{env.UMF_TESTS_FSDAX_PATH_2}}
+          ctest -C ${{matrix.build_type}} -V -R "file|fsdax"
+
+      - name: Run the DEVDAX tests with the proxy library
+        # proxy library is built only if libumf is a shared library
+        if: ${{ matrix.shared_library == 'ON' }}
+        working-directory: ${{env.BUILD_DIR}}
+        run: >
+          LD_PRELOAD=./lib/libumf_proxy.so
+          UMF_TESTS_DEVDAX_PATH="/dev/dax${{env.DEVDAX_NAMESPACE}}"
+          UMF_TESTS_DEVDAX_SIZE="$(ndctl list --namespace=namespace${{env.DEVDAX_NAMESPACE}} | grep size | cut -d':' -f2 | cut -d',' -f1)"
+          ctest -C ${{matrix.build_type}} -V -R devdax
+
+      - name: Run the FSDAX tests with the proxy library
+        # proxy library is built only if libumf is a shared library
+        if: ${{ matrix.shared_library == 'ON' }}
+        working-directory: ${{env.BUILD_DIR}}
+        run: >
+          LD_PRELOAD=./lib/libumf_proxy.so
+          UMF_TESTS_FSDAX_PATH=${{env.UMF_TESTS_FSDAX_PATH}}
+          UMF_TESTS_FSDAX_PATH_2=${{env.UMF_TESTS_FSDAX_PATH_2}}
+          ctest -C ${{matrix.build_type}} -V -R "file|fsdax"
+
+      - name: Run DAX tests under valgrind
+        run: |
+          ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{env.BUILD_DIR}} memcheck "${{env.DAX_TESTS}}"
+          ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{env.BUILD_DIR}} drd "${{env.DAX_TESTS}}"
+          ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{env.BUILD_DIR}} helgrind "${{env.DAX_TESTS}}"
+
+      - name: Check coverage
+        if:  ${{ matrix.build_type == 'Debug' }}
+        working-directory: ${{env.BUILD_DIR}}
+        run: |
+          export COVERAGE_FILE_NAME=${{env.COVERAGE_NAME}}-shared-${{matrix.shared_library}}
+          echo "COVERAGE_FILE_NAME: $COVERAGE_FILE_NAME"
+          ../scripts/coverage/coverage_capture.sh $COVERAGE_FILE_NAME
+          mkdir -p ${{env.COVERAGE_DIR}}
+          mv ./$COVERAGE_FILE_NAME ${{env.COVERAGE_DIR}}
+
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if:  ${{ matrix.build_type == 'Debug' }}
+        with:
+          name: ${{env.COVERAGE_NAME}}-shared-${{matrix.shared_library}}
+          path: ${{env.COVERAGE_DIR}}
diff --git a/.github/workflows/reusable_dockers_build.yml b/.github/workflows/reusable_dockers_build.yml
new file mode 100644
index 000000000..a0a84ab0e
--- /dev/null
+++ b/.github/workflows/reusable_dockers_build.yml
@@ -0,0 +1,46 @@
+# Build and push Docker images to GHCR
+name: BuildDockers
+
+on: 
+  workflow_call:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  packages: read
+
+jobs: 
+  build-dockers:
+    runs-on: ubuntu-latest
+    strategy: 
+      matrix:
+        os: [ubuntu-20.04, ubuntu-22.04, ubuntu-24.04]
+    env:
+      IMG: ghcr.io/bb-ur/umf-${{ matrix.os }}:latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@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
new file mode 100644
index 000000000..e73b67033
--- /dev/null
+++ b/.github/workflows/reusable_docs_build.yml
@@ -0,0 +1,84 @@
+name: Docs build
+
+on:
+  workflow_call:
+    inputs:
+      upload:
+        description: Should HTML documentation be uploaded as artifact?
+        type: boolean
+        default: false
+
+permissions:
+  contents: read
+
+jobs:
+  DocsBuild:
+    name: Docs build
+    runs-on: ${{ github.repository_owner == 'oneapi-src' && 'intel-ubuntu-22.04' || 'ubuntu-latest' }}
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      with:
+        fetch-depth: 0
+
+    - name: Install doxygen
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y doxygen
+
+    # Latest distros do not allow global pip installation
+    - name: Install Python requirements in venv
+      run: |
+        python3 -m venv .venv
+        . .venv/bin/activate
+        echo "$PATH" >> $GITHUB_PATH
+        python3 -m pip install -r third_party/requirements.txt
+
+    - name: Build the documentation
+      run: |
+        cmake -B build \
+          -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF \
+          -DUMF_BUILD_CUDA_PROVIDER=OFF \
+          -DUMF_BUILD_TESTS=OFF \
+          -DUMF_BUILD_EXAMPLES=OFF \
+          -DUMF_DISABLE_HWLOC=ON
+        cmake --build build --target docs
+
+    #
+    # Documentation is built. Now we want to add benchmark dashboard.
+    # We only do it if inputs.upload is set, as this job is also used for testing docs build.
+    #
+    - name: Checkout benchmark scripts
+      if: ${{ inputs.upload == true }}
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      with:
+        repository: intel/llvm
+        # 15.04.2025
+        # branch: sycl
+        ref: 08d11bcae0cc2daec903f222c9b3e3af92f3b806
+        path: sc
+        sparse-checkout: |
+          devops/scripts/benchmarks
+
+    - name: Move benchmark HTML files
+      if: ${{ inputs.upload == true }}
+      working-directory: ${{ github.workspace }}/build/docs_build/generated/html
+      run: |
+        mkdir performance
+        mv ${{ github.workspace }}/sc/devops/scripts/benchmarks/html/* performance/
+
+    - name: Replace config.js
+      if: ${{ inputs.upload == true }}
+      working-directory: ${{ github.workspace }}/build/docs_build/generated/html
+      run: |
+        cat << 'EOF' > ./performance/config.js
+        remoteDataUrl = 'https://raw.githubusercontent.com/oneapi-src/unified-memory-framework/refs/heads/benchmark-results/data.json';
+        defaultCompareNames = ["Baseline_PVC"];
+        EOF
+
+    - name: Upload artifact
+      if: ${{ inputs.upload == true }}
+      uses: actions/upload-pages-artifact@56afc609e74202658d3ffba0e8f6dda462b719fa # v3.0.1
+      with:
+        path: build/docs_build/generated/html
diff --git a/.github/workflows/fast.yml b/.github/workflows/reusable_fast.yml
similarity index 50%
rename from .github/workflows/fast.yml
rename to .github/workflows/reusable_fast.yml
index a42f0b694..63bbc85d0 100644
--- a/.github/workflows/fast.yml
+++ b/.github/workflows/reusable_fast.yml
@@ -1,97 +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
-            disjoint: 'OFF'
+          - os: ubuntu-24.04
             build_tests: 'ON'
+            extra_build_options: ' -DUMF_BUILD_BENCHMARKS=ON -DUMF_BUILD_BENCHMARKS_MT=ON'
             simple_cmake: 'OFF'
-          # pure C build (Windows)
-          - os: windows-latest
-            disjoint: 'OFF'
+          # pure C build
+          - os: ubuntu-24.04
             # Tests' building is off for a pure C build
             build_tests: 'OFF'
+            extra_build_options: '-DUMF_BUILD_BENCHMARKS=ON'
             simple_cmake: 'OFF'
-          - os: ubuntu-latest
-            disjoint: 'ON'
+          # simplest CMake on Ubuntu 22.04, 24.04
+          - os: ubuntu-24.04
             build_tests: 'ON'
-            # Windows doesn't recognize 'CMAKE_BUILD_TYPE', it uses '--config' param in build command
-            extra_build_options: '-DCMAKE_BUILD_TYPE=Release -DUMF_BUILD_BENCHMARKS=ON -DUMF_BUILD_BENCHMARKS_MT=ON'
-            simple_cmake: 'OFF'
-          # pure C build (Linux)
-          - os: ubuntu-latest
-            disjoint: 'OFF'
-            # Windows doesn't recognize 'CMAKE_BUILD_TYPE', it uses '--config' param in build command
-            # Tests' building is off for a pure C build
-            build_tests: 'OFF'
-            extra_build_options: '-DCMAKE_BUILD_TYPE=Release -DUMF_BUILD_BENCHMARKS=ON'
-            simple_cmake: 'OFF'
-          # simplest CMake on ubuntu-latest
-          - os: ubuntu-latest
-            disjoint: 'OFF'
-            build_tests: 'ON'
-            extra_build_options: '-DCMAKE_BUILD_TYPE=Release'
             simple_cmake: 'ON'
-          # simplest CMake ubuntu-20.04
-          - os: ubuntu-20.04
-            disjoint: 'OFF'
+          - os: ubuntu-22.04
             build_tests: 'ON'
-            extra_build_options: '-DCMAKE_BUILD_TYPE=Release'
             simple_cmake: 'ON'
-    runs-on: ${{matrix.os}}
+    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: 3dd44b931481d7a8e9ba412621fa810232b66289
+        vcpkgGitCommitId: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
         vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
         vcpkgJsonGlob: '**/vcpkg.json'
 
     - name: Install dependencies
-      if: matrix.os == 'windows-latest'
-      run: vcpkg install
+      run: vcpkg install --triplet x64-windows
       shell: pwsh # Specifies PowerShell as the shell for running the script.
 
-    - name: Install apt packages (ubuntu-latest)
-      if: matrix.os == 'ubuntu-latest'
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y cmake libjemalloc-dev libhwloc-dev libnuma-dev libtbb-dev
-
-    - name: Install apt packages (ubuntu-20.04)
-      if: matrix.os == 'ubuntu-20.04'
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y cmake libjemalloc-dev libnuma-dev libtbb-dev
-        .github/scripts/install_hwloc.sh # install hwloc-2.3.0 instead of hwloc-2.1.0 present in the OS package
-
-    - name: Set ptrace value for IPC test (on Linux only)
-      if: ${{ matrix.os == 'ubuntu-latest' || matrix.os == 'ubuntu-20.04' }}
-      run: sudo bash -c "echo 0 > /proc/sys/kernel/yama/ptrace_scope"
-
     - name: Configure CMake
       if: matrix.simple_cmake == 'OFF'
       run: >
@@ -101,14 +128,13 @@ jobs:
         -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
         -DUMF_FORMAT_CODE_STYLE=OFF
         -DUMF_DEVELOPER_MODE=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=${{matrix.disjoint}}
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
         -DUMF_BUILD_TESTS=${{matrix.build_tests}}
         -DUMF_BUILD_EXAMPLES=ON
         -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'
@@ -116,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
@@ -132,20 +158,9 @@ jobs:
       working-directory: ${{env.BUILD_DIR}}
       run: ctest --output-on-failure --test-dir test -C Release
 
-    - name: check /DEPENDENTLOADFLAG (Windows only)
-      if: matrix.os == 'windows-latest'
-      run: ${{github.workspace}}/.github/scripts/check_dll_flags.ps1 ${{env.BUILD_DIR}}/bin/Release/umf.dll
-      shell: pwsh
-
-    - name: check /DEPENDENTLOADFLAG in umf_proxy.dll
-      if: matrix.os == 'windows-latest'
-      run: ${{github.workspace}}/.github/scripts/check_dll_flags.ps1 ${{env.BUILD_DIR}}/src/proxy_lib/Release/umf_proxy.dll
-      shell: pwsh
-
     # 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
new file mode 100644
index 000000000..1f342733e
--- /dev/null
+++ b/.github/workflows/reusable_gpu.yml
@@ -0,0 +1,147 @@
+# This workflow builds and tests providers using GPU memory. It requires properly
+# labelled self-hosted runners on systems with the correct GPU and drivers.
+name: GPU
+
+on:
+  workflow_call:
+    inputs:
+      provider:
+        description: Provider name
+        type: string
+        required: true
+      runner:
+        description: Runner name (without 'DSS-' prefix)
+        type: string
+        required: true
+      os:
+        description: A list of OSes
+        type: string
+        default: "['Ubuntu', 'Windows']"
+      build_type:
+        description: A list of build types
+        type: string
+        default: "['Debug', 'Release']"
+      shared_lib:
+        description: A list of options for building shared library
+        type: string
+        default: "['ON', 'OFF']"
+
+permissions:
+  contents: read
+
+env:
+  BUILD_DIR : "${{github.workspace}}/build"
+  INSTL_DIR : "${{github.workspace}}/install-dir"
+  COVERAGE_DIR : "${{github.workspace}}/coverage"
+
+jobs:
+  gpu:
+    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;"
+      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:
+      fail-fast: false
+      matrix:
+        shared_library: ${{ fromJSON(inputs.shared_lib)}}
+        os: ${{ fromJSON(inputs.os)}}
+        build_type: ${{ fromJSON(inputs.build_type)}}
+    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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+
+      - name: Get information about platform
+        if: matrix.os == 'Ubuntu'
+        run: .github/scripts/get_system_info.sh
+
+      - name: "[Win] Initialize vcpkg"
+        if: matrix.os == 'Windows'
+        uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
+        with:
+          vcpkgGitCommitId: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
+          vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
+          vcpkgJsonGlob: '**/vcpkg.json'
+
+      - name: "[Win] Install dependencies"
+        if: matrix.os == 'Windows'
+        run: vcpkg install --triplet x64-windows
+
+      # note: disable all providers except the one being tested
+      # '-DCMAKE_SUPPRESS_REGENERATION=ON' is the WA for the error: "CUSTOMBUILD : CMake error : Cannot restore timestamp"
+      - name: Configure build
+        run: >
+          cmake
+          -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=${{env.C_COMPILER}}
+          -DCMAKE_CXX_COMPILER=${{env.CXX_COMPILER}}
+          -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}}
+          -DUMF_BUILD_BENCHMARKS=ON
+          -DUMF_BUILD_BENCHMARKS_MT=ON
+          -DUMF_BUILD_TESTS=ON
+          -DUMF_BUILD_GPU_TESTS=ON
+          -DUMF_BUILD_GPU_EXAMPLES=ON
+          -DUMF_DEVELOPER_MODE=ON
+          -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+          -DUMF_BUILD_CUDA_PROVIDER=OFF
+          -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
+          -DUMF_BUILD_${{inputs.provider}}_PROVIDER=ON
+          -DUMF_TESTS_FAIL_ON_SKIP=ON
+          ${{ matrix.os == '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 ${{env.PROCS}}
+
+      - name: Run tests
+        working-directory: ${{env.BUILD_DIR}}
+        run: ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
+
+      - name: Run examples
+        working-directory: ${{env.BUILD_DIR}}
+        run: ctest --output-on-failure --test-dir examples -C ${{matrix.build_type}}
+
+      - name: Run benchmarks
+        if: matrix.build_type == 'Release'
+        working-directory: ${{env.BUILD_DIR}}
+        run: ctest --output-on-failure --test-dir benchmark -C ${{matrix.build_type}} --exclude-regex umf-multithreaded
+
+      - name: Check coverage
+        if: ${{ matrix.build_type == 'Debug' && matrix.os == 'Ubuntu' }}
+        working-directory: ${{env.BUILD_DIR}}
+        run: |
+          export COVERAGE_FILE_NAME=${{env.COVERAGE_NAME}}-shared-${{matrix.shared_library}}
+          echo "COVERAGE_FILE_NAME: $COVERAGE_FILE_NAME"
+          ../scripts/coverage/coverage_capture.sh $COVERAGE_FILE_NAME
+          mkdir -p ${{env.COVERAGE_DIR}}
+          mv ./$COVERAGE_FILE_NAME ${{env.COVERAGE_DIR}}
+
+      - 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}}
+          path: ${{env.COVERAGE_DIR}}
diff --git a/.github/workflows/reusable_multi_numa.yml b/.github/workflows/reusable_multi_numa.yml
new file mode 100644
index 000000000..63075c6f9
--- /dev/null
+++ b/.github/workflows/reusable_multi_numa.yml
@@ -0,0 +1,92 @@
+# Runs tests on multi-numa machines
+name: MultiNuma
+
+on: [workflow_call]
+
+permissions:
+  contents: read
+
+env:
+  BUILD_DIR : "${{github.workspace}}/build"
+  COVERAGE_DIR : "${{github.workspace}}/coverage"
+  COVERAGE_NAME : "exports-coverage-multinuma"
+  NUMA_TESTS: "./test/test_memspace_numa ./test/test_provider_os_memory_multiple_numa_nodes"
+
+jobs:
+  multi_numa:
+    # 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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+
+      - name: Configure build
+        run: >
+          cmake
+          -B ${{github.workspace}}/build
+          -DCMAKE_BUILD_TYPE=${{matrix.build_type}}
+          -DCMAKE_C_COMPILER=gcc
+          -DCMAKE_CXX_COMPILER=g++
+          -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}}
+          -DUMF_BUILD_BENCHMARKS=OFF
+          -DUMF_BUILD_TESTS=ON
+          -DUMF_DEVELOPER_MODE=ON
+          -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=${{ matrix.os == 'rhel-9.1' && 'OFF' || 'ON' }}
+          -DUMF_TESTS_FAIL_ON_SKIP=ON
+          ${{ matrix.build_type == 'Debug' && matrix.os == 'ubuntu-22.04' && '-DUMF_USE_COVERAGE=ON' || '' }}
+
+      - name: Build UMF
+        run: cmake --build ${{github.workspace}}/build -j $(nproc)
+
+      - name: Run tests
+        if: (matrix.os != 'rhel-9.1') && (matrix.os != 'sles-15')
+        working-directory: ${{github.workspace}}/build
+        run: ctest --output-on-failure --test-dir test
+
+        # On RHEL/SLES, hwloc version is just a little too low.
+        # Skip some tests until we upgrade hwloc and update CMake to properly handle local hwloc installation.
+        # TODO: fix issue #560
+      - name: Run tests (on RHEL/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/test_provider_os_memory_multiple_numa_nodes \
+            --gtest_filter="-*checkModeLocal/*:*checkModePreferredEmptyNodeset/*:testNuma.checkModeInterleave"
+
+      - name: Run NUMA tests under valgrind
+        if: (matrix.os != 'rhel-9.1') && (matrix.os != 'sles-15')
+        run: |
+          ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{env.BUILD_DIR}} memcheck "${{env.NUMA_TESTS}}"
+          ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{env.BUILD_DIR}} drd "${{env.NUMA_TESTS}}"
+          ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{env.BUILD_DIR}} helgrind "${{env.NUMA_TESTS}}"
+
+      - name: Check coverage
+        if: ${{ matrix.build_type == 'Debug' && matrix.os == 'ubuntu-22.04' }}
+        working-directory: ${{env.BUILD_DIR}}
+        run: |
+          export COVERAGE_FILE_NAME=${{env.COVERAGE_NAME}}-${{matrix.os}}-shared-${{matrix.shared_library}}
+          echo "COVERAGE_FILE_NAME: $COVERAGE_FILE_NAME"
+          ../scripts/coverage/coverage_capture.sh $COVERAGE_FILE_NAME
+          mkdir -p ${{env.COVERAGE_DIR}}
+          mv ./$COVERAGE_FILE_NAME ${{env.COVERAGE_DIR}}
+
+      - uses: actions/upload-artifact@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}}
+          path: ${{env.COVERAGE_DIR}}
+
+      - name: Get information about platform
+        if: always()
+        run: .github/scripts/get_system_info.sh
diff --git a/.github/workflows/reusable_proxy_lib.yml b/.github/workflows/reusable_proxy_lib.yml
new file mode 100644
index 000000000..4eb191fef
--- /dev/null
+++ b/.github/workflows/reusable_proxy_lib.yml
@@ -0,0 +1,94 @@
+# Builds libumf_proxy and runs tests with it
+name: Proxy library
+
+on: workflow_call
+
+permissions:
+  contents: read
+
+env:
+  BUILD_DIR : "${{github.workspace}}/build"
+  INSTL_DIR : "${{github.workspace}}/install-dir"
+  COVERAGE_DIR : "${{github.workspace}}/coverage"
+  COVERAGE_NAME : "exports-coverage-proxy"
+
+jobs:
+  proxy-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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+
+      - name: Install apt packages
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake libhwloc-dev libnuma-dev libtbb-dev lcov
+
+      - name: Configure build
+        run: >
+          cmake
+          -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}}
+          -DUMF_BUILD_SHARED_LIBRARY=ON
+          -DUMF_BUILD_BENCHMARKS=OFF
+          -DUMF_BUILD_TESTS=ON
+          -DUMF_FORMAT_CODE_STYLE=OFF
+          -DUMF_DEVELOPER_MODE=ON
+          -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+          -DUMF_TESTS_FAIL_ON_SKIP=ON
+          -DUMF_PROXY_LIB_BASED_ON_POOL=${{matrix.proxy_lib_pool}}
+          ${{ matrix.build_type == 'Debug' && '-DUMF_USE_COVERAGE=ON' || '' }}
+
+      - name: Build UMF
+        run: cmake --build ${{env.BUILD_DIR}} -j $(nproc)
+
+      - name: Run "ctest --output-on-failure" with proxy library
+        working-directory: ${{env.BUILD_DIR}}
+        run: LD_PRELOAD=./lib/libumf_proxy.so ctest --output-on-failure
+
+      - name: Run "./test/test_memoryPool" with proxy library
+        working-directory: ${{env.BUILD_DIR}}
+        run: LD_PRELOAD=./lib/libumf_proxy.so ./test/test_memoryPool
+
+      - name: Run "/usr/bin/ls" with proxy library
+        working-directory: ${{env.BUILD_DIR}}
+        run: UMF_PROXY="page.disposition=shared-fd" LD_PRELOAD=./lib/libumf_proxy.so /usr/bin/ls
+
+      - name: Run "/usr/bin/date" with proxy library
+        working-directory: ${{env.BUILD_DIR}}
+        run: UMF_PROXY="page.disposition=shared-shm" LD_PRELOAD=./lib/libumf_proxy.so /usr/bin/date
+
+      - name: Run "ctest --output-on-failure" with proxy library and size.threshold=128
+        working-directory: ${{env.BUILD_DIR}}
+        run: >
+          UMF_PROXY="page.disposition=shared-shm;size.threshold=128"
+          LD_PRELOAD=./lib/libumf_proxy.so
+          ctest --output-on-failure
+
+      - name: Check coverage
+        if:  ${{ matrix.build_type == 'Debug' }}
+        working-directory: ${{env.BUILD_DIR}}
+        run: |
+          export COVERAGE_FILE_NAME=${{env.COVERAGE_NAME}}-proxy_lib_pool-${{matrix.proxy_lib_pool}}
+          echo "COVERAGE_FILE_NAME: $COVERAGE_FILE_NAME"
+          ../scripts/coverage/coverage_capture.sh $COVERAGE_FILE_NAME
+          mkdir -p ${{env.COVERAGE_DIR}}
+          mv ./$COVERAGE_FILE_NAME ${{env.COVERAGE_DIR}}
+
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        if:  ${{ matrix.build_type == 'Debug' }}
+        with:
+          name: ${{env.COVERAGE_NAME}}-proxy_lib_pool-${{matrix.proxy_lib_pool}}
+          path: ${{env.COVERAGE_DIR}}
diff --git a/.github/workflows/reusable_qemu.yml b/.github/workflows/reusable_qemu.yml
new file mode 100644
index 000000000..df4125d1a
--- /dev/null
+++ b/.github/workflows/reusable_qemu.yml
@@ -0,0 +1,155 @@
+# Builds project on qemu with custom hmat settings
+name: Qemu
+
+on:
+  workflow_call:
+    inputs:
+      short_run:
+        description: Should the workflow run only basic tests?
+        type: boolean
+        default: false
+      os:
+        description: List of OSes
+        type: string
+        default: '["ubuntu-24.04"]'
+
+permissions:
+  contents: read
+
+jobs:
+  qemu-build:
+    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@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      with:
+        fetch-depth: 0
+        path: umf
+
+    - name: Enable KVM
+      run: |
+        echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules
+        sudo udevadm control --reload-rules
+        sudo udevadm trigger --name-match=kvm
+
+    - name: Install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y qemu-system genisoimage qemu-utils \
+          libvirt-clients libvirt-daemon-system libvirt-daemon virtinst bridge-utils
+
+    # Latest distros do not allow global pip installation
+    - name: Install Python requirements in venv
+      run: |
+        python3 -m venv .venv
+        . .venv/bin/activate
+        echo "$PATH" >> $GITHUB_PATH
+        python3 -m pip install -r umf/scripts/qemu/requirements.txt
+
+    - name: Add user to kvm group
+      run: sudo usermod -a -G kvm,libvirt $USER
+
+    - name: Run ssh-keygen
+      run: ssh-keygen -b 4096 -N '' -f ~/.ssh/id_rsa
+
+    - name: Generate iso with user info
+      run: |
+        pub_key=$(cat ~/.ssh/id_rsa.pub)
+
+        cat > user-data << EOF
+        #cloud-config
+
+        # Add a 'testuser' user to the system with a password
+        users:
+          - default
+          - name: testuser
+            gecos: Test User
+            primary_group: wheel
+            groups: users
+            sudo: ALL=(ALL) NOPASSWD:ALL
+            lock_passwd: false
+            ssh-authorized-keys:
+              - $pub_key
+            shell: /usr/bin/bash
+
+        # Set local logins
+        chpasswd:
+          list: |
+            root:password
+            testuser:password
+          expire: False
+        EOF
+
+        cat > meta-data << EOF
+        instance-id: qemu-test
+        local-hostname: qemu-test
+        EOF
+
+        sudo -Sk genisoimage -output ubuntu-cloud-init.iso -volid cidata -joliet -rock ./user-data ./meta-data
+
+    - name: Set vars if short run
+      if: ${{ inputs.short_run == true }}
+      run: |
+        echo "SHORT_RUN=true" >> $GITHUB_ENV
+        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
+      if: ${{ inputs.short_run == false }}
+      run: |
+        echo "SHORT_RUN=false" >> $GITHUB_ENV
+        echo "CONFIG_OPTIONS=umf/scripts/qemu/configs/*.xml" >> $GITHUB_ENV
+
+    - name: Download Ubuntu image
+      run: |
+        OS_VER=$(echo ${{matrix.os}} | cut -d'-' -f2)
+        wget https://cloud-images.ubuntu.com/releases/${OS_VER}/release/${{matrix.os}}-server-cloudimg-amd64.img -O qemu_image.img
+
+    - name: Resize image
+      run: qemu-img resize ./qemu_image.img +4G
+
+    - name: Build UMF in QEMU
+      run: |
+        umf/scripts/qemu/start_qemu.sh default.xml
+
+        # Copy UMF repository's content into the home dir in QEMU
+        rsync -az -e "ssh -p 2222" ${{github.workspace}}/umf/ testuser@127.0.0.1:/home/testuser/
+        ssh testuser@127.0.0.1 -p 2222 -t "sudo chown -R testuser:users /home/testuser"
+
+        ssh testuser@127.0.0.1 -p 2222 -t "bash /home/testuser/scripts/qemu/run-build.sh COVERAGE"
+        # ssh may return non-zero error code on closing the connection in Ubuntu 22.04
+        ssh testuser@127.0.0.1 -p 2222 -t "sudo shutdown -h now" || true
+
+    - name: Run tests in QEMU
+      run: |
+        echo "Running tests for: ${CONFIG_OPTIONS}"
+
+        for config_file in ${CONFIG_OPTIONS}; do
+          config_name=$(basename $config_file)
+
+          while ps -aux | grep qemu-system-x86_64 | grep -q -v grep; do
+            echo "Waiting for QEMU to shut down..."
+            sleep 5
+          done
+
+          echo "### Testing ${config_name} ###"
+          umf/scripts/qemu/start_qemu.sh ${config_name}
+
+          ssh testuser@127.0.0.1 -p 2222 -t "export SHORT_RUN=${SHORT_RUN} OS_FULL_NAME=${{matrix.os}} && /home/testuser/scripts/qemu/run-tests.sh COVERAGE ${config_name}"
+          scp -r -P 2222 testuser@127.0.0.1:/home/testuser/coverage ./
+          # ssh may return non-zero error code on closing the connection in Ubuntu 22.04
+          ssh testuser@127.0.0.1 -p 2222 -t "sudo shutdown -h now" || true
+        done
+        ls -al ./coverage
+
+    - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+      with:
+        name: exports-coverage-qemu-${{matrix.os}}
+        path: coverage
diff --git a/.github/workflows/sanitizers.yml b/.github/workflows/reusable_sanitizers.yml
similarity index 76%
rename from .github/workflows/sanitizers.yml
rename to .github/workflows/reusable_sanitizers.yml
index 2ca712543..5c7be09ae 100644
--- a/.github/workflows/sanitizers.yml
+++ b/.github/workflows/reusable_sanitizers.yml
@@ -5,31 +5,31 @@ on: workflow_call
 
 env:
   BUILD_DIR : "${{github.workspace}}/build"
-  INSTL_DIR : "${{github.workspace}}/../install-dir"
+  INSTL_DIR : "${{github.workspace}}/install-dir"
 
 permissions:
   contents: read
 
 jobs:
   ubuntu-build:
-    name: Ubuntu
     strategy:
       matrix:
         compiler: [{c: gcc, cxx: g++}, {c: clang, cxx: clang++}, {c: icx, cxx: icpx}]
         # TSAN is mutually exclusive with other sanitizers
         sanitizers: [{asan: ON, ubsan: ON, tsan: OFF}, {asan: OFF, ubsan: OFF, tsan: ON}]
+    name: Sanitizers (ubuntu-22.04, compilers=${{matrix.compiler.c}}/${{matrix.compiler.cxx}}, asan=${{matrix.sanitizers.asan}}, ubsan=${{matrix.sanitizers.ubsan}}, tsan=${{matrix.sanitizers.tsan}})
     runs-on: ubuntu-22.04
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@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 libjemalloc-dev libtbb-dev
+        sudo apt-get install -y clang cmake libhwloc-dev libnuma-dev libtbb-dev
 
     - name: Install oneAPI basekit
       if: matrix.compiler.cxx == 'icpx'
@@ -40,10 +40,6 @@ jobs:
         sudo apt-get update
         sudo apt-get install -y intel-oneapi-ippcp-devel intel-oneapi-ipp-devel intel-oneapi-common-oneapi-vars intel-oneapi-compiler-dpcpp-cpp
 
-
-    - name: Set ptrace value for IPC test
-      run: sudo bash -c "echo 0 > /proc/sys/kernel/yama/ptrace_scope"
-
     - name: Configure build
       run: >
         ${{ matrix.compiler.cxx == 'icpx' && '. /opt/intel/oneapi/setvars.sh &&' || ''}} 
@@ -55,10 +51,10 @@ jobs:
         -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_DEVELOPER_MODE=OFF
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
         -DUMF_USE_ASAN=${{matrix.sanitizers.asan}}
         -DUMF_USE_UBSAN=${{matrix.sanitizers.ubsan}}
         -DUMF_USE_TSAN=${{matrix.sanitizers.tsan}}
@@ -66,16 +62,19 @@ jobs:
         -DUMF_TESTS_FAIL_ON_SKIP=ON
 
     - name: Build UMF
-      run: cmake --build ${{env.BUILD_DIR}} -j $(nproc)
+      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}}
-      run: > 
-        ${{ matrix.compiler.cxx == 'icpx' && '. /opt/intel/oneapi/setvars.sh &&' || ''}}
+      env:
+        ASAN_OPTIONS: allocator_may_return_null=1
+        TSAN_OPTIONS: allocator_may_return_null=1
+      run: |
         ctest --output-on-failure
 
   windows-build:
-    name: cl and clang-cl on Windows
     env:
       VCPKG_PATH: "${{github.workspace}}/build/vcpkg/packages/hwloc_x64-windows;${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows"
     strategy:
@@ -83,11 +82,12 @@ jobs:
         compiler: [{c: cl, cxx: cl}, {c: clang-cl, cxx: clang-cl}]
         # Only ASAN is supported
         sanitizers: [{asan: ON}]
-    runs-on: windows-2022
+    name: Sanitizers (windows-latest, compilers=${{matrix.compiler.c}}/${{matrix.compiler.cxx}}, asan=${{matrix.sanitizers.asan}})
+    runs-on: windows-latest
 
     steps:
     - name: Checkout
-      uses: actions/checkout@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'
@@ -106,15 +106,14 @@ jobs:
     - name: Initialize vcpkg
       uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
       with:
-        vcpkgGitCommitId: 3dd44b931481d7a8e9ba412621fa810232b66289
+        vcpkgGitCommitId: ea2a964f9303270322cf3f2d51c265ba146c422d # 1.04.2025
         vcpkgDirectory: ${{env.BUILD_DIR}}/vcpkg
         vcpkgJsonGlob: '**/vcpkg.json'
 
     - name: Install dependencies
-      run: vcpkg install
+      run: vcpkg install --triplet x64-windows
       shell: pwsh # Specifies PowerShell as the shell for running the script.
 
-    # TODO enable level zero provider
     - name: Configure build
       run: >
         cmake
@@ -125,11 +124,11 @@ jobs:
         -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
         -DUMF_BUILD_SHARED_LIBRARY=OFF
         -DUMF_FORMAT_CODE_STYLE=OFF
-        -DUMF_DEVELOPER_MODE=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
+        -DUMF_DEVELOPER_MODE=OFF
         -DUMF_USE_ASAN=${{matrix.sanitizers.asan}}
         -DUMF_BUILD_EXAMPLES=ON
-        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=OFF
         -DUMF_TESTS_FAIL_ON_SKIP=ON
 
     - name: Build UMF
@@ -137,4 +136,7 @@ jobs:
 
     - name: Run tests
       working-directory: ${{env.BUILD_DIR}}
+      env:
+        ASAN_OPTIONS: allocator_may_return_null=1
+        TSAN_OPTIONS: allocator_may_return_null=1
       run: ctest -C Debug --output-on-failure
diff --git a/.github/workflows/reusable_sycl.yml b/.github/workflows/reusable_sycl.yml
new file mode 100644
index 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
new file mode 100644
index 000000000..a0de5abec
--- /dev/null
+++ b/.github/workflows/reusable_trivy.yml
@@ -0,0 +1,43 @@
+# Runs linter for Docker files
+name: Trivy
+
+on: workflow_call
+
+permissions:
+  contents: read
+  security-events: read
+
+jobs:
+  trivy:
+    name: Trivy
+    runs-on: ${{ github.repository_owner == 'oneapi-src' && 'intel-ubuntu-22.04' || 'ubuntu-latest' }}
+    permissions:
+      security-events: write
+
+    steps:
+      - name: Clone the git repo
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+
+      - name: Run Trivy
+        uses: aquasecurity/trivy-action@76071ef0d7ec797419534a183b498b4d6366cf37 # v0.31.0
+        with:
+          scan-type: 'config'
+          hide-progress: false
+          format: 'sarif'
+          output: 'trivy-results.sarif'
+          exit-code: 1  # Fail if issue found
+          # file with suppressions: .trivyignore (in root dir)
+
+      - name: Print report and trivyignore file
+        run: |
+          echo "### Trivy ignore content:"
+          cat .trivyignore
+          echo "### Trivy report:"
+          cat trivy-results.sarif
+
+      - name: Upload results
+        uses: github/codeql-action/upload-sarif@ce28f5bb42b7a9f2c824e633a3f6ee835bab6858 # v3.29.0
+        with:
+          sarif_file: 'trivy-results.sarif'
diff --git a/.github/workflows/valgrind.yml b/.github/workflows/reusable_valgrind.yml
similarity index 50%
rename from .github/workflows/valgrind.yml
rename to .github/workflows/reusable_valgrind.yml
index 53569385e..65bb767ed 100644
--- a/.github/workflows/valgrind.yml
+++ b/.github/workflows/reusable_valgrind.yml
@@ -1,3 +1,4 @@
+# Run tests with valgrind instrumentation tools: memcheck, drd, helgrind
 name: Valgrind
 
 on: workflow_call
@@ -8,22 +9,18 @@ permissions:
 jobs:
   valgrind:
     name: Valgrind
-    strategy:
-      fail-fast: false
-      matrix:
-        tool: ['memcheck', 'drd', 'helgrind']
     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
 
     - name: Install apt packages
       run: |
         sudo apt-get update
-        sudo apt-get install -y cmake hwloc libhwloc-dev libjemalloc-dev libnuma-dev libtbb-dev valgrind
+        sudo apt-get install -y cmake hwloc libhwloc-dev libnuma-dev libtbb-dev valgrind
 
     - name: Configure CMake
       run: >
@@ -31,15 +28,21 @@ jobs:
         -B ${{github.workspace}}/build
         -DCMAKE_BUILD_TYPE=Debug
         -DUMF_FORMAT_CODE_STYLE=OFF
-        -DUMF_DEVELOPER_MODE=ON
-        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
+        -DUMF_DEVELOPER_MODE=OFF
         -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=OFF
+        -DUMF_BUILD_CUDA_PROVIDER=OFF
         -DUMF_USE_VALGRIND=1
         -DUMF_TESTS_FAIL_ON_SKIP=ON
 
     - name: Build
       run: cmake --build ${{github.workspace}}/build --config Debug -j$(nproc)
 
-    - name: Run tests under valgrind
-      run: ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{github.workspace}}/build ${{matrix.tool}}
+    - name: Run tests with 'memcheck'
+      run: ${{github.workspace}}/test/test_valgrind.sh ${{github.workspace}} ${{github.workspace}}/build memcheck
+
+    - 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..f42837ff2 100644
--- a/.github/workflows/scorecard.yml
+++ b/.github/workflows/scorecard.yml
@@ -12,7 +12,9 @@ on:
   push:
     branches: [ "main" ]
 
-permissions: read-all
+permissions:
+  contents: read
+  security-events: read
 
 jobs:
   analyze:
@@ -26,12 +28,12 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      uses: actions/checkout@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 +41,7 @@ jobs:
 
     # Upload the results as artifacts to the repository Actions tab.
     - name: Upload artifact
-      uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 # 4.3.1
+      uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # 4.6.2
       with:
         name: Scorecard results
         path: scorecard_results.sarif
@@ -47,6 +49,6 @@ jobs:
 
     # Upload the results to GitHub's code scanning dashboard.
     - name: Upload to code-scanning
-      uses: github/codeql-action/upload-sarif@05963f47d870e2cb19a537396c1f668a348c7d8f # v3.24.8
+      uses: github/codeql-action/upload-sarif@ce28f5bb42b7a9f2c824e633a3f6ee835bab6858 # v3.29.0
       with:
         sarif_file: scorecard_results.sarif
diff --git a/.github/workflows/spellcheck.yml b/.github/workflows/spellcheck.yml
deleted file mode 100644
index 07265fc17..000000000
--- a/.github/workflows/spellcheck.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-# Checks spelling issues in the repo
-name: SpellCheck
-
-on: workflow_call
-
-permissions:
-  contents: read
-
-jobs:
-  analyze:
-    name: Run spell check
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      with:
-        fetch-depth: 0
-
-    - name: Run a spell check
-      uses: crate-ci/typos@b63f421581dce830bda2f597a678cb7776b41877 # v1.18.2
-      with:
-        config: ./.github/workflows/.spellcheck-conf.toml
diff --git a/.github/workflows/trivy.yml b/.github/workflows/trivy.yml
deleted file mode 100644
index 1c3e63120..000000000
--- a/.github/workflows/trivy.yml
+++ /dev/null
@@ -1,57 +0,0 @@
-# Runs linter for Docker files
-name: Trivy
-
-# Due to lower score on Scorecard we're running this separately from
-# "PR/push" workflow. For some reason permissions weren't properly set
-# or recognized (by Scorecard). If Scorecard changes its behavior we can
-# use 'workflow_call' trigger.
-on:
-  push:
-    branches-ignore:
-      - 'dependabot/**'
-  pull_request:
-    paths:
-      - '.github/docker/*Dockerfile'
-      - '.github/workflows/trivy.yml'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-
-jobs:
-  trivy:
-    name: Trivy
-    runs-on: ubuntu-latest
-    permissions:
-      security-events: write
-
-    steps:
-      - name: Clone the git repo
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-        with:
-          fetch-depth: 0
-
-      - name: Run Trivy
-        uses: aquasecurity/trivy-action@84384bd6e777ef152729993b8145ea352e9dd3ef # v0.17.0
-        with:
-          scan-type: 'config'
-          hide-progress: false
-          format: 'sarif'
-          output: 'trivy-results.sarif'
-          exit-code: 1  # Fail if issue found
-          # file with suppressions: .trivyignore (in root dir)
-
-      - name: Print report and trivyignore file
-        run: |
-          echo "### Trivy ignore content:"
-          cat .trivyignore
-          echo "### Trivy report:"
-          cat trivy-results.sarif
-
-      - name: Upload results
-        uses: github/codeql-action/upload-sarif@e8893c57a1f3a2b659b6b55564fdfdbbd2982911 # v3.24.0
-        with:
-          sarif_file: 'trivy-results.sarif'
diff --git a/.github/workflows/weekly.yml b/.github/workflows/weekly.yml
new file mode 100644
index 000000000..fcaf8e913
--- /dev/null
+++ b/.github/workflows/weekly.yml
@@ -0,0 +1,75 @@
+# Various non-standard tests, requiring e.g. very long runs or just not required to be run very often.
+name: Weekly
+
+# This job is run every Saturday at 01:00 UTC or on demand.
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0 1 * * 6' # every Saturday at 01:00 UTC
+
+env:
+  BUILD_DIR : "${{github.workspace}}/build"
+  INSTL_DIR : "${{github.workspace}}/install-dir"
+
+permissions:
+  contents: read
+
+jobs:
+  # Check code with looped compilers' sanitizers. With 1000 iterations it should take around 4,5 hours.
+  sanitizers-looped:
+    name: Sanitizers looped
+    strategy:
+      fail-fast: false
+      matrix:
+        compiler: [{c: gcc, cxx: g++}, {c: clang, cxx: clang++}, {c: icx, cxx: icpx}]
+        # TSAN is mutually exclusive with other sanitizers
+        sanitizers: [{asan: ON, ubsan: ON, tsan: OFF}, {asan: OFF, ubsan: OFF, tsan: ON}]
+    runs-on: ubuntu-22.04
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@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 .github/scripts/install_oneAPI.sh
+
+    - name: Configure build
+      run: >
+        ${{ matrix.compiler.cxx == 'icpx' && '. /opt/intel/oneapi/setvars.sh &&' || ''}}
+        cmake
+        -B ${{env.BUILD_DIR}}
+        -DCMAKE_INSTALL_PREFIX="${{env.INSTL_DIR}}"
+        -DCMAKE_BUILD_TYPE=Debug
+        -DUMF_BUILD_SHARED_LIBRARY=OFF
+        -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
+        -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
+        -DUMF_BUILD_CUDA_PROVIDER=ON
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=OFF
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+        -DUMF_USE_ASAN=${{matrix.sanitizers.asan}}
+        -DUMF_USE_UBSAN=${{matrix.sanitizers.ubsan}}
+        -DUMF_USE_TSAN=${{matrix.sanitizers.tsan}}
+        -DUMF_BUILD_EXAMPLES=ON
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+
+    - name: Build UMF
+      run: |
+        ${{ matrix.compiler.cxx == 'icpx' && '. /opt/intel/oneapi/setvars.sh' || true }}
+        cmake --build ${{env.BUILD_DIR}} -j $(nproc)
+
+    - name: Run tests
+      working-directory: ${{env.BUILD_DIR}}
+      env:
+        ASAN_OPTIONS: allocator_may_return_null=1
+        TSAN_OPTIONS: allocator_may_return_null=1
+      run: for i in {1..1000}; do ctest --output-on-failure || exit 1; date; done
diff --git a/.gitignore b/.gitignore
index a1a488bc1..7d0aa10fd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -58,7 +58,7 @@ __pycache__/
 *.py[cod]
 
 # Generated docs
-docs/
+docs_build/
 
 # Build files
 /build*/
@@ -83,3 +83,7 @@ out/
 # IDE Files
 /.vscode
 /.devcontainer
+
+# clangd files
+/.cache/clangd
+compile_commands.json
diff --git a/.mailmap b/.mailmap
new file mode 100644
index 000000000..de589da03
--- /dev/null
+++ b/.mailmap
@@ -0,0 +1,7 @@
+Rafał Rudnicki <rafal.rudnicki@intel.com>
+Igor Chorążewicz <igor.chorazewicz@intel.com>
+<adam.szopinski@intel.com> <83662296+szadam@users.noreply.github.com>
+Adam Szopiński <adam.szopinski@intel.com>
+Adam Szopiński <adam.szopinski@intel.com> Adam <szadamx@gmail.com>
+Adam Szopiński <adam.szopinski@intel.com> szadam <szadamx@gmail.com>
+Sergei Vinogradov <sergey.vinogradov@intel.com>
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 020009c86..4eeb575df 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,8 +1,10 @@
-# Copyright (C) 2022-2024 Intel Corporation
+# Copyright (C) 2022-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+message(STATUS "CMake version: ${CMAKE_VERSION}")
 cmake_minimum_required(VERSION 3.14.0 FATAL_ERROR)
+
 # needed when UMF is used as an external project
 set(UMF_CMAKE_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
@@ -10,8 +12,12 @@ list(APPEND CMAKE_MODULE_PATH "${UMF_CMAKE_SOURCE_DIR}/cmake")
 # Use full path of the helpers module (to omit potential conflicts with others)
 include(${UMF_CMAKE_SOURCE_DIR}/cmake/helpers.cmake)
 
+# --------------------------------------------------------------------------- #
+# Set UMF version variables, define project, and add basic modules
+# --------------------------------------------------------------------------- #
+
 # We use semver aligned version, set via git tags. We parse git output to
-# establih the version of UMF to be used in CMake, Win dll's, and within the
+# establish the version of UMF to be used in CMake, Win dll's, and within the
 # code (e.g. in logger). We have 3-component releases (e.g. 1.5.1) plus release
 # candidates and git info. Function below sets all variables related to version.
 set_version_variables()
@@ -22,6 +28,12 @@ project(
     umf
     VERSION ${UMF_CMAKE_VERSION}
     LANGUAGES C)
+if(UMF_CMAKE_VERSION VERSION_EQUAL "0.0.0")
+    message(
+        WARNING
+            "UMF version is set to 0.0.0, which most likely is not expected! "
+            "Please checkout the git tags to get a proper version.")
+endif()
 
 if(PROJECT_VERSION_PATCH GREATER 0)
     # set extra variable for Windows dll metadata
@@ -31,46 +43,71 @@ endif()
 include(CTest)
 include(CMakePackageConfigHelpers)
 include(GNUInstallDirs)
+include(FetchContent)
 find_package(PkgConfig)
 
-# Build Options
-option(UMF_BUILD_SHARED_LIBRARY "Build UMF as shared library" OFF)
-option(UMF_BUILD_LEVEL_ZERO_PROVIDER "Build Level Zero memory provider" ON)
-option(UMF_BUILD_LIBUMF_POOL_DISJOINT
-       "Build the libumf_pool_disjoint static library" OFF)
-option(UMF_BUILD_LIBUMF_POOL_JEMALLOC
-       "Build the libumf_pool_jemalloc static library" OFF)
-option(UMF_BUILD_TESTS "Build UMF tests" ON)
-option(UMF_BUILD_GPU_TESTS "Build UMF GPU tests" OFF)
-option(UMF_BUILD_BENCHMARKS "Build UMF benchmarks" OFF)
-option(UMF_BUILD_BENCHMARKS_MT "Build UMF multithreaded benchmarks" OFF)
-option(UMF_BUILD_EXAMPLES "Build UMF examples" ON)
-option(UMF_BUILD_FUZZTESTS "Build UMF fuzz tests" OFF)
-option(UMF_BUILD_GPU_EXAMPLES "Build UMF GPU examples" OFF)
-option(UMF_DEVELOPER_MODE "Enable additional developer checks" OFF)
-option(
+# --------------------------------------------------------------------------- #
+# Set UMF build options (and CACHE variables)
+# --------------------------------------------------------------------------- #
+
+# Define a list to store the names of all options
+set(UMF_OPTIONS_LIST "")
+list(APPEND UMF_OPTIONS_LIST CMAKE_BUILD_TYPE)
+
+# Define a macro to wrap the option() command and track the options
+macro(umf_option)
+    list(APPEND UMF_OPTIONS_LIST ${ARGV0})
+    option(${ARGV})
+endmacro()
+
+# All CMake options have to be explicitly set in the build_umfd target's
+# configuration command
+umf_option(UMF_BUILD_SHARED_LIBRARY "Build UMF as shared library" OFF)
+umf_option(UMF_BUILD_LEVEL_ZERO_PROVIDER "Build Level Zero memory provider" ON)
+umf_option(UMF_BUILD_CUDA_PROVIDER "Build CUDA memory provider" ON)
+umf_option(UMF_BUILD_LIBUMF_POOL_JEMALLOC
+           "Build the libumf_pool_jemalloc static library" OFF)
+umf_option(UMF_BUILD_TESTS "Build UMF tests" ON)
+umf_option(UMF_BUILD_GPU_TESTS "Build UMF GPU tests" OFF)
+umf_option(UMF_BUILD_BENCHMARKS "Build UMF benchmarks" OFF)
+umf_option(UMF_BUILD_BENCHMARKS_MT "Build UMF multithreaded benchmarks" OFF)
+umf_option(UMF_BUILD_EXAMPLES "Build UMF examples" ON)
+umf_option(UMF_BUILD_GPU_EXAMPLES "Build UMF GPU examples" 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)"
+    OFF)
+umf_option(
     UMF_LINK_HWLOC_STATICALLY
-    "Link UMF with HWLOC library statically (supported for Linux, MacOS and Release build on Windows)"
+    "Link UMF with HWLOC library statically (proxy library will be disabled on Windows+Debug build)"
     OFF)
-option(UMF_FORMAT_CODE_STYLE
-       "Add clang, cmake, and black -format-check and -format-apply targets"
-       OFF)
 set(UMF_HWLOC_NAME
     "hwloc"
     CACHE STRING "Custom name for hwloc library w/o extension")
-
+list(APPEND UMF_OPTIONS_LIST UMF_HWLOC_NAME)
+set(UMF_INSTALL_RPATH
+    ""
+    CACHE
+        STRING
+        "Set the runtime search path to the directory with dependencies (e.g. hwloc)"
+)
+
+umf_option(UMF_USE_DEBUG_POSTFIX "Add a 'd' postfix to Windows debug libraries"
+           OFF)
+umf_option(UMF_DEVELOPER_MODE "Enable additional developer checks" OFF)
+umf_option(
+    UMF_FORMAT_CODE_STYLE
+    "Add clang, cmake, and black -format-check and -format-apply targets" OFF)
 # Only a part of skips is treated as a failure now. TODO: extend to all tests
-option(UMF_TESTS_FAIL_ON_SKIP "Treat skips in tests as fail" OFF)
-option(UMF_USE_ASAN "Enable AddressSanitizer checks" OFF)
-option(UMF_USE_UBSAN "Enable UndefinedBehaviorSanitizer checks" OFF)
-option(UMF_USE_TSAN "Enable ThreadSanitizer checks" OFF)
-option(UMF_USE_MSAN "Enable MemorySanitizer checks" OFF)
-option(UMF_USE_VALGRIND "Enable Valgrind instrumentation" OFF)
-option(UMF_USE_GCOV "Enable gcov support" OFF)
-option(
-    UMF_DISABLE_HWLOC
-    "Disable features that requires hwloc (OS provider, memory targets, topolgy discovery)"
-    OFF)
+umf_option(UMF_TESTS_FAIL_ON_SKIP "Treat skips in tests as fail" OFF)
+umf_option(UMF_USE_ASAN "Enable AddressSanitizer checks" OFF)
+umf_option(UMF_USE_UBSAN "Enable UndefinedBehaviorSanitizer checks" OFF)
+umf_option(UMF_USE_TSAN "Enable ThreadSanitizer checks" OFF)
+umf_option(UMF_USE_MSAN "Enable MemorySanitizer checks" OFF)
+umf_option(UMF_USE_VALGRIND "Enable Valgrind instrumentation" OFF)
+umf_option(UMF_USE_COVERAGE "Build with coverage enabled (Linux only)" OFF)
 
 # set UMF_PROXY_LIB_BASED_ON_POOL to one of: SCALABLE or JEMALLOC
 set(KNOWN_PROXY_LIB_POOLS SCALABLE JEMALLOC)
@@ -80,6 +117,20 @@ set(UMF_PROXY_LIB_BASED_ON_POOL
           "A UMF pool the proxy library is based on (SCALABLE or JEMALLOC)")
 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.
+# --------------------------------------------------------------------------- #
+message(STATUS "CMAKE_GENERATOR: ${CMAKE_GENERATOR}")
 
 if(UMF_BUILD_TESTS
    AND DEFINED ENV{CI}
@@ -104,112 +155,234 @@ else()
     message(FATAL_ERROR "Unknown OS type")
 endif()
 
-if(NOT DEFINED UMF_HWLOC_REPO)
-    set(UMF_HWLOC_REPO "https://github.com/open-mpi/hwloc.git")
+if(UMF_DEVELOPER_MODE)
+    set(UMF_COMMON_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS}
+                                       UMF_DEVELOPER_MODE=1)
 endif()
 
-if(NOT DEFINED UMF_HWLOC_TAG)
-    set(UMF_HWLOC_TAG hwloc-2.10.0)
-endif()
-
-if(NOT UMF_LINK_HWLOC_STATICALLY)
-    if(NOT UMF_DISABLE_HWLOC)
-        pkg_check_modules(LIBHWLOC hwloc>=2.3.0)
-        if(NOT LIBHWLOC_FOUND)
-            find_package(LIBHWLOC 2.3.0 REQUIRED hwloc)
-        endif()
+message(STATUS "CMAKE_PREFIX_PATH=${CMAKE_PREFIX_PATH}")
 
-        # add PATH to DLL on Windows
-        set(DLL_PATH_LIST
-            "${DLL_PATH_LIST};PATH=path_list_append:${LIBHWLOC_DLL_DIRS}")
+if(NOT UMF_BUILD_LIBUMF_POOL_JEMALLOC)
+    set(UMF_POOL_JEMALLOC_ENABLED FALSE)
+    set(JEMALLOC_FOUND FALSE)
+    set(JEMALLOC_LIBRARIES FALSE)
+elseif(WINDOWS)
+    pkg_check_modules(JEMALLOC jemalloc)
+    if(NOT JEMALLOC_FOUND)
+        find_package(JEMALLOC REQUIRED jemalloc)
     endif()
-    # add PATH to DLL on Windows
-    set(DLL_PATH_LIST
-        "${DLL_PATH_LIST};PATH=path_list_append:${LIBHWLOC_DLL_DIRS}")
-elseif(WINDOWS AND NOT UMF_DISABLE_HWLOC)
-    include(FetchContent)
-    set(HWLOC_ENABLE_TESTING OFF)
-    set(HWLOC_SKIP_LSTOPO ON)
-    set(HWLOC_SKIP_TOOLS ON)
-
-    message(STATUS "Will fetch hwloc from ${UMF_HWLOC_REPO}")
-
-    FetchContent_Declare(
-        hwloc_targ
-        GIT_REPOSITORY ${UMF_HWLOC_REPO}
-        GIT_TAG ${UMF_HWLOC_TAG}
-        SOURCE_SUBDIR contrib/windows-cmake/ FIND_PACKAGE_ARGS)
-
-    FetchContent_GetProperties(hwloc_targ)
-    if(NOT hwloc_targ_POPULATED)
-        FetchContent_MakeAvailable(hwloc_targ)
+else()
+    if(NOT DEFINED UMF_JEMALLOC_REPO)
+        set(UMF_JEMALLOC_REPO "https://github.com/jemalloc/jemalloc.git")
     endif()
 
-    set(LIBHWLOC_INCLUDE_DIRS
-        ${hwloc_targ_SOURCE_DIR}/include;${hwloc_targ_BINARY_DIR}/include)
-    set(LIBHWLOC_LIBRARY_DIRS
-        ${hwloc_targ_BINARY_DIR}/Release;${hwloc_targ_BINARY_DIR}/Debug)
-
-    message(STATUS "    LIBHWLOC_LIBRARIES = ${LIBHWLOC_LIBRARIES}")
-    message(STATUS "    LIBHWLOC_INCLUDE_DIRS = ${LIBHWLOC_INCLUDE_DIRS}")
-    message(STATUS "    LIBHWLOC_LIBRARY_DIRS = ${LIBHWLOC_LIBRARY_DIRS}")
-elseif(NOT UMF_DISABLE_HWLOC)
-    include(FetchContent)
+    if(NOT DEFINED UMF_JEMALLOC_TAG)
+        set(UMF_JEMALLOC_TAG 5.3.0)
+    endif()
 
-    message(STATUS "Will fetch hwloc from ${UMF_HWLOC_REPO}")
+    message(
+        STATUS
+            "Will fetch jemalloc from ${UMF_JEMALLOC_REPO} (tag: ${UMF_JEMALLOC_TAG})"
+    )
 
     FetchContent_Declare(
-        hwloc_targ
-        GIT_REPOSITORY ${UMF_HWLOC_REPO}
-        GIT_TAG ${UMF_HWLOC_TAG})
-
-    FetchContent_GetProperties(hwloc_targ)
-    if(NOT hwloc_targ_POPULATED)
-        FetchContent_MakeAvailable(hwloc_targ)
-    endif()
+        jemalloc_targ
+        GIT_REPOSITORY ${UMF_JEMALLOC_REPO}
+        GIT_TAG ${UMF_JEMALLOC_TAG})
+    FetchContent_MakeAvailable(jemalloc_targ)
 
     add_custom_command(
         COMMAND ./autogen.sh
-        WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
-        OUTPUT ${hwloc_targ_SOURCE_DIR}/configure)
+        WORKING_DIRECTORY ${jemalloc_targ_SOURCE_DIR}
+        OUTPUT ${jemalloc_targ_SOURCE_DIR}/configure)
     add_custom_command(
+        # Custom jemalloc build. Non-default options used:
+        # --with-jemalloc-prefix=je_ - add je_ prefix to all public APIs
+        # --disable-cxx - Disable C++ integration. This will cause new and
+        # delete operators implementations to be omitted.
+        # --disable-initial-exec-tls - Disable the initial-exec TLS model for
+        # jemalloc's internal thread-local storage (on those platforms that
+        # support explicit settings). This can allow jemalloc to be dynamically
+        # loaded after program startup (e.g. using dlopen). --disable-doc -
+        # Disable building and installing the documentation.
         COMMAND
-            ./configure --prefix=${hwloc_targ_BINARY_DIR} --enable-static=yes
-            --enable-shared=no --disable-libxml2 --disable-pci
-            --disable-levelzero --disable-opencl --disable-cuda --disable-nvml
-            CFLAGS=-fPIC CXXFLAGS=-fPIC
-        WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
-        OUTPUT ${hwloc_targ_SOURCE_DIR}/Makefile
-        DEPENDS ${hwloc_targ_SOURCE_DIR}/configure)
+            ./configure --prefix=${jemalloc_targ_BINARY_DIR}
+            --with-jemalloc-prefix=je_ --disable-cxx --disable-initial-exec-tls
+            --disable-doc CFLAGS=-fPIC
+        WORKING_DIRECTORY ${jemalloc_targ_SOURCE_DIR}
+        OUTPUT ${jemalloc_targ_SOURCE_DIR}/Makefile
+        DEPENDS ${jemalloc_targ_SOURCE_DIR}/configure)
+
+    if(NOT UMF_QEMU_BUILD)
+        set(MAKE_ARGUMENTS "-j$(nproc)")
+    endif()
+
     add_custom_command(
-        COMMAND make
-        WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
-        OUTPUT ${hwloc_targ_SOURCE_DIR}/lib/libhwloc.la
-        DEPENDS ${hwloc_targ_SOURCE_DIR}/Makefile)
+        COMMAND make ${MAKE_ARGUMENTS}
+        WORKING_DIRECTORY ${jemalloc_targ_SOURCE_DIR}
+        OUTPUT ${jemalloc_targ_SOURCE_DIR}/lib/libjemalloc.a
+        DEPENDS ${jemalloc_targ_SOURCE_DIR}/Makefile)
     add_custom_command(
         COMMAND make install
-        WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
-        OUTPUT ${hwloc_targ_BINARY_DIR}/lib/libhwloc.a
-        DEPENDS ${hwloc_targ_SOURCE_DIR}/lib/libhwloc.la)
+        WORKING_DIRECTORY ${jemalloc_targ_SOURCE_DIR}
+        OUTPUT ${jemalloc_targ_BINARY_DIR}/lib/libjemalloc.a
+        DEPENDS ${jemalloc_targ_SOURCE_DIR}/lib/libjemalloc.a)
+
+    add_custom_target(jemalloc_prod
+                      DEPENDS ${jemalloc_targ_BINARY_DIR}/lib/libjemalloc.a)
+    add_library(jemalloc INTERFACE)
+    target_link_libraries(
+        jemalloc INTERFACE ${jemalloc_targ_BINARY_DIR}/lib/libjemalloc.a)
+    add_dependencies(jemalloc jemalloc_prod)
+
+    set(JEMALLOC_FOUND TRUE)
+    set(JEMALLOC_LIBRARY_DIRS ${jemalloc_targ_BINARY_DIR}/lib)
+    set(JEMALLOC_INCLUDE_DIRS ${jemalloc_targ_BINARY_DIR}/include)
+    set(JEMALLOC_LIBRARIES ${jemalloc_targ_BINARY_DIR}/lib/libjemalloc.a)
+endif()
+
+if(JEMALLOC_FOUND)
+    set(UMF_POOL_JEMALLOC_ENABLED TRUE)
+    # add PATH to DLL on Windows
+    set(DLL_PATH_LIST
+        "${DLL_PATH_LIST};PATH=path_list_append:${JEMALLOC_DLL_DIRS}")
+    message(STATUS "    JEMALLOC_LIBRARIES = ${JEMALLOC_LIBRARIES}")
+    message(STATUS "    JEMALLOC_INCLUDE_DIRS = ${JEMALLOC_INCLUDE_DIRS}")
+    message(STATUS "    JEMALLOC_LIBRARY_DIRS = ${JEMALLOC_LIBRARY_DIRS}")
+    if(WINDOWS)
+        message(STATUS "    JEMALLOC_DLL_DIRS = ${JEMALLOC_DLL_DIRS}")
+    endif()
+else()
+    set(UMF_POOL_JEMALLOC_ENABLED FALSE)
+    message(
+        STATUS
+            "Disabling the Jemalloc Pool and tests and benchmarks that use it because jemalloc was not built/found."
+    )
+endif()
+
+if(NOT UMF_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)
+    endif()
 
-    add_custom_target(hwloc_prod
-                      DEPENDS ${hwloc_targ_BINARY_DIR}/lib/libhwloc.a)
-    add_library(hwloc INTERFACE)
-    target_link_libraries(hwloc
-                          INTERFACE ${hwloc_targ_BINARY_DIR}/lib/libhwloc.a)
-    add_dependencies(hwloc hwloc_prod)
+    if(LIBHWLOC_FOUND)
+        # add PATH to DLL on Windows
+        set(DLL_PATH_LIST
+            "${DLL_PATH_LIST};PATH=path_list_append:${LIBHWLOC_DLL_DIRS}")
+    else()
+        set(UMF_LINK_HWLOC_STATICALLY ON)
+    endif()
+endif()
+
+if(UMF_LINK_HWLOC_STATICALLY AND LINUX)
+    find_program(AUTORECONF_EXECUTABLE autoreconf)
+    if(NOT AUTORECONF_EXECUTABLE)
+        message(WARNING "autoreconf is not installed. Disabling hwloc.")
+        set(UMF_DISABLE_HWLOC ON)
+        set(UMF_LINK_HWLOC_STATICALLY OFF)
+    endif()
+endif()
+
+if(UMF_DISABLE_HWLOC)
+    message(STATUS "hwloc is disabled, hence OS provider, memtargets, "
+                   "topology discovery, examples won't be available!")
+else()
+    if(UMF_LINK_HWLOC_STATICALLY)
+        if(NOT DEFINED UMF_HWLOC_REPO)
+            set(UMF_HWLOC_REPO "https://github.com/open-mpi/hwloc.git")
+        endif()
+
+        if(NOT DEFINED UMF_HWLOC_TAG)
+            set(UMF_HWLOC_TAG hwloc-2.10.0)
+        endif()
+        message(
+            STATUS
+                "Will fetch hwloc from ${UMF_HWLOC_REPO} (tag: ${UMF_HWLOC_TAG})"
+        )
 
-    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)
+        if(WINDOWS)
+            set(HWLOC_ENABLE_TESTING OFF)
+            set(HWLOC_SKIP_LSTOPO ON)
+            set(HWLOC_SKIP_TOOLS ON)
+            set(HWLOC_SKIP_INCLUDES ON)
+
+            FetchContent_Declare(
+                hwloc_targ
+                GIT_REPOSITORY ${UMF_HWLOC_REPO}
+                GIT_TAG ${UMF_HWLOC_TAG}
+                SOURCE_SUBDIR contrib/windows-cmake/)
+            FetchContent_MakeAvailable(hwloc_targ)
+
+            set(HWLOC_LIB_PATH "")
+            if(CMAKE_GENERATOR STREQUAL "NMake Makefiles")
+                set(HWLOC_LIB_PATH "${hwloc_targ_BINARY_DIR}/hwloc.lib")
+            else()
+                set(HWLOC_LIB_PATH "${hwloc_targ_BINARY_DIR}/lib/hwloc.lib")
+            endif()
+
+            get_filename_component(LIBHWLOC_LIBRARY_DIRS ${HWLOC_LIB_PATH}
+                                   DIRECTORY)
+            set(LIBHWLOC_LIBRARIES ${HWLOC_LIB_PATH})
+            set(LIBHWLOC_INCLUDE_DIRS ${hwloc_targ_BINARY_DIR}/include)
+            set(LIBHWLOC_FOUND TRUE)
+        else() # not Windows
+            FetchContent_Declare(
+                hwloc_targ
+                GIT_REPOSITORY ${UMF_HWLOC_REPO}
+                GIT_TAG ${UMF_HWLOC_TAG})
+            FetchContent_MakeAvailable(hwloc_targ)
+
+            add_custom_command(
+                COMMAND ./autogen.sh
+                WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
+                OUTPUT ${hwloc_targ_SOURCE_DIR}/configure)
+            add_custom_command(
+                COMMAND
+                    ./configure --prefix=${hwloc_targ_BINARY_DIR}
+                    --enable-static=yes --enable-shared=no --disable-libxml2
+                    --disable-pci --disable-levelzero --disable-opencl
+                    --disable-cuda --disable-nvml --disable-libudev
+                    --disable-rsmi CFLAGS=-fPIC CXXFLAGS=-fPIC
+                WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
+                OUTPUT ${hwloc_targ_SOURCE_DIR}/Makefile
+                DEPENDS ${hwloc_targ_SOURCE_DIR}/configure)
+            add_custom_command(
+                COMMAND make
+                WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
+                OUTPUT ${hwloc_targ_SOURCE_DIR}/lib/libhwloc.la
+                DEPENDS ${hwloc_targ_SOURCE_DIR}/Makefile)
+            add_custom_command(
+                COMMAND make install
+                WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
+                OUTPUT ${hwloc_targ_BINARY_DIR}/lib/libhwloc.a
+                DEPENDS ${hwloc_targ_SOURCE_DIR}/lib/libhwloc.la)
+
+            add_custom_target(hwloc_prod
+                              DEPENDS ${hwloc_targ_BINARY_DIR}/lib/libhwloc.a)
+            add_library(hwloc INTERFACE)
+            target_link_libraries(
+                hwloc INTERFACE ${hwloc_targ_BINARY_DIR}/lib/libhwloc.a)
+            add_dependencies(hwloc hwloc_prod)
+
+            set(LIBHWLOC_LIBRARY_DIRS ${hwloc_targ_BINARY_DIR}/lib)
+            set(LIBHWLOC_INCLUDE_DIRS ${hwloc_targ_BINARY_DIR}/include)
+            set(LIBHWLOC_LIBRARIES ${hwloc_targ_BINARY_DIR}/lib/libhwloc.a)
+            set(LIBHWLOC_FOUND TRUE)
+        endif()
+    endif() # UMF_LINK_HWLOC_STATICALLY
 
     message(STATUS "    LIBHWLOC_LIBRARIES = ${LIBHWLOC_LIBRARIES}")
     message(STATUS "    LIBHWLOC_INCLUDE_DIRS = ${LIBHWLOC_INCLUDE_DIRS}")
     message(STATUS "    LIBHWLOC_LIBRARY_DIRS = ${LIBHWLOC_LIBRARY_DIRS}")
+    message(STATUS "    LIBHWLOC_API_VERSION = ${LIBHWLOC_API_VERSION}")
+    if(WINDOWS)
+        message(STATUS "    LIBHWLOC_DLL_DIRS = ${LIBHWLOC_DLL_DIRS}")
+    endif()
 endif()
 
 if(hwloc_targ_SOURCE_DIR)
-    # apply security patch for HWLOC
+    # Apply security patch for HWLOC
     execute_process(
         COMMAND git apply ${PROJECT_SOURCE_DIR}/cmake/fix_coverity_issues.patch
         WORKING_DIRECTORY ${hwloc_targ_SOURCE_DIR}
@@ -224,6 +397,186 @@ if(hwloc_targ_SOURCE_DIR)
     endif()
 endif()
 
+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()
+
+    # 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)
+
+        message(STATUS "Fetching Level Zero loader (${LEVEL_ZERO_LOADER_TAG}) "
+                       "from ${LEVEL_ZERO_LOADER_REPO} ...")
+
+        # We don't want to build and include Level Zero binaries to our install
+        # target. For CMake >= 3.28 we use EXCLUDE_FROM_ALL flag to do that, but
+        # for older versions we need to use FetchContent_Populate.
+        if(CMAKE_VERSION VERSION_LESS 3.28)
+            FetchContent_Declare(
+                level-zero-loader
+                GIT_REPOSITORY ${LEVEL_ZERO_LOADER_REPO}
+                GIT_TAG ${LEVEL_ZERO_LOADER_TAG})
+            FetchContent_Populate(level-zero-loader)
+        else()
+            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
+if(WINDOWS AND UMF_USE_DEBUG_POSTFIX)
+    # The build_umfd target's configuration command requires to have
+    # CMAKE_PREFIX_PATH with semicolons escaped
+    string(JOIN "\;" UMFD_CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH})
+    add_custom_target(
+        build_umfd ALL
+        COMMAND
+            ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" -S ${UMF_CMAKE_SOURCE_DIR}
+            -B ${CMAKE_BINARY_DIR}/umfd_build -DCMAKE_BUILD_TYPE=Debug
+            -DCMAKE_DEBUG_POSTFIX=d
+            -DCMAKE_PREFIX_PATH="${UMFD_CMAKE_PREFIX_PATH}"
+            -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+            -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+            -DUMF_USE_DEBUG_POSTFIX=OFF
+            -DUMF_BUILD_SHARED_LIBRARY=${UMF_BUILD_SHARED_LIBRARY}
+            -DUMF_BUILD_LEVEL_ZERO_PROVIDER=${UMF_BUILD_LEVEL_ZERO_PROVIDER}
+            -DUMF_BUILD_CUDA_PROVIDER=${UMF_BUILD_CUDA_PROVIDER}
+            -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=${UMF_BUILD_LIBUMF_POOL_JEMALLOC}
+            -DUMF_BUILD_TESTS=OFF -DUMF_BUILD_GPU_TESTS=OFF
+            -DUMF_BUILD_BENCHMARKS=OFF -DUMF_BUILD_BENCHMARKS_MT=OFF
+            -DUMF_BUILD_EXAMPLES=OFF -DUMF_BUILD_GPU_EXAMPLES=OFF
+            -DUMF_BUILD_FUZZTESTS=OFF -DUMF_DISABLE_HWLOC=${UMF_DISABLE_HWLOC}
+            -DUMF_LINK_HWLOC_STATICALLY=${UMF_LINK_HWLOC_STATICALLY}
+            -DUMF_HWLOC_NAME=${UMF_HWLOC_NAME}
+            -DUMF_INSTALL_RPATH=${UMF_INSTALL_RPATH} -DUMF_DEVELOPER_MODE=OFF
+            -DUMF_FORMAT_CODE_STYLE=OFF -DUMF_TESTS_FAIL_ON_SKIP=OFF
+            -DUMF_USE_ASAN=OFF -DUMF_USE_UBSAN=OFF -DUMF_USE_TSAN=OFF
+            -DUMF_USE_MSAN=OFF -DUMF_USE_VALGRIND=OFF -DUMF_USE_COVERAGE=OFF
+            -DUMF_PROXY_LIB_BASED_ON_POOL=${UMF_PROXY_LIB_BASED_ON_POOL}
+        COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR}/umfd_build --target
+                umf --config Debug
+        COMMENT
+            "Configuring and building umfd.dll in a separate directory with Debug configuration"
+    )
+
+    # Copy built UMF libraries to the main binary directory and remove
+    # umfd_build
+    if(CMAKE_CONFIGURATION_TYPES)
+        # Multi-config generator (e.g., Visual Studio)
+        set(UMFD_DLL_SRC "${CMAKE_BINARY_DIR}/umfd_build/bin/Debug/umfd.dll")
+        set(UMFD_LIB_SRC "${CMAKE_BINARY_DIR}/umfd_build/lib/Debug/umfd.lib")
+        set(UMFD_DLL "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/umfd.dll")
+        set(UMFD_LIB "${CMAKE_BINARY_DIR}/lib/$<CONFIG>/umfd.lib")
+    else()
+        # Single-config generator (e.g., Ninja)
+        set(UMFD_DLL_SRC "${CMAKE_BINARY_DIR}/umfd_build/bin/umfd.dll")
+        set(UMFD_LIB_SRC "${CMAKE_BINARY_DIR}/umfd_build/lib/umfd.lib")
+        set(UMFD_DLL "${CMAKE_BINARY_DIR}/bin/umfd.dll")
+        set(UMFD_LIB "${CMAKE_BINARY_DIR}/lib/umfd.lib")
+    endif()
+
+    if(UMF_BUILD_SHARED_LIBRARY)
+        add_custom_command(
+            TARGET build_umfd
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different ${UMFD_DLL_SRC}
+                    ${UMFD_DLL}
+            COMMENT "Copying umfd.dll to the main binary directory")
+    endif()
+    add_custom_command(
+        TARGET build_umfd
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${UMFD_LIB_SRC}
+                ${UMFD_LIB}
+        COMMAND ${CMAKE_COMMAND} -E remove_directory
+                ${CMAKE_BINARY_DIR}/umfd_build DEPENDS ${UMFD_DLL}
+        COMMENT "Copying umfd.lib to the main library directory")
+endif()
+
 # This build type check is not possible on Windows when CMAKE_BUILD_TYPE is not
 # set, because in this case the build type is determined after a CMake
 # configuration is done (at the build time)
@@ -260,8 +613,8 @@ endif()
 # For using the options listed in the OPTIONS_REQUIRING_CXX variable a C++17
 # compiler is required. Moreover, if these options are not set, CMake will set
 # up a strict C build, without C++ support.
-set(OPTIONS_REQUIRING_CXX "UMF_BUILD_TESTS" "UMF_BUILD_LIBUMF_POOL_DISJOINT"
-                          "UMF_BUILD_BENCHMARKS_MT")
+set(OPTIONS_REQUIRING_CXX "UMF_BUILD_TESTS" "UMF_BUILD_BENCHMARKS_MT"
+                          "UMF_BUILD_BENCHMARKS")
 foreach(option_name ${OPTIONS_REQUIRING_CXX})
     if(${option_name})
         enable_language(CXX)
@@ -274,15 +627,26 @@ endforeach()
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
 set(CMAKE_UMF_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
-if(MSVC)
+if(CMAKE_GENERATOR MATCHES "Visual Studio" OR CMAKE_GENERATOR MATCHES
+                                              "Ninja Multi-Config")
     set(CMAKE_UMF_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin/$<CONFIG>)
 endif()
 
-# Define a path for custom commands to work around MSVC
-set(CUSTOM_COMMAND_BINARY_DIR ${CMAKE_UMF_OUTPUT_DIRECTORY})
-if(MSVC)
-    # MSVC implicitly adds $<CONFIG> to the output path
-    set(CUSTOM_COMMAND_BINARY_DIR ${CUSTOM_COMMAND_BINARY_DIR}/$<CONFIG>)
+# 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
@@ -300,16 +664,36 @@ 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 library to specify include directories in transitive
-# dependencies.
+# A header-only lib to specify include directories in transitive dependencies
 add_library(umf_headers INTERFACE)
 
 # Alias target to support FetchContent.
@@ -338,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)
@@ -350,17 +734,6 @@ else()
     set(UMF_POOL_SCALABLE_ENABLED FALSE)
 endif()
 
-if(UMF_BUILD_LIBUMF_POOL_JEMALLOC)
-    pkg_check_modules(JEMALLOC jemalloc)
-    if(NOT JEMALLOC_FOUND)
-        find_package(JEMALLOC REQUIRED jemalloc)
-    endif()
-    # add PATH to DLL on Windows
-    set(DLL_PATH_LIST
-        "${DLL_PATH_LIST};PATH=path_list_append:${JEMALLOC_DLL_DIRS}")
-endif()
-
-# set UMF_PROXY_LIB_ENABLED
 if(WINDOWS)
     # TODO: enable the proxy library in the Debug build on Windows
     #
@@ -379,7 +752,17 @@ if(WINDOWS)
         )
     endif()
 endif()
-if(UMF_PROXY_LIB_BASED_ON_POOL STREQUAL SCALABLE)
+
+# set UMF_PROXY_LIB_ENABLED
+if(UMF_DISABLE_HWLOC)
+    message(STATUS "Disabling the proxy library, because HWLOC is disabled")
+elseif(NOT UMF_BUILD_SHARED_LIBRARY)
+    # TODO enable this scenario
+    message(
+        STATUS
+            "Disabling the proxy library, because UMF is built as static library"
+    )
+elseif(UMF_PROXY_LIB_BASED_ON_POOL STREQUAL SCALABLE)
     if(UMF_POOL_SCALABLE_ENABLED)
         set(UMF_PROXY_LIB_ENABLED ON)
         set(PROXY_LIB_USES_SCALABLE_POOL ON)
@@ -391,14 +774,14 @@ if(UMF_PROXY_LIB_BASED_ON_POOL STREQUAL SCALABLE)
         )
     endif()
 elseif(UMF_PROXY_LIB_BASED_ON_POOL STREQUAL JEMALLOC)
-    if(UMF_BUILD_LIBUMF_POOL_JEMALLOC)
+    if(UMF_POOL_JEMALLOC_ENABLED)
         set(UMF_PROXY_LIB_ENABLED ON)
         set(PROXY_LIB_USES_JEMALLOC_POOL ON)
-        set(PROXY_LIBS jemalloc_pool umf)
+        set(PROXY_LIBS umf)
     else()
         message(
             STATUS
-                "Disabling the proxy library, because UMF_PROXY_LIB_BASED_ON_POOL==JEMALLOC but UMF_BUILD_LIBUMF_POOL_JEMALLOC is OFF"
+                "Disabling the proxy library, because UMF_PROXY_LIB_BASED_ON_POOL==JEMALLOC but the jemalloc pool is disabled"
         )
     endif()
 else()
@@ -408,18 +791,6 @@ else()
     )
 endif()
 
-set(UMF_OPTIONAL_SYMBOLS_LINUX "")
-set(UMF_OPTIONAL_SYMBOLS_WINDOWS "")
-
-# Conditional configuration for Level Zero provider
-if(UMF_BUILD_LEVEL_ZERO_PROVIDER)
-    add_optional_symbol(umfLevelZeroMemoryProviderOps)
-endif()
-
-if(NOT UMF_DISABLE_HWLOC)
-    add_optional_symbol(umfOsMemoryProviderOps)
-endif()
-
 add_subdirectory(src)
 
 if(UMF_BUILD_TESTS)
@@ -430,12 +801,8 @@ if(UMF_BUILD_BENCHMARKS)
     add_subdirectory(benchmark)
 endif()
 
-if(UMF_BUILD_EXAMPLES)
-    if(NOT UMF_DISABLE_HWLOC)
-        add_subdirectory(examples)
-    else()
-        message(WARNING "Examples cannot be build - hwloc disabled")
-    endif()
+if(UMF_BUILD_EXAMPLES AND NOT UMF_DISABLE_HWLOC)
+    add_subdirectory(examples)
 endif()
 
 if(UMF_FORMAT_CODE_STYLE)
@@ -553,7 +920,7 @@ if(UMF_FORMAT_CODE_STYLE)
         add_custom_target(
             cmake-format-apply
             COMMAND ${CMAKE_FORMAT} --in-place ${format_cmake_list}
-            COMMENT "Format Cmake files using cmake-format")
+            COMMENT "Format CMake files using cmake-format")
     endif()
 
     if(BLACK)
@@ -568,12 +935,12 @@ if(UMF_FORMAT_CODE_STYLE)
 
         add_custom_target(
             black-format-check
-            COMMAND ${BLACK} --check --verbose ${CMAKE_SOURCE_DIR}
+            COMMAND ${BLACK} --check --verbose ${UMF_CMAKE_SOURCE_DIR}
             COMMENT "Check Python files formatting using black formatter")
 
         add_custom_target(
             black-format-apply
-            COMMAND ${BLACK} ${CMAKE_SOURCE_DIR}
+            COMMAND ${BLACK} ${UMF_CMAKE_SOURCE_DIR}
             COMMENT "Format Python files using black formatter")
     endif()
 
@@ -603,20 +970,44 @@ if(UMF_FORMAT_CODE_STYLE)
             COMMENT "Format C/C++, CMake, and Python files")
         message(
             STATUS
-                "  Adding convenience targets 'format-check' and 'format-apply'."
-        )
+                "Adding convenience targets 'format-check' and 'format-apply'.")
     else()
         message(
             STATUS
-                "  Convenience targets 'format-check' and 'format-apply' are "
+                "Convenience targets 'format-check' and 'format-apply' are "
                 "not available. Use commands specific for found tools (see the log above)."
         )
     endif()
 endif()
 
+find_package(Python3 3.8)
+if(Python3_FOUND)
+    message(STATUS "Adding 'docs' target for creating a documentation.")
+    add_custom_target(
+        docs
+        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+        COMMAND UMF_VERSION=${UMF_CMAKE_VERSION} ${Python3_EXECUTABLE}
+                ${UMF_CMAKE_SOURCE_DIR}/docs/generate_docs.py
+        COMMENT "Generate HTML documentation using Doxygen")
+endif()
+
 # --------------------------------------------------------------------------- #
 # Configure make install/uninstall and packages
 # --------------------------------------------------------------------------- #
+# Install the umfd library files as part of the umfd component
+if(WINDOWS AND UMF_USE_DEBUG_POSTFIX)
+    if(UMF_BUILD_SHARED_LIBRARY)
+        install(
+            FILES ${UMFD_DLL}
+            DESTINATION ${CMAKE_INSTALL_BINDIR}
+            COMPONENT umfd)
+    endif()
+    install(
+        FILES ${UMFD_LIB}
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        COMPONENT umfd)
+endif()
+
 install(FILES ${PROJECT_SOURCE_DIR}/LICENSE.TXT
         DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/doc/${PROJECT_NAME}/")
 install(
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index 58dba18db..2e7fbf7d6 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -5,7 +5,7 @@
 We as members, contributors, and leaders pledge to make participation in our
 community a harassment-free experience for everyone, regardless of age, body
 size, visible or invisible disability, ethnicity, sex characteristics, gender
-identity and expression, level of experience, education, socio-economic status,
+identity and expression, level of experience, education, socioeconomic status,
 nationality, personal appearance, race, caste, color, religion, or sexual
 identity and orientation.
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index e350cd8d0..cb2f9de1f 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,15 +2,21 @@
 
 
 <!-- TODO: Add [Naming convention](#naming-convention) section -->
-- [Opening new issues](#opening-new-issues)
-- [Submitting Pull Requests](#submitting-pull-requests)
+- [Contributing to UMF (Unified Memory Framework)](#contributing-to-umf-unified-memory-framework)
+  - [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)
+    - [When my PR is merged?](#when-my-pr-is-merged)
     - [Extending public API](#extending-public-api)
     - [License](#license)
     - [Adding new dependency](#adding-new-dependency)
-- [Code coverage](#code-coverage)
+  - [Code coverage](#code-coverage)
+  - [Debugging](#debugging)
+    - [Checking UMF version and build options](#checking-umf-version-and-build-options)
+      - [Linux](#linux)
+      - [Windows](#windows)
 
 Below you'll find instructions on how to contribute to UMF, either with code changes
 or issues. All contributions are most welcome!
@@ -62,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 
@@ -89,14 +102,16 @@ $ cmake --build build --target format-apply
 # Remember to review introduced changes
 ```
 
-If you wish to use only `clang-format`, or `cmake-format`, or `black`, you can execute the corresponding
-`clang-format-check` and `clang-format-apply` for C/C++ source files, or `cmake-format-check` and
-`cmake-format-apply` for CMake files, or `black-format-check` and `black-format-apply` for Python
-source files, respectively.
+**NOTE**: The `format-check` and `format-apply` targets are only available if all of `clang-format`,
+`cmake-format` and `black` are installed. Otherwise you can use them separately with:
+- `clang-format-check` and `clang-format-apply` for C/C++ source files 
+- `cmake-format-check` and `cmake-format-apply` for CMake files
+- `black-format-check` and `black-format-apply` for Python source files
 
 **NOTE**: We use specific versions of formatting tools to ensure consistency across the project. The required versions are:
 - clang-format version **15.0**, which can be installed with the command: `python -m pip install clang-format==15.0.7`.
 - cmake-format version **0.6**, which can be installed with the command: `python -m pip install cmake-format==0.6.13`.
+- black (no specific version required), which can be installed with the command: `python -m pip install black`.
 
 Please ensure you have these specific versions installed before contributing to the project.
 
@@ -207,16 +222,45 @@ origin: https://dependency_origin.com
 ## Code coverage
 
 After adding a new functionality add tests and check coverage before and after the change.
-To do this, enable coverage instrumentation by turning on the UMF_USE_GCOV flag in CMake.
+To do this, enable coverage instrumentation by turning on the UMF_USE_COVERAGE flag in CMake.
 Coverage instrumentation feature is supported only by GCC and Clang.
 An example flow might look like the following:
 
 ```bash
-$ cmake -B build -DUMF_USE_GCOV=1 -DCMAKE_BUILD_TYPE=Debug
+$ cmake -B build -DUMF_USE_COVERAGE=1 -DCMAKE_BUILD_TYPE=Debug
 $ cmake --build build -j
 $ cd build
 $ ctest
 $ apt install lcov
 $ lcov --capture --directory . --output-file coverage.info
 $ genhtml -o html_report coverage.info
-```
\ No newline at end of file
+```
+
+## Debugging
+
+### Checking UMF version and build options
+
+From an already built UMF shared library you can obtain UMF precise version and
+CMake variables/options it was built with. It's not only useful to verify what should
+be included within the library, but also for debugging. If you're filing an issue to
+UMF project, please include this information in your ticket.
+
+#### Linux
+
+Make sure the `binutils` package is installed in your system. Then, you can use
+the following grep command:
+
+```bash
+$ strings libumf.so | grep "@(#)"
+@(#) Intel(R) UMF version: 0.11.0-dev.git66.g89e3831d
+@(#) Intel(R) UMF CMake variables: "CMAKE_BUILD_TYPE:Debug,...
+```
+
+Please note, that version available in the name of library file (e.g. `libumf.so.0.11.0`)
+may be not accurate - version coded inside of the library is far more precise.
+
+#### Windows
+
+On Windows, DLL's metadata can be accessed e.g. looking into *Properties* of the dll file
+in the explorer. Look into the *Details* tab for "Product version" and "File description"
+(it contains UMF's build options).
diff --git a/ChangeLog b/ChangeLog
index 2b41d7d9b..c12e01f37 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,70 @@
+Mon May 12 2025 Łukasz Stolarczuk <lukasz.stolarczuk@intel.com>
+
+	* Version 0.11.2
+
+	This patch release contains following changes:
+	- retrieve numanode object by os index instead of logical index (#1309)
+
+Thu May 08 2025 Łukasz Stolarczuk <lukasz.stolarczuk@intel.com>
+
+	* Version 0.11.1
+
+	This patch release contains following changes:
+	- check global state destruction in destructors (#1297)
+	- a minor change in UMF logs (#1299)
+
+Thu Apr 17 2025 Łukasz Stolarczuk <lukasz.stolarczuk@intel.com>
+
+	* Version 0.11.0
+
+	This release contains:
+	- make disjoint pool a C structure #898
+	- add fixed provider #976
+	- remove the Coarse provider #934 and replace with internal coarse library #931, #932
+	- implement umfPool[Set/Get]Tag #962
+	- L0 provider: implement support for defer and blocking free #963
+	- add set/restore context in CUDA provider free() #1049
+	- L0 provider: implement min/recommended page size query #1059
+	- add support for CUDA allocation flags #1079
+	- increase refcount to ze_loader/CUDA libraries #1086
+	- implement size limit for the cache of opened IPC handles #998
+	- allow creating fixed provider based on allocations from another pool #1143
+	- multiple benchmark improvements
+	- new tests and CI workflows, incl. backward compatibility checks (#1087, #1163)
+
+Fri Jan 10 2025 Łukasz Stolarczuk <lukasz.stolarczuk@intel.com>
+
+	* Version 0.10.1
+
+	This patch release contains:
+	- Set symbol versions 0.10 in def/map files (#1013)
+	- Fix: remove incorrect assert in utils_align_ptr_up_size_down() (#977)
+	- Add strings with UMF version and useful CMake options (#992)
+	- Extended error messages, when providers are disabled (#1012)
+
+Mon Dec 09 2024 Łukasz Stolarczuk <lukasz.stolarczuk@intel.com>
+
+	* Version 0.10.0
+
+	In this release we introduced updates in several areas, listed below.
+	We still don't yet guarantee a fully stable API, though.
+	With new parameters' API we broke the compatibility, as we no longer
+	support direct access to UMF params via (now internal) structures.
+
+	Significant updates:
+	- updated Level Zero Provider
+	- new API to handle UMF parameters (replacing previous struct's)
+	- extended IPC API testing
+	- new Memtarget and Memspace API
+
+	Minor updates:
+	- multiple fixes in the source code
+	- extended code coverage reporting
+	- improved CI and testing
+	- new examples
+	- extended logging
+	- yet more fixes in the building system
+
 Tue Nov 12 2024 Łukasz Stolarczuk <lukasz.stolarczuk@intel.com>
 
 	* Version 0.9.1
diff --git a/README.md b/README.md
index 528fe9c8b..403f897bb 100644
--- a/README.md
+++ b/README.md
@@ -1,15 +1,13 @@
 # Unified Memory Framework
 
-[![Basic builds](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/basic.yml/badge.svg?branch=main)](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/basic.yml)
-[![CodeQL](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/codeql.yml/badge.svg?branch=main)](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/codeql.yml)
-[![SpellCheck](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/spellcheck.yml/badge.svg?branch=main)](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/spellcheck.yml)
+[![PR/push](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/pr_push.yml/badge.svg?branch=main&event=push)](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/pr_push.yml)
+[![Coverage](https://gist.githubusercontent.com/bb-ur/3f66c77d7035df39aa75dda8a2ac75b3/raw/umf_coverage_badge.svg)](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/pr_push.yml?query=branch%3Amain)
 [![GitHubPages](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/docs.yml/badge.svg?branch=main)](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/docs.yml)
-[![Benchmarks](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/benchmarks.yml/badge.svg?branch=main)](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/benchmarks.yml)
 [![Nightly](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/nightly.yml/badge.svg?branch=main)](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/nightly.yml)
-[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/oneapi-src/unified-memory-framework/badge)](https://securityscorecards.dev/viewer/?uri=github.com/oneapi-src/unified-memory-framework)
+[![Weekly](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/weekly.yml/badge.svg)](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/weekly.yml)
 [![Coverity build](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/coverity.yml/badge.svg?branch=main)](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/coverity.yml)
 [![Coverity report](https://scan.coverity.com/projects/29761/badge.svg?flat=0)](https://scan.coverity.com/projects/oneapi-src-unified-memory-framework)
-[![Bandit](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/bandit.yml/badge.svg?branch=main)](https://github.com/oneapi-src/unified-memory-framework/actions/workflows/bandit.yml)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/oneapi-src/unified-memory-framework/badge)](https://securityscorecards.dev/viewer/?uri=github.com/oneapi-src/unified-memory-framework)
 
 ## Introduction
 
@@ -20,51 +18,52 @@ The Unified Memory Framework (UMF) is a library for constructing allocators and
 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)
-and the more advanced one that allocates
-[USM memory from the GPU device](https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/basic/gpu_shared_memory.c)
-using the Level Zero API and UMF Level Zero memory provider.
+[basic example](https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/basic/basic.c).
+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
 
 ### Requirements
 
 Required packages:
+
 - libhwloc-dev >= 2.3.0 (Linux) / hwloc >= 2.3.0 (Windows)
 - C compiler
 - [CMake](https://cmake.org/) >= 3.14.0
 
 For development and contributions:
+
 - clang-format-15.0 (can be installed with `python -m pip install clang-format==15.0.7`)
 - cmake-format-0.6 (can be installed with `python -m pip install cmake-format==0.6.13`)
 - black (can be installed with `python -m pip install black==24.3.0`)
 
-For building tests, multithreaded benchmarks and Disjoint Pool:
+For building tests and multithreaded benchmarks:
+
 - C++ compiler with C++17 support
 
 For Level Zero memory provider tests:
+
 - Level Zero headers and libraries
 - compatible GPU with installed driver
 
 ### Linux
 
-Executable and binaries will be in **build/bin**
+Executable and binaries will be in **build/bin**.
+The `{build_config}` can be either `Debug` or `Release`.
 
 ```bash
-$ mkdir build
-$ cd build
-$ cmake {path_to_source_dir}
-$ make
+cmake -B build -DCMAKE_BUILD_TYPE={build_config}
+cmake --build build -j $(nproc)
 ```
 
 ### Windows
 
-Generating Visual Studio Project. EXE and binaries will be in **build/bin/{build_config}**
+Generating Visual Studio Project. EXE and binaries will be in **build/bin/{build_config}**.
+The `{build_config}` can be either `Debug` or `Release`.
 
 ```bash
-$ mkdir build
-$ cd build
-$ cmake {path_to_source_dir} -G "Visual Studio 15 2017 Win64"
+cmake -B build -G "Visual Studio 15 2017 Win64"
+cmake --build build --config {build_config} -j $Env:NUMBER_OF_PROCESSORS
 ```
 
 ### Benchmark
@@ -74,26 +73,42 @@ In order to build the benchmark, the `UMF_BUILD_BENCHMARKS` CMake configuration
 
 UMF also provides multithreaded benchmarks that can be enabled by setting both
 `UMF_BUILD_BENCHMARKS` and `UMF_BUILD_BENCHMARKS_MT` CMake
-configuration flags to `ON`. Multithreaded benchmarks require a C++ support.
+configuration flags to `ON`. Multithreaded benchmarks require C++ support.
 
-The Scalable Pool requirements can be found in the relevant 'Memory Pool 
+The Scalable Pool requirements can be found in the relevant 'Memory Pool
 managers' section below.
 
 ### Sanitizers
 
 List of sanitizers available on Linux:
+
 - AddressSanitizer
 - UndefinedBehaviorSanitizer
 - ThreadSanitizer
-   - Is mutually exclusive with other sanitizers.
+  - Is mutually exclusive with other sanitizers.
 - MemorySanitizer
-   - Requires linking against MSan-instrumented libraries to prevent false positive reports. More information [here](https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo).
+  - Requires linking against MSan-instrumented libraries to prevent false positive reports. More information [here](https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo).
 
 List of sanitizers available on Windows:
+
 - AddressSanitizer
 
 Listed sanitizers can be enabled with appropriate [CMake options](#cmake-standard-options).
 
+### Fuzz testing
+
+To enable fuzz testing, the `UMF_BUILD_FUZZTESTS` CMake configuration flag must
+be set to `ON`. Note, that this feature is supported only on Linux and requires
+Clang. Additionally, ensure that the `CMAKE_PREFIX_PATH` includes the directory
+containing the libraries necessary for fuzzing (e.g., Clang's
+libclang_rt.fuzzer_no_main-x86_64.a).
+
+Example:
+
+```bash
+cmake -B build -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_BUILD_TYPE=Debug -DUMF_BUILD_FUZZTESTS=ON -DCMAKE_PREFIX_PATH=/path/to/fuzzer/libs
+```
+
 ### CMake standard options
 
 List of options provided by CMake:
@@ -102,13 +117,13 @@ List of options provided by CMake:
 | - | - | - | - |
 | UMF_BUILD_SHARED_LIBRARY | Build UMF as shared library | ON/OFF | OFF |
 | UMF_BUILD_LEVEL_ZERO_PROVIDER | Build Level Zero memory provider | ON/OFF | ON |
-| UMF_BUILD_LIBUMF_POOL_DISJOINT | Build the libumf_pool_disjoint static library | ON/OFF | OFF |
+| UMF_BUILD_CUDA_PROVIDER | Build CUDA memory provider | ON/OFF | ON |
 | UMF_BUILD_LIBUMF_POOL_JEMALLOC | Build the libumf_pool_jemalloc static library | ON/OFF | OFF |
 | UMF_BUILD_TESTS | Build UMF tests | ON/OFF | ON |
 | UMF_BUILD_GPU_TESTS | Build UMF GPU tests | ON/OFF | OFF |
 | UMF_BUILD_BENCHMARKS | Build UMF benchmarks | ON/OFF | OFF |
 | UMF_BUILD_EXAMPLES | Build UMF examples | ON/OFF | ON |
-| UMF_BUILD_FUZZTESTS | Build UMF fuzz tests | ON/OFF | OFF |
+| UMF_BUILD_FUZZTESTS | Build UMF fuzz tests (supported only on Linux with Clang) | ON/OFF | OFF |
 | UMF_BUILD_GPU_EXAMPLES | Build UMF GPU examples | ON/OFF | OFF |
 | UMF_DEVELOPER_MODE | Enable additional developer checks | ON/OFF | OFF |
 | UMF_FORMAT_CODE_STYLE | Add clang, cmake, and black -format-check and -format-apply targets to make | ON/OFF | OFF |
@@ -118,59 +133,142 @@ List of options provided by CMake:
 | UMF_USE_TSAN | Enable ThreadSanitizer checks | ON/OFF | OFF |
 | UMF_USE_MSAN | Enable MemorySanitizer checks | ON/OFF | OFF |
 | UMF_USE_VALGRIND | Enable Valgrind instrumentation | ON/OFF | OFF |
-| UMF_USE_GCOV | Enable gcov support (Linux only) | ON/OFF | OFF |
-| UMF_LINK_HWLOC_STATICALLY | Link UMF with HWLOC library statically (Windows+Release only) | ON/OFF | OFF |
+| UMF_USE_COVERAGE | Build with coverage enabled (Linux only) | ON/OFF | OFF |
+| UMF_LINK_HWLOC_STATICALLY | Link UMF with HWLOC library statically (proxy library will be disabled on Windows+Debug build) | ON/OFF | OFF |
+| UMF_DISABLE_HWLOC | Disable features that requires hwloc (OS provider, memory targets, topology discovery) | ON/OFF | OFF |
 
 ## Architecture: memory pools and providers
 
-A UMF memory pool is a combination of a pool allocator and a memory provider. A memory provider is responsible for coarse-grained memory allocations and management of memory pages, while the pool allocator controls memory pooling and handles fine-grained memory allocations.
+A UMF memory pool is a combination of a pool allocator and a memory provider. A memory provider is responsible for
+coarse-grained memory allocations and management of memory pages, while the pool allocator controls memory pooling
+and handles fine-grained memory allocations.
 
 Pool allocator can leverage existing allocators (e.g. jemalloc or tbbmalloc) or be written from scratch.
 
-UMF comes with predefined pool allocators (see include/pool) and providers (see include/provider). UMF can also work with user-defined pools and providers that implement a specific interface (see include/umf/memory_pool_ops.h and include/umf/memory_provider_ops.h).
+UMF comes with predefined pool allocators (see [`include/umf/pools`](include/umf/pools)) and providers
+(see [`include/umf/providers`](include/umf/providers)). UMF can also work with user-defined pools and
+providers that implement a specific interface (see [`include/umf/memory_pool_ops.h`](include/umf/memory_pool_ops.h)
+and [`include/umf/memory_provider_ops.h`](include/umf/memory_provider_ops.h)).
 
-More detailed documentation is available here: https://oneapi-src.github.io/unified-memory-framework/
+More detailed documentation is available here: <https://oneapi-src.github.io/unified-memory-framework/>
 
 ### Memory providers
 
+#### Fixed memory provider
+
+A memory provider that can provide memory from a given pre-allocated buffer.
+
 #### OS memory provider
 
 A memory provider that provides memory from an operating system.
 
 OS memory provider supports two types of memory mappings (set by the `visibility` parameter):
+
 1) private memory mapping (`UMF_MEM_MAP_PRIVATE`)
 2) shared memory mapping (`UMF_MEM_MAP_SHARED` - supported on Linux only yet)
 
+IPC API requires the `UMF_MEM_MAP_SHARED` memory `visibility` mode
+(`UMF_RESULT_ERROR_INVALID_ARGUMENT` is returned otherwise).
+
+IPC API uses file descriptor duplication, which requires the `pidfd_getfd(2)` system call to obtain
+a duplicate of another process's file descriptor. This system call is supported since Linux 5.6.
+Required permission ("restricted ptrace") is governed by the `PTRACE_MODE_ATTACH_REALCREDS` check
+(see `ptrace(2)`). To allow file descriptor duplication in a binary that opens IPC handle, you can call
+`prctl(PR_SET_PTRACER, ...)` in the producer binary that gets the IPC handle.
+Alternatively you can change the `ptrace_scope` globally in the system, e.g.:
+
+```sh
+sudo bash -c "echo 0 > /proc/sys/kernel/yama/ptrace_scope"
+```
+
 There are available two mechanisms for the shared memory mapping:
+
 1) a named shared memory object (used if the `shm_name` parameter is not NULL) or
 2) an anonymous file descriptor (used if the `shm_name` parameter is NULL)
 
 The `shm_name` parameter should be a null-terminated string of up to NAME_MAX (i.e., 255) characters none of which are slashes.
 
 An anonymous file descriptor for the shared memory mapping will be created using:
+
 1) `memfd_secret()` syscall - (if it is implemented and) if the `UMF_MEM_FD_FUNC` environment variable does not contain the "memfd_create" string or
 2) `memfd_create()` syscall - otherwise (and if it is implemented).
 
 ##### Requirements
 
-Required packages for tests (Linux-only yet):
-   - libnuma-dev
+IPC API on Linux requires the `PTRACE_MODE_ATTACH_REALCREDS` permission (see `ptrace(2)`)
+to duplicate another process's file descriptor (see above).
+
+Packages required for tests (Linux-only yet):
+
+- libnuma-dev
 
 #### Level Zero memory provider
 
 A memory provider that provides memory from L0 device.
 
+IPC API uses file descriptor duplication, which requires the `pidfd_getfd(2)` system call to obtain
+a duplicate of another process's file descriptor. This system call is supported since Linux 5.6.
+Required permission ("restricted ptrace") is governed by the `PTRACE_MODE_ATTACH_REALCREDS` check
+(see `ptrace(2)`). To allow file descriptor duplication in a binary that opens IPC handle, you can call
+`prctl(PR_SET_PTRACER, ...)` in the producer binary that gets the IPC handle.
+Alternatively you can change the `ptrace_scope` globally in the system, e.g.:
+
+```sh
+sudo bash -c "echo 0 > /proc/sys/kernel/yama/ptrace_scope"
+```
 ##### Requirements
 
 1) Linux or Windows OS
 2) The `UMF_BUILD_LEVEL_ZERO_PROVIDER` option turned `ON` (by default)
+3) IPC API on Linux requires the `PTRACE_MODE_ATTACH_REALCREDS` permission (see `ptrace(2)`)
+   to duplicate another process's file descriptor (see above).
+
+Additionally, required for tests:
+
+4) The `UMF_BUILD_GPU_TESTS` option turned `ON`
+5) System with Level Zero compatible GPU
+6) Required packages:
+   - liblevel-zero-dev (Linux) or level-zero-sdk (Windows)
+
+#### DevDax memory provider (Linux only)
+
+A memory provider that provides memory from a device DAX (a character device file like `/dev/daxX.Y`).
+It can be used when large memory mappings are needed.
+
+##### Requirements
+
+1) Linux OS
+2) A character device file /dev/daxX.Y created in the OS.
+
+#### File memory provider (Linux only yet)
+
+A memory provider that provides memory by mapping a regular, extendable file.
+
+IPC API requires the `UMF_MEM_MAP_SHARED` memory `visibility` mode
+(`UMF_RESULT_ERROR_INVALID_ARGUMENT` is returned otherwise).
+
+The memory visibility mode parameter must be set to `UMF_MEM_MAP_SHARED` in case of FSDAX.
+
+##### Requirements
+
+1) Linux OS
+2) A length of a path of a file to be mapped can be `PATH_MAX` (4096) characters at most.
+
+#### CUDA memory provider
+
+A memory provider that provides memory from CUDA device.
+
+##### Requirements
+
+1) Linux or Windows OS
+2) The `UMF_BUILD_CUDA_PROVIDER` option turned `ON` (by default)
 
 Additionally, required for tests:
 
 3) The `UMF_BUILD_GPU_TESTS` option turned `ON`
-4) System with Level Zero compatible GPU
+4) System with CUDA compatible GPU
 5) Required packages:
-   - liblevel-zero-dev (Linux) or level-zero-sdk (Windows)
+   - nvidia-cuda-dev (Linux) or cuda-sdk (Windows)
 
 ### Memory pool managers
 
@@ -180,26 +278,41 @@ This memory pool is distributed as part of libumf. It forwards all requests to t
 memory provider. Currently umfPoolRealloc, umfPoolCalloc and umfPoolMallocUsableSize functions
 are not supported by the proxy pool.
 
-#### Disjoint pool
+#### Disjoint pool (part of libumf)
 
-TODO: Add a description
-
-##### Requirements
-
-To enable this feature, the `UMF_BUILD_LIBUMF_POOL_DISJOINT` option needs to be turned `ON`.
+The Disjoint pool is designed to keep internal metadata separate from user data.
+This separation is particularly useful when user data needs to be placed in memory with relatively high latency,
+such as GPU memory or disk storage.
 
 #### Jemalloc pool
 
-Jemalloc pool is a [jemalloc](https://github.com/jemalloc/jemalloc)-based memory 
+Jemalloc pool is a [jemalloc](https://github.com/jemalloc/jemalloc)-based memory
 pool manager built as a separate static library: libjemalloc_pool.a on Linux and
 jemalloc_pool.lib on Windows.
 The `UMF_BUILD_LIBUMF_POOL_JEMALLOC` option has to be turned `ON` to build this library.
 
+[jemalloc](https://github.com/jemalloc/jemalloc) is required to build the jemalloc pool.
+
+In case of Linux OS jemalloc is built from the (fetched) sources with the following
+non-default options enabled:
+
+- `--with-jemalloc-prefix=je_` - adds the `je_` prefix to all public APIs,
+- `--disable-cxx` - disables C++ integration, it will cause the `new` and the `delete`
+                    operators implementations to be omitted.
+- `--disable-initial-exec-tls` - disables the initial-exec TLS model for jemalloc's
+                    internal thread-local storage (on those platforms that support
+                    explicit settings), it can allow jemalloc to be dynamically
+                    loaded after program startup (e.g. using `dlopen()`).
+
+The default jemalloc package is required on Windows.
+
 ##### Requirements
 
 1) The `UMF_BUILD_LIBUMF_POOL_JEMALLOC` option turned `ON`
-2) Required packages:
-   - libjemalloc-dev (Linux) or jemalloc (Windows)
+2) jemalloc is required:
+
+- on Linux and MacOS: jemalloc is fetched and built from sources (a custom build),
+- on Windows: the default jemalloc package is required
 
 #### Scalable Pool (part of libumf)
 
@@ -208,8 +321,9 @@ It is distributed as part of libumf. To use this pool, TBB must be installed in
 
 ##### Requirements
 
-Required packages:
-   - libtbb-dev (libtbbmalloc.so.2) on Linux or tbb (tbbmalloc.dll) on Windows
+Packages required for using this pool and executing tests/benchmarks (not required for build):
+
+- libtbb-dev (libtbbmalloc.so.2) on Linux or tbb (tbbmalloc.dll) on Windows
 
 ### Memspaces (Linux-only)
 
@@ -240,23 +354,34 @@ Querying the latency value requires HMAT support on the platform. Calling `umfMe
 UMF provides the UMF proxy library (`umf_proxy`) that makes it possible
 to override the default allocator in other programs in both Linux and Windows.
 
+To enable this feature, the `UMF_BUILD_SHARED_LIBRARY` option needs to be turned `ON`.
+
 #### Linux
 
 In case of Linux it can be done without any code changes using the `LD_PRELOAD` environment variable:
 
 ```sh
-$ LD_PRELOAD=/usr/lib/libumf_proxy.so myprogram
+LD_PRELOAD=/usr/lib/libumf_proxy.so myprogram
 ```
 
 The memory used by the proxy memory allocator is mmap'ed:
+
 1) with the `MAP_PRIVATE` flag by default or
 2) with the `MAP_SHARED` flag if the `UMF_PROXY` environment variable contains one of two following strings: `page.disposition=shared-shm` or `page.disposition=shared-fd`. These two options differ in a mechanism used during IPC:
    - `page.disposition=shared-shm` - IPC uses the named shared memory. An SHM name is generated using the `umf_proxy_lib_shm_pid_$PID` pattern, where `$PID` is the PID of the process. It creates the `/dev/shm/umf_proxy_lib_shm_pid_$PID` file.
-   - `page.disposition=shared-fd` - IPC uses the file descriptor duplication. It requires using `pidfd_getfd(2)` to obtain a duplicate of another process's file descriptor. Permission to duplicate another process's file descriptor is governed by a ptrace access mode `PTRACE_MODE_ATTACH_REALCREDS` check (see `ptrace(2)`) that can be changed using the `/proc/sys/kernel/yama/ptrace_scope` interface. `pidfd_getfd(2)` is supported since Linux 5.6.
+   - `page.disposition=shared-fd` -  IPC API uses file descriptor duplication, which requires the `pidfd_getfd(2)` system call to obtain a duplicate of another process's file descriptor. This system call is supported since Linux 5.6. Required permission ("restricted ptrace") is governed by the `PTRACE_MODE_ATTACH_REALCREDS` check (see `ptrace(2)`). To allow file descriptor duplication in a binary that opens IPC handle, you can call `prctl(PR_SET_PTRACER, ...)` in the producer binary that gets the IPC handle. Alternatively you can change the `ptrace_scope` globally in the system, e.g.: `sudo bash -c "echo 0 > /proc/sys/kernel/yama/ptrace_scope"`.
+
+**Size threshold**
+
+The **size threshold** feature (Linux only) causes that all allocations of size less than the given threshold value go to the default system allocator instead of the proxy library.
+It can be enabled by adding the `size.threshold=<value>` string to the `UMF_PROXY` environment variable (with `';'` as a separator), for example: `UMF_PROXY="page.disposition=shared-shm;size.threshold=64"`.
+
+**Remark:** changing a size of allocation (using `realloc()` ) does not change the allocator (`realloc(malloc(threshold - 1), threshold + 1)` still belongs to the default system allocator and `realloc(malloc(threshold + 1), threshold - 1)` still belongs to the proxy library pool allocator).
 
 #### Windows
 
 In case of Windows it requires:
+
 1) explicitly linking your program dynamically with the `umf_proxy.dll` library
 2) (C++ code only) including `proxy_lib_new_delete.h` in a single(!) source file in your project
    to override also the `new`/`delete` operations.
@@ -270,3 +395,7 @@ an issue or a Pull Request, please read [Contribution Guide](./CONTRIBUTING.md).
 
 To enable logging in UMF source files please follow the guide in the
 [web documentation](https://oneapi-src.github.io/unified-memory-framework/introduction.html#logging).
+
+## Notices
+
+The contents of this repository may have been developed with support from one or more Intel-operated generative artificial intelligence solutions.
diff --git a/RELEASE_STEPS.md b/RELEASE_STEPS.md
index e88ca9c2d..9189d4804 100644
--- a/RELEASE_STEPS.md
+++ b/RELEASE_STEPS.md
@@ -38,12 +38,10 @@ Do changes for a release:
     - If previously we decided not to create such branch, create it now, based on the appropriate minor or major tag
   - For major/minor release start from the `main` branch
 - Add an entry to ChangeLog, remember to change the day of the week in the release date
-  - For major releases mention API and ABI compatibility with the previous release
-- Update project's version in a few places:
-  - For major and minor releases: `UMF_VERSION_CURRENT` in `include/umf/base.h` (the API version)
-  - `release` variable in `scripts/docs_config/conf.py` (for docs)
-  - `UMF_VERSION` variable in `.github/workflows/basic.yml` (for installation test)
-- For major releases update ABI version in `.map` and `.def` files
+  - For major and minor (prior 1.0.0) releases mention API and ABI compatibility with the previous release
+- For major and minor releases, update `UMF_VERSION_CURRENT` in `include/umf/base.h` (the API version)
+  - For changes in ops structures, update corresponding UMF_*_OPS_VERSION_CURRENT
+- For major and minor (prior 1.0.0) releases update ABI version in `.map` and `.def` files
   - These files are defined for all public libraries (`libumf` and `proxy_lib`, at the moment)
 - Commit these changes and tag the release:
   - `git commit -a -S -m "$VERSION release"`
@@ -52,6 +50,11 @@ Do changes for a release:
   - If stable branch for this release is required, create it:
     - `git checkout -b v$VER.x`
     - For some early versions (like `0.1.0`) we may omit creation of the branch
+- For major/minor release, when release is done, add an extra "dev" tag on the `main` branch:
+  - `git tag -a -s -m "Development version $VERSION+1" v$VERSION+1-dev`
+    - for example, when `v0.1.0` is released, the dev tag would be `v0.2.0-dev`
+    - if needed, further in time, an extra dev tag can be introduced, e.g. `v0.2.0-dev1`
+  - This way, the `main` branch will introduce itself as the next version
 
 ## Publish changes
 
diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
index 455b9bc06..9b46ed6ea 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -1,7 +1,24 @@
-# Copyright (C) 2023 Intel Corporation
+# Copyright (C) 2023-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+include(FetchContent)
+FetchContent_Declare(
+    googlebenchmark
+    GIT_REPOSITORY https://github.com/google/benchmark.git
+    GIT_TAG v1.9.0)
+
+set(BENCHMARK_ENABLE_GTEST_TESTS
+    OFF
+    CACHE BOOL "" FORCE)
+set(BENCHMARK_ENABLE_TESTING
+    OFF
+    CACHE BOOL "" FORCE)
+set(BENCHMARK_ENABLE_INSTALL
+    OFF
+    CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(googlebenchmark)
+
 # In MSVC builds, there is no way to determine the actual build type during the
 # CMake configuration step. Therefore, this message is printed in all MSVC
 # builds.
@@ -23,8 +40,9 @@ function(add_umf_benchmark)
     # * SRCS - source files
     # * LIBS - libraries to be linked with
     # * LIBDIRS - directories of libraries to be linked with
+    # * TESTARGS - additional arguments to be passed to the add_test
     set(oneValueArgs NAME)
-    set(multiValueArgs SRCS LIBS LIBDIRS)
+    set(multiValueArgs SRCS LIBS LIBDIRS TESTARGS)
     cmake_parse_arguments(
         ARG
         ""
@@ -32,9 +50,9 @@ function(add_umf_benchmark)
         "${multiValueArgs}"
         ${ARGN})
 
-    set(BENCH_NAME umf-bench-${ARG_NAME})
+    set(BENCH_NAME umf-${ARG_NAME})
 
-    set(BENCH_LIBS ${ARG_LIBS} umf)
+    set(BENCH_LIBS ${ARG_LIBS} umf umf_utils)
 
     add_umf_executable(
         NAME ${BENCH_NAME}
@@ -45,23 +63,26 @@ function(add_umf_benchmark)
         ${BENCH_NAME}
         PRIVATE ${UMF_CMAKE_SOURCE_DIR}/include
                 ${UMF_CMAKE_SOURCE_DIR}/src/utils
-                ${UMF_CMAKE_SOURCE_DIR}/test/common
-                ${UMF_CMAKE_SOURCE_DIR}/examples/common)
+                ${UMF_CMAKE_SOURCE_DIR}/test/common)
 
     target_link_directories(${BENCH_NAME} PRIVATE ${ARG_LIBDIRS})
 
     add_test(
         NAME ${BENCH_NAME}
-        COMMAND ${BENCH_NAME}
+        COMMAND ${BENCH_NAME} ${ARG_TESTARGS}
         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
-    # Benchmark passes if it prints "PASSED" in the output, because ubench of
-    # scalable pool fails if the confidence interval exceeds maximum permitted
-    # 2.5%.
-    set_tests_properties(
-        ${BENCH_NAME} PROPERTIES
-        LABELS "benchmark"
-        PASS_REGULAR_EXPRESSION "PASSED")
+    if("${BENCH_NAME}" STREQUAL "umf-ubench")
+        # Benchmark passes if it prints "PASSED" in the output, because ubench
+        # of scalable pool fails if the confidence interval exceeds maximum
+        # permitted 2.5%.
+        set_tests_properties(
+            ${BENCH_NAME} PROPERTIES
+            LABELS "benchmark"
+            PASS_REGULAR_EXPRESSION "PASSED")
+    else()
+        set_tests_properties(${BENCH_NAME} PROPERTIES LABELS "benchmark")
+    endif()
 
     if(WINDOWS)
         # append PATH to DLLs
@@ -69,21 +90,24 @@ function(add_umf_benchmark)
                                                  "${DLL_PATH_LIST}")
     endif()
 
-    if(UMF_BUILD_LIBUMF_POOL_DISJOINT)
+    if(UMF_POOL_JEMALLOC_ENABLED)
         target_compile_definitions(${BENCH_NAME}
-                                   PRIVATE UMF_BUILD_LIBUMF_POOL_DISJOINT=1)
-    endif()
-    if(UMF_BUILD_LIBUMF_POOL_JEMALLOC)
-        target_compile_definitions(${BENCH_NAME}
-                                   PRIVATE UMF_BUILD_LIBUMF_POOL_JEMALLOC=1)
+                                   PRIVATE UMF_POOL_JEMALLOC_ENABLED=1)
     endif()
     if(UMF_POOL_SCALABLE_ENABLED)
         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 ${LEVEL_ZERO_INCLUDE_DIRS})
+    endif()
+    if(UMF_CUDA_ENABLED)
         target_compile_definitions(${BENCH_NAME}
-                                   PRIVATE UMF_BUILD_LEVEL_ZERO_PROVIDER=1)
+                                   PRIVATE UMF_BUILD_CUDA_PROVIDER=1)
+        target_include_directories(${BENCH_NAME} PRIVATE ${CUDA_INCLUDE_DIRS})
     endif()
     if(UMF_BUILD_GPU_TESTS)
         target_compile_definitions(${BENCH_NAME} PRIVATE UMF_BUILD_GPU_TESTS=1)
@@ -93,28 +117,32 @@ endfunction()
 set(LIB_DIRS ${LIBHWLOC_LIBRARY_DIRS})
 
 # optional libraries
-if(UMF_BUILD_LIBUMF_POOL_DISJOINT)
-    set(LIBS_OPTIONAL ${LIBS_OPTIONAL} disjoint_pool)
-endif()
-if(UMF_BUILD_LIBUMF_POOL_JEMALLOC)
-    set(LIBS_OPTIONAL ${LIBS_OPTIONAL} jemalloc_pool ${JEMALLOC_LIBRARIES})
-    set(LIB_DIRS ${LIB_DIRS} ${JEMALLOC_LIBRARY_DIRS})
-endif()
 if(LINUX)
     set(LIBS_OPTIONAL ${LIBS_OPTIONAL} m)
 endif()
-if(UMF_BUILD_GPU_TESTS)
+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()
 
 # BENCHMARKS
 
 add_umf_benchmark(
     NAME ubench
-    SRCS ubench.c
+    SRCS ubench.c ${SRCS_OPTIONAL}
     LIBS ${LIBS_OPTIONAL}
     LIBDIRS ${LIB_DIRS})
 
+add_umf_benchmark(
+    NAME benchmark
+    SRCS benchmark.cpp
+    LIBS ${LIBS_OPTIONAL} benchmark::benchmark
+    # limit running benchmarks in CI tests to single-threaded
+    LIBDIRS ${LIB_DIRS}
+    TESTARGS --benchmark_filter=threads:1$)
+
 if(UMF_BUILD_BENCHMARKS_MT)
     add_umf_benchmark(
         NAME multithreaded
diff --git a/benchmark/benchmark.cpp b/benchmark/benchmark.cpp
new file mode 100644
index 000000000..d4375fe9d
--- /dev/null
+++ b/benchmark/benchmark.cpp
@@ -0,0 +1,266 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+#include "benchmark.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) {                                               \
+        for (auto _ : state) {                                                 \
+            bench(state);                                                      \
+        }                                                                      \
+    }
+
+#define UMF_BENCHMARK_REGISTER_F(BaseClass, Method)                            \
+    BENCHMARK_REGISTER_F(BaseClass, Method)                                    \
+        ->Apply(                                                               \
+            &BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method)::defaultArgs)
+
+// Benchmarks scenarios:
+
+// The benchmark arguments specified in Args() are, in order:
+// benchmark arguments, allocator arguments, size generator arguments.
+// The exact meaning of each argument depends on the benchmark, allocator, and size components used.
+// Refer to the 'argsName()' function in each component to find detailed descriptions of these arguments.
+
+static void multithreaded(benchmark::internal::Benchmark *benchmark) {
+    benchmark->Threads(1);
+    benchmark->Threads(4);
+}
+
+static void singlethreaded(benchmark::internal::Benchmark *benchmark) {
+    benchmark->Threads(1);
+}
+
+static void
+default_multiple_alloc_fix_size(benchmark::internal::Benchmark *benchmark) {
+    benchmark->Args({10000, 1, 4096});
+    benchmark->Iterations(500000);
+}
+
+static void
+default_multiple_alloc_uniform_size(benchmark::internal::Benchmark *benchmark) {
+    benchmark->Args({10000, 1, 8, 4096, 8});
+    benchmark->Args({10000, 1, 8, 128, 8});
+    benchmark->Iterations(500000);
+}
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark, glibc_fix,
+                              fixed_alloc_size, glibc_malloc);
+
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, glibc_fix)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark, glibc_uniform,
+                              uniform_alloc_size, glibc_malloc);
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, glibc_uniform)
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark, proxy_pool,
+                              fixed_alloc_size,
+                              pool_allocator<proxy_pool<os_provider>>);
+
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, proxy_pool)
+    ->Apply(&default_multiple_alloc_fix_size)
+    // reduce iterations, as this benchmark is slower than others
+    ->Iterations(50000)
+    ->Apply(&singlethreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark, os_provider,
+                              fixed_alloc_size,
+                              provider_allocator<os_provider>);
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, os_provider)
+    ->Apply(&default_multiple_alloc_fix_size)
+    // reduce iterations, as this benchmark is slower than others
+    ->Iterations(50000)
+    ->Apply(&singlethreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark, disjoint_pool_fix,
+                              fixed_alloc_size,
+                              pool_allocator<disjoint_pool<os_provider>>);
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, disjoint_pool_fix)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark,
+                              disjoint_pool_uniform, uniform_alloc_size,
+                              pool_allocator<disjoint_pool<os_provider>>);
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, disjoint_pool_uniform)
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
+
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark, jemalloc_pool_fix,
+                              fixed_alloc_size,
+                              pool_allocator<jemalloc_pool<os_provider>>);
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, jemalloc_pool_fix)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark,
+                              jemalloc_pool_uniform, uniform_alloc_size,
+                              pool_allocator<jemalloc_pool<os_provider>>);
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, jemalloc_pool_uniform)
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
+
+#endif
+
+#ifdef UMF_POOL_SCALABLE_ENABLED
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark, scalable_pool_fix,
+                              fixed_alloc_size,
+                              pool_allocator<scalable_pool<os_provider>>);
+
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, scalable_pool_fix)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark,
+                              scalable_pool_uniform, uniform_alloc_size,
+                              pool_allocator<scalable_pool<os_provider>>);
+
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, scalable_pool_uniform)
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
+
+#endif
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark,
+                              proxy_pool_fixedprovider, fixed_alloc_size,
+                              pool_allocator<proxy_pool<fixed_provider>>);
+
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark,
+                         proxy_pool_fixedprovider)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&singlethreaded)
+    // reduce iterations, to match os_provider benchmark
+    ->Iterations(50000);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark, fixed_provider,
+                              fixed_alloc_size,
+                              provider_allocator<fixed_provider>);
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark, fixed_provider)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&singlethreaded)
+    // reduce iterations, to match os_provider benchmark
+    ->Iterations(50000);
+
+// peak
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, glibc_fix, fixed_alloc_size,
+                              glibc_malloc);
+
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, glibc_fix)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, glibc_uniform,
+                              uniform_alloc_size, glibc_malloc);
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, glibc_uniform)
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, disjoint_pool_fix,
+                              fixed_alloc_size,
+                              pool_allocator<disjoint_pool<os_provider>>);
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, disjoint_pool_fix)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, disjoint_pool_uniform,
+                              uniform_alloc_size,
+                              pool_allocator<disjoint_pool<os_provider>>);
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, disjoint_pool_uniform)
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
+
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, jemalloc_pool_fix,
+                              fixed_alloc_size,
+                              pool_allocator<jemalloc_pool<os_provider>>);
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, jemalloc_pool_fix)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, jemalloc_pool_uniform,
+                              uniform_alloc_size,
+                              pool_allocator<jemalloc_pool<os_provider>>);
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, jemalloc_pool_uniform)
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
+
+#endif
+
+#ifdef UMF_POOL_SCALABLE_ENABLED
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, scalable_pool_fix,
+                              fixed_alloc_size,
+                              pool_allocator<scalable_pool<os_provider>>);
+
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, scalable_pool_fix)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, scalable_pool_uniform,
+                              uniform_alloc_size,
+                              pool_allocator<scalable_pool<os_provider>>);
+
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, scalable_pool_uniform)
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
+
+#endif
+
+// stacked pool benchmarks
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark,
+                              disjoint_pool_stack_fix, fixed_alloc_size,
+                              pool_stacked_allocator<os_provider>);
+
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark,
+                         disjoint_pool_stack_fix)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(multiple_malloc_free_benchmark,
+                              disjoint_pool_stack_uniform, uniform_alloc_size,
+                              pool_stacked_allocator<os_provider>);
+UMF_BENCHMARK_REGISTER_F(multiple_malloc_free_benchmark,
+                         disjoint_pool_stack_uniform)
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, disjoint_pool_stack_fix,
+                              fixed_alloc_size,
+                              pool_stacked_allocator<os_provider>);
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, disjoint_pool_stack_fix)
+    ->Apply(&default_multiple_alloc_fix_size)
+    ->Apply(&multithreaded);
+
+UMF_BENCHMARK_TEMPLATE_DEFINE(peak_alloc_benchmark, disjoint_pool_stack_uniform,
+                              uniform_alloc_size,
+                              pool_stacked_allocator<os_provider>);
+UMF_BENCHMARK_REGISTER_F(peak_alloc_benchmark, disjoint_pool_stack_uniform)
+    ->Apply(&default_multiple_alloc_uniform_size)
+    ->Apply(&multithreaded);
+
+//BENCHMARK_MAIN();
+int main(int argc, char **argv) {
+    if (initAffinityMask()) {
+        std::cerr << "initAffinityMask failed" << std::endl;
+        return -1;
+    }
+
+    benchmark::Initialize(&argc, argv);
+    benchmark::RunSpecifiedBenchmarks();
+    benchmark::Shutdown();
+}
diff --git a/benchmark/benchmark.hpp b/benchmark/benchmark.hpp
new file mode 100644
index 000000000..201c9e382
--- /dev/null
+++ b/benchmark/benchmark.hpp
@@ -0,0 +1,663 @@
+/*
+ * 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
+ *
+ */
+
+/*
+ * This file defines a benchmarking framework for evaluating memory allocation
+ * and deallocation performance using the Unified Memory Framework (UMF). The
+ * design is modular and extensible, allowing for flexible benchmarking of different
+ * allocation strategies, size distributions, and memory providers.
+ *
+ * **Key Design Features:**
+ * - **Modular Components**: The framework is built using interfaces and templates,
+ *   which allows for easy extension and customization of allocation strategies,
+ *   size distributions, and memory providers.
+ * - **Flexible Allocation Size Generators**: Includes classes like `fixed_alloc_size`
+ *   and `uniform_alloc_size` that generate allocation sizes based on different
+ *   strategies. These classes implement the `alloc_size_interface`.
+ * - **Abstract Allocator Interface**: The `allocator_interface` defines the basic
+ *   methods for memory allocation and deallocation. Concrete allocators like
+ *   `provider_allocator` and `pool_allocator` implement this interface to work
+ *   with different memory providers and pools.
+ * - **Benchmarking Classes**: Classes like `alloc_benchmark` and `multiple_malloc_free_benchmark`
+ *   templates the allocation size generator and allocator to perform benchmarks.
+ *   It manages the setup, execution, and teardown of the benchmark.
+ * - **Threaded Execution Support**: The benchmarks support multi-threaded execution
+ *   by maintaining thread-specific allocation data and synchronization.
+ *
+ * **Component Interactions:**
+ * - **Size Generators and Allocators**: The `alloc_benchmark` class uses a size
+ *   generator (e.g., `fixed_alloc_size` or `uniform_alloc_size`) to determine the
+ *   sizes of memory allocations, and an allocator (e.g., `provider_allocator` or
+ *   `pool_allocator`) to perform the actual memory operations.
+ * - **Benchmark Execution**: During the benchmark, `alloc_benchmark` repeatedly
+ *   calls the `bench` method, which performs allocations and deallocations using
+ *   the allocator and size generator.
+ * - **Allocator Adapters**: The `provider_allocator` and `pool_allocator` adapt
+ *   specific memory providers and pools to the `allocator_interface`, allowing
+ *   them to be used interchangeably in the benchmark classes. This abstraction
+ *   enables benchmarking different memory management strategies without changing
+ *   the core benchmarking logic.
+ * - **Pre-allocations and Iterations**: The `alloc_benchmark` can perform a set
+ *   number of pre-allocations before the benchmark starts, and manages allocation
+ *   and deallocation cycles to simulate memory pressure and fragmentation.
+ * - **Derived Benchmarks**: `multiple_malloc_free_benchmark` extends
+ *   `alloc_benchmark` to perform multiple random deallocations and reallocations
+ *   in each iteration, using a uniform distribution to select which allocations
+ *   to free and reallocate. This models workloads with frequent memory churn.
+ *
+ * **Execution Flow:**
+ * 1. **Setup Phase**:
+ *    - The benchmark class initializes the size generator and allocator.
+ *    - Pre-allocations are performed if specified.
+ *    - Thread-specific data structures for allocations are prepared.
+ * 2. **Benchmark Loop**:
+ *    - For each iteration, the `bench` method is called.
+ *    - The size generator provides the next allocation size.
+ *    - The allocator performs the allocation.
+ *    - Allocations are tracked per thread.
+ * 3. **Teardown Phase**:
+ *    - All remaining allocations are freed.
+ *    - Allocator and size generator are cleaned up.
+ *
+ * **Customization and Extension:**
+ * - New size generators can be created by implementing the `alloc_size_interface`.
+ * - New allocators can be adapted by implementing the `allocator_interface`.
+ * - 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>
+#include <umf/memory_provider.h>
+
+#include "benchmark_size.hpp"
+#include "benchmark_umf.hpp"
+
+struct alloc_data {
+    void *ptr;
+    size_t size;
+};
+
+struct next_alloc_data {
+    bool alloc; // true if allocation, false if deallocation
+    size_t offset;
+    size_t size;
+};
+
+#ifndef WIN32
+std::vector<cpu_set_t> affinityMask;
+
+int initAffinityMask() {
+    cpu_set_t mask;
+    CPU_ZERO(&mask);
+
+    if (sched_getaffinity(0, sizeof(mask), &mask) == -1) {
+        perror("sched_getaffinity");
+        return 1;
+    }
+
+    for (int cpu = 0; cpu < CPU_SETSIZE; cpu++) {
+        if (CPU_ISSET(cpu, &mask)) {
+            cpu_set_t mask;
+            CPU_ZERO(&mask);
+            CPU_SET(cpu, &mask);
+            affinityMask.push_back(mask);
+        }
+    }
+    // we reverse affinityMask to avoid using cpu 0 if possible.
+    // CPU 0 is usually the most used one by other applications on the system.
+    std::reverse(affinityMask.begin(), affinityMask.end());
+    return 0;
+}
+
+void setAffinity(benchmark::State &state) {
+    size_t tid = state.thread_index();
+    if (tid >= affinityMask.size()) {
+        state.SkipWithError("Not enough CPUs available to set affinity");
+    }
+
+    auto &mask = affinityMask[tid];
+
+    if (sched_setaffinity(0, sizeof(mask), &mask) != 0) {
+        state.SkipWithError("Failed to set affinity");
+    }
+}
+
+#else
+int initAffinityMask() {
+    printf(
+        "Affinity set not supported on Windows, benchmark can be unstable\n");
+    return 0;
+}
+
+void setAffinity([[maybe_unused]] benchmark::State &state) {
+    // Not implemented for Windows
+}
+
+#endif
+
+// function that ensures that all threads have reached the same point
+inline void waitForAllThreads(const benchmark::State &state) {
+    static std::atomic<int> count{0};
+    static std::atomic<int> generation{0};
+
+    const int totalThreads = state.threads();
+    int gen = generation.load(std::memory_order_relaxed);
+
+    int c = count.fetch_add(1, std::memory_order_acq_rel) + 1;
+
+    if (c == totalThreads) {
+        // Last thread - reset count and bump generation
+        count.store(0, std::memory_order_relaxed);
+        generation.fetch_add(1, std::memory_order_acq_rel);
+    } else {
+        // Not the last thread: spin until the generation changes
+        while (generation.load(std::memory_order_acquire) == gen) {
+            std::this_thread::yield();
+        }
+    }
+}
+
+template <typename Provider, typename = std::enable_if_t<std::is_base_of<
+                                 provider_interface, Provider>::value>>
+class provider_allocator : public allocator_interface {
+  public:
+    unsigned SetUp(::benchmark::State &state, unsigned argPos) override {
+        provider.SetUp(state);
+        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);
+    }
+
+    void *benchAlloc(size_t size) override {
+        void *ptr;
+        if (umfMemoryProviderAlloc(provider.provider, size, 0, &ptr) !=
+            UMF_RESULT_SUCCESS) {
+            return NULL;
+        }
+        return ptr;
+    }
+
+    void benchFree(void *ptr, size_t size) override {
+        umfMemoryProviderFree(provider.provider, ptr, size);
+    }
+
+    static std::string name() { return Provider::name(); }
+
+  private:
+    Provider provider;
+};
+
+// TODO: assert Pool to be a pool_interface<provider_interface>.
+template <typename Pool> class pool_allocator : public allocator_interface {
+  public:
+    virtual unsigned SetUp(::benchmark::State &state,
+                           unsigned argPos) override {
+        pool.SetUp(state);
+        return argPos;
+    }
+
+    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);
+    }
+
+    virtual void benchFree(void *ptr, [[maybe_unused]] size_t size) override {
+        umfPoolFree(pool.pool, ptr);
+    }
+
+    static std::string name() { return Pool::name(); }
+
+  protected:
+    Pool pool;
+};
+
+template <typename Provider>
+class pool_stacked_allocator
+    : public pool_allocator<disjoint_pool_stack<Provider>> {
+    using base = pool_allocator<disjoint_pool_stack<Provider>>;
+
+  public:
+    virtual void preBench([[maybe_unused]] ::benchmark::State &state) override {
+        // we do not measure fragmentation for stack pools
+    }
+    virtual void
+    postBench([[maybe_unused]] ::benchmark::State &state) override {
+        // we do not measure fragmentation for stack pools
+    }
+    void *benchAlloc(size_t size) override {
+        static thread_local int counter = 0;
+        static auto pool_number = base::pool.pools.size();
+        // stacked pools has limited space, so we might need a few
+        // tries to find one with free space
+        auto retry = pool_number;
+        while (retry--) {
+            void *ptr = umfPoolMalloc(
+                base::pool.pools[(++counter % pool_number)], size);
+            if (ptr != NULL) {
+                return ptr;
+            }
+        }
+        return NULL;
+    }
+
+    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) {
+        Size generator;
+        argPos = generator.SetUp(state, argPos);
+        argPos = allocator.SetUp(state, argPos);
+        alloc_sizes.resize(state.threads());
+        for (auto &i : alloc_sizes) {
+            i = generator;
+        }
+        return argPos;
+    }
+    void SetUp(::benchmark::State &state) { parseArgs(state, 0); }
+
+    void TearDown(::benchmark::State &state) {
+        for (auto &i : alloc_sizes) {
+            i.TearDown(state);
+        }
+        allocator.TearDown(state);
+    }
+
+    void bench([[maybe_unused]] ::benchmark::State &state){};
+
+    virtual std::vector<std::string> argsName() {
+        auto s = Size::argsName();
+        auto a = Allocator::argsName();
+        std::vector<std::string> res = {};
+        res.insert(res.end(), s.begin(), s.end());
+        res.insert(res.end(), a.begin(), a.end());
+        return res;
+    }
+
+    virtual std::string name() { return Allocator::name(); }
+
+    static void defaultArgs(Benchmark *benchmark) {
+        auto *bench =
+            static_cast<benchmark_interface<Size, Allocator> *>(benchmark);
+        benchmark->ArgNames(bench->argsName())->Name(bench->name());
+    }
+
+    void custom_counters(::benchmark::State &state) {
+        allocator.custom_counters(state);
+    }
+    std::vector<Size> alloc_sizes;
+    Allocator allocator;
+};
+
+// This class benchmarks performance of random deallocations and (re)allocations
+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 multiple_malloc_free_benchmark : public benchmark_interface<Size, Alloc> {
+  protected:
+    template <class T> using vector2d = std::vector<std::vector<T>>;
+    using base = benchmark_interface<Size, Alloc>;
+    int allocsPerIterations = 10;
+    bool thread_local_allocations = true;
+    size_t max_allocs = 0;
+
+    vector2d<alloc_data> allocations;
+    vector2d<next_alloc_data> next;
+    using next_alloc_data_iterator =
+        typename std::vector<next_alloc_data>::const_iterator;
+    std::vector<std::unique_ptr<next_alloc_data_iterator>> next_iter;
+    int64_t iterations;
+    bool log_fragmentation;
+    multiple_malloc_free_benchmark(bool log_fragmentation = true)
+        : log_fragmentation(log_fragmentation) {}
+
+  public:
+    void SetUp(::benchmark::State &state) override {
+        auto tid = state.thread_index();
+
+        if (tid == 0) {
+            // unpack arguments
+            iterations = state.max_iterations;
+            int argPos = 0;
+            max_allocs = state.range(argPos++);
+            thread_local_allocations = state.range(argPos++);
+            base::parseArgs(state, argPos);
+
+            allocations.resize(state.threads());
+            next.resize(state.threads());
+            next_iter.resize(state.threads());
+
+#ifndef WIN32
+            // Ensure that system malloc does not have memory pooled on the heap
+            malloc_trim(0);
+#endif
+        }
+        setAffinity(state);
+        // sync thread to ensure that thread 0 parsed args and did all initialization
+        waitForAllThreads(state);
+        // Prepare workload for warp up
+        prealloc(state);
+        prepareWorkload(state);
+        // Start warm up with all threads at once
+        waitForAllThreads(state);
+        // warm up
+        for (int j = 0; j < iterations; j++) {
+            bench(state);
+        }
+        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) {
+            // release memory used by benchmark
+            next.clear();
+            next_iter.clear();
+            allocations.clear();
+        }
+        base::TearDown(state);
+    }
+
+    void bench(benchmark::State &state) {
+        auto tid = state.thread_index();
+        auto &allocation = allocations[tid];
+        auto &iter = next_iter[tid];
+
+        for (int i = 0; i < allocsPerIterations; i++) {
+            auto &n = *(*iter)++;
+            auto &alloc = allocation[n.offset];
+            if (n.alloc) {
+                alloc.ptr = base::allocator.benchAlloc(n.size);
+                if (alloc.ptr == NULL) {
+                    state.SkipWithError("allocation failed");
+                }
+                alloc.size = n.size;
+            } else {
+                base::allocator.benchFree(alloc.ptr, alloc.size);
+                alloc.ptr = NULL;
+                alloc.size = 0;
+            }
+        }
+    }
+
+    virtual std::string name() {
+        return base::name() + "/multiple_malloc_free";
+    }
+
+    virtual std::vector<std::string> argsName() {
+        auto n = benchmark_interface<Size, Alloc>::argsName();
+        std::vector<std::string> res = {"max_allocs",
+                                        "thread_local_allocations"};
+        res.insert(res.end(), n.begin(), n.end());
+        return res;
+    }
+
+  private:
+    virtual void prealloc(benchmark::State &state) {
+        auto tid = state.thread_index();
+        auto &i = allocations[tid];
+        i.resize(max_allocs);
+        auto sizeGenerator = base::alloc_sizes[tid];
+
+        // Preallocate half of the available slots, for allocations
+        for (size_t j = 0; j < max_allocs / 2; j++) {
+            auto size = sizeGenerator.nextSize();
+            i[j].ptr = base::allocator.benchAlloc(size);
+            if (i[j].ptr == NULL) {
+                state.SkipWithError("preallocation failed");
+                return;
+            }
+            i[j].size = size;
+        }
+    }
+
+    void freeAllocs(benchmark::State &state) {
+        auto tid = state.thread_index();
+        auto &i = allocations[tid];
+        for (auto &j : i) {
+            if (j.ptr != NULL) {
+                base::allocator.benchFree(j.ptr, j.size);
+                j.ptr = NULL;
+                j.size = 0;
+            }
+        }
+    }
+
+    virtual void prepareWorkload(benchmark::State &state) {
+        auto tid = state.thread_index();
+        auto &n = next[tid];
+
+        // Create generators for random index selection and binary decision.
+        using distribution = std::uniform_int_distribution<size_t>;
+        std::default_random_engine generator;
+        distribution dist_offset(0, max_allocs - 1);
+        distribution dist_opt_type(0, 1);
+        generator.seed(0);
+
+        auto sizeGenerator = base::alloc_sizes[tid];
+        std::vector<size_t> free;
+        std::vector<size_t> allocated;
+        free.reserve(max_allocs / 2);
+        allocated.reserve(max_allocs / 2);
+        // Preallocate memory: initially, half the indices are allocated.
+        // See prealloc() function;
+        size_t i = 0;
+        while (i < max_allocs / 2) {
+            allocated.push_back(i++);
+        }
+        // The remaining indices are marked as free.
+        while (i < max_allocs) {
+            free.push_back(i++);
+        }
+
+        n.clear();
+        for (int64_t j = 0; j < state.max_iterations * allocsPerIterations;
+             j++) {
+            // Decide whether to allocate or free:
+            // - If no allocations exist, allocation is forced.
+            // - If there is maximum number of allocation, free is forced
+            // - Otherwise, use a binary random choice (0 or 1)
+            if (allocated.empty() ||
+                (dist_opt_type(generator) == 0 && !free.empty())) {
+                // Allocation:
+                std::swap(free[dist_offset(generator) % free.size()],
+                          free.back());
+                auto offset = free.back();
+                free.pop_back();
+
+                n.push_back({true, offset, sizeGenerator.nextSize()});
+                allocated.push_back(offset);
+            } else {
+                // Free
+                std::swap(allocated[dist_offset(generator) % allocated.size()],
+                          allocated.back());
+                auto offset = allocated.back();
+                allocated.pop_back();
+
+                n.push_back({false, offset, 0});
+                free.push_back(offset);
+            }
+        }
+
+        next_iter[tid] = std::make_unique<next_alloc_data_iterator>(n.cbegin());
+    }
+};
+// This class benchmarks performance by randomly allocating and freeing memory.
+// Initially, it slowly increases the memory footprint, and later decreases it.
+template <
+    typename Size, typename Alloc,
+    typename =
+        std::enable_if_t<std::is_base_of<alloc_size_interface, Size>::value>,
+    typename =
+        std::enable_if_t<std::is_base_of<allocator_interface, Alloc>::value>>
+class peak_alloc_benchmark
+    : public multiple_malloc_free_benchmark<Size, Alloc> {
+
+    using base = multiple_malloc_free_benchmark<Size, Alloc>;
+
+  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_size.hpp b/benchmark/benchmark_size.hpp
new file mode 100644
index 000000000..44e4bf1da
--- /dev/null
+++ b/benchmark/benchmark_size.hpp
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+#include <benchmark/benchmark.h>
+#include <string>
+#include <vector>
+
+class alloc_size_interface {
+  public:
+    virtual unsigned SetUp([[maybe_unused]] ::benchmark::State &state,
+                           [[maybe_unused]] unsigned argPos) = 0;
+    virtual void TearDown([[maybe_unused]] ::benchmark::State &state) = 0;
+    virtual size_t nextSize() = 0;
+    static std::vector<std::string> argsName() { return {""}; };
+};
+
+class fixed_alloc_size : public alloc_size_interface {
+  public:
+    unsigned SetUp(::benchmark::State &state, unsigned argPos) override {
+        size = state.range(argPos);
+        return argPos + 1;
+    }
+    void TearDown([[maybe_unused]] ::benchmark::State &state) override {}
+    size_t nextSize() override { return size; };
+    static std::vector<std::string> argsName() { return {"size"}; }
+
+  private:
+    size_t size;
+};
+
+class uniform_alloc_size : public alloc_size_interface {
+    using distribution = std::uniform_int_distribution<int64_t>;
+
+  public:
+    unsigned SetUp(::benchmark::State &state, unsigned argPos) override {
+        auto min = state.range(argPos++);
+        auto max = state.range(argPos++);
+        auto gran = state.range(argPos++);
+        if (min % gran != 0 && max % gran != 0) {
+            state.SkipWithError("min and max must be divisible by granularity");
+            return argPos;
+        }
+        generator.seed(0);
+        dist.param(distribution::param_type(min / gran, max / gran));
+        multiplier = gran;
+        return argPos;
+    }
+    void TearDown([[maybe_unused]] ::benchmark::State &state) override {}
+    size_t nextSize() override { return dist(generator) * multiplier; }
+    static std::vector<std::string> argsName() {
+        return {"min_size", "max_size", "granularity"};
+    }
+
+  private:
+    std::default_random_engine generator;
+    distribution dist;
+    size_t multiplier = 1;
+};
diff --git a/benchmark/benchmark_umf.hpp b/benchmark/benchmark_umf.hpp
new file mode 100644
index 000000000..74551b20e
--- /dev/null
+++ b/benchmark/benchmark_umf.hpp
@@ -0,0 +1,482 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+#include <memory>
+#include <thread>
+
+#include <benchmark/benchmark.h>
+#include <umf/memory_pool.h>
+#include <umf/memory_provider.h>
+#include <umf/pools/pool_disjoint.h>
+#include <umf/pools/pool_proxy.h>
+
+#ifdef UMF_POOL_SCALABLE_ENABLED
+#include <umf/pools/pool_scalable.h>
+#endif
+#include <umf/providers/provider_fixed_memory.h>
+#include <umf/providers/provider_os_memory.h>
+
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+#include <umf/pools/pool_jemalloc.h>
+#endif
+
+struct provider_interface {
+    using params_ptr = std::unique_ptr<void, void (*)(void *)>;
+
+    umf_memory_provider_handle_t provider = NULL;
+    void SetUp(::benchmark::State &state) {
+        if (state.thread_index() != 0) {
+            return;
+        }
+        auto params = getParams(state);
+        auto umf_result =
+            umfMemoryProviderCreate(getOps(state), params.get(), &provider);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            state.SkipWithError("umfMemoryProviderCreate() failed");
+        }
+    }
+
+    void preBench([[maybe_unused]] ::benchmark::State &state) {
+        if (state.thread_index() != 0) {
+            return;
+        }
+        umfCtlExec("umf.provider.by_handle.stats.peak_memory.reset", 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;
+        }
+
+        if (provider) {
+            umfMemoryProviderDestroy(provider);
+        }
+    }
+
+    virtual const umf_memory_provider_ops_t *
+    getOps([[maybe_unused]] ::benchmark::State &state) = 0;
+
+    virtual params_ptr getParams([[maybe_unused]] ::benchmark::State &state) {
+        return {nullptr, [](void *) {}};
+    }
+};
+
+template <typename T,
+          typename =
+              std::enable_if_t<std::is_base_of<provider_interface, T>::value>>
+struct pool_interface {
+    using params_ptr = std::unique_ptr<void, void (*)(void *)>;
+
+    void SetUp(::benchmark::State &state) {
+        provider.SetUp(state);
+        if (state.thread_index() != 0) {
+            return;
+        }
+        auto params = getParams(state);
+        auto umf_result = umfPoolCreate(getOps(state), provider.provider,
+                                        params.get(), 0, &pool);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            state.SkipWithError("umfPoolCreate() failed");
+        }
+    }
+
+    void preBench([[maybe_unused]] ::benchmark::State &state) {
+        provider.preBench(state);
+        if (state.thread_index() != 0) {
+            return;
+        }
+    }
+
+    void postBench([[maybe_unused]] ::benchmark::State &state) {
+        provider.postBench(state);
+        if (state.thread_index() != 0) {
+            return;
+        }
+    }
+
+    void TearDown([[maybe_unused]] ::benchmark::State &state) {
+        if (state.thread_index() != 0) {
+            return;
+        }
+        // TODO: The scalable pool destruction process can race with other threads
+        // performing TLS (Thread-Local Storage) destruction.
+        // As a temporary workaround, we introduce a delay (sleep)
+        // to ensure the pool is destroyed only after all threads have completed.
+        // Issue: #933
+        std::this_thread::sleep_for(std::chrono::milliseconds(500));
+        if (pool) {
+            umfPoolDestroy(pool);
+        }
+
+        provider.TearDown(state);
+    };
+
+    virtual const umf_memory_pool_ops_t *
+    getOps([[maybe_unused]] ::benchmark::State &state) = 0;
+
+    virtual params_ptr getParams([[maybe_unused]] ::benchmark::State &state) {
+        return {nullptr, [](void *) {}};
+    }
+
+    T provider;
+    umf_memory_pool_handle_t pool;
+};
+
+class allocator_interface {
+  public:
+    virtual unsigned SetUp([[maybe_unused]] ::benchmark::State &state,
+                           [[maybe_unused]] unsigned argPos) = 0;
+    virtual void preBench([[maybe_unused]] ::benchmark::State &state) = 0;
+    virtual void postBench([[maybe_unused]] ::benchmark::State &state) = 0;
+    virtual void TearDown([[maybe_unused]] ::benchmark::State &state) = 0;
+    virtual void *benchAlloc(size_t size) = 0;
+    virtual void benchFree(void *ptr, [[maybe_unused]] size_t size) = 0;
+    static std::vector<std::string> argsName() { return {}; }
+};
+
+struct glibc_malloc : public allocator_interface {
+    unsigned SetUp([[maybe_unused]] ::benchmark::State &state,
+                   unsigned argPos) override {
+        return argPos;
+    }
+    void preBench([[maybe_unused]] ::benchmark::State &state) override {}
+    void postBench([[maybe_unused]] ::benchmark::State &state) override {}
+    void TearDown([[maybe_unused]] ::benchmark::State &state) override {}
+    void *benchAlloc(size_t size) override { return malloc(size); }
+    void benchFree(void *ptr, [[maybe_unused]] size_t size) override {
+        free(ptr);
+    }
+    static std::string name() { return "glibc"; }
+};
+
+struct os_provider : public provider_interface {
+    provider_interface::params_ptr
+    getParams(::benchmark::State &state) override {
+        umf_os_memory_provider_params_handle_t raw_params = nullptr;
+        umfOsMemoryProviderParamsCreate(&raw_params);
+        if (!raw_params) {
+            state.SkipWithError("Failed to create os provider params");
+            return {nullptr, [](void *) {}};
+        }
+
+        // Use a lambda as the custom deleter
+        auto deleter = [](void *p) {
+            auto handle =
+                static_cast<umf_os_memory_provider_params_handle_t>(p);
+            umfOsMemoryProviderParamsDestroy(handle);
+        };
+
+        return {static_cast<provider_interface::params_ptr::element_type *>(
+                    raw_params),
+                deleter};
+    }
+
+    const umf_memory_provider_ops_t *
+    getOps([[maybe_unused]] ::benchmark::State &state) override {
+        return umfOsMemoryProviderOps();
+    }
+    static std::string name() { return "os_provider"; }
+};
+
+struct fixed_provider : public provider_interface {
+  private:
+    char *mem = NULL;
+    const size_t size = 1024 * 1024 * 1024; // 1GB
+  public:
+    void SetUp(::benchmark::State &state) {
+        if (state.thread_index() != 0) {
+            return;
+        }
+
+        if (!mem) {
+            mem = new char[size];
+        }
+
+        provider_interface::SetUp(state);
+    }
+
+    void TearDown(::benchmark::State &state) {
+        if (state.thread_index() != 0) {
+            return;
+        }
+
+        delete[] mem;
+        mem = nullptr;
+
+        provider_interface::TearDown(state);
+    }
+
+    provider_interface::params_ptr
+    getParams(::benchmark::State &state) override {
+        umf_fixed_memory_provider_params_handle_t raw_params = nullptr;
+        umfFixedMemoryProviderParamsCreate(&raw_params, mem, size);
+        if (!raw_params) {
+            state.SkipWithError("Failed to create fixed provider params");
+            return {nullptr, [](void *) {}};
+        }
+
+        // Use a lambda as the custom deleter
+        auto deleter = [](void *p) {
+            auto handle =
+                static_cast<umf_fixed_memory_provider_params_handle_t>(p);
+            umfFixedMemoryProviderParamsDestroy(handle);
+        };
+
+        return {static_cast<provider_interface::params_ptr::element_type *>(
+                    raw_params),
+                deleter};
+    }
+
+    const umf_memory_provider_ops_t *
+    getOps([[maybe_unused]] ::benchmark::State &state) override {
+        return umfFixedMemoryProviderOps();
+    }
+    static std::string name() { return "fixed_provider"; }
+};
+
+template <typename Provider>
+struct proxy_pool : public pool_interface<Provider> {
+    const umf_memory_pool_ops_t *
+    getOps([[maybe_unused]] ::benchmark::State &state) override {
+        return umfProxyPoolOps();
+    }
+
+    static std::string name() { return "proxy_pool<" + Provider::name() + ">"; }
+};
+
+template <typename Provider>
+struct disjoint_pool : public pool_interface<Provider> {
+    const umf_memory_pool_ops_t *
+    getOps([[maybe_unused]] ::benchmark::State &state) override {
+        return umfDisjointPoolOps();
+    }
+
+    typename pool_interface<Provider>::params_ptr
+    getParams(::benchmark::State &state) override {
+        umf_disjoint_pool_params_handle_t raw_params = nullptr;
+        auto ret = umfDisjointPoolParamsCreate(&raw_params);
+        if (ret != UMF_RESULT_SUCCESS) {
+            state.SkipWithError("Failed to create disjoint pool params");
+            return {nullptr, [](void *) {}};
+        }
+
+        typename pool_interface<Provider>::params_ptr params(
+            raw_params, [](void *p) {
+                umfDisjointPoolParamsDestroy(
+                    static_cast<umf_disjoint_pool_params_handle_t>(p));
+            });
+
+        ret = umfDisjointPoolParamsSetSlabMinSize(raw_params, 4096);
+        if (ret != UMF_RESULT_SUCCESS) {
+            state.SkipWithError("Failed to set slab min size");
+            return {nullptr, [](void *) {}};
+        }
+
+        ret = umfDisjointPoolParamsSetCapacity(raw_params, 4);
+        if (ret != UMF_RESULT_SUCCESS) {
+            state.SkipWithError("Failed to set capacity");
+            return {nullptr, [](void *) {}};
+        }
+
+        ret = umfDisjointPoolParamsSetMinBucketSize(raw_params, 8);
+        if (ret != UMF_RESULT_SUCCESS) {
+            state.SkipWithError("Failed to set min bucket size");
+            return {nullptr, [](void *) {}};
+        }
+
+        ret = umfDisjointPoolParamsSetMaxPoolableSize(raw_params, 4096 * 16);
+        if (ret != UMF_RESULT_SUCCESS) {
+            state.SkipWithError("Failed to set max poolable size");
+            return {nullptr, [](void *) {}};
+        }
+
+        return params;
+    }
+
+    static std::string name() {
+        return "disjoint_pool<" + Provider::name() + ">";
+    }
+};
+
+// benchmark tracking provider, by creating big number pools(2^7) stacked
+template <typename Provider>
+struct disjoint_pool_stack : public disjoint_pool<Provider> {
+    using base = disjoint_pool<Provider>;
+
+    std::vector<umf_memory_provider_handle_t> providers;
+    std::vector<umf_memory_pool_handle_t> pools;
+    std::vector<void *> pool_ptrs;
+
+    static constexpr size_t firstPoolSize = 2ull * 1024 * 1024 * 1024; // 2GB
+    static constexpr size_t levels = 7;
+
+    void SetUp(::benchmark::State &state) {
+        base::provider.SetUp(state);
+        if (state.thread_index() != 0) {
+            return;
+        }
+
+        providers.push_back(base::provider.provider);
+        base::provider.provider = nullptr;
+
+        auto params = base::getParams(state);
+        umf_memory_pool_handle_t rootPool = nullptr;
+        auto umf_result = umfPoolCreate(base::getOps(state), providers[0],
+                                        params.get(), 0, &rootPool);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            state.SkipWithError("umfPoolCreate() failed");
+            return;
+        }
+
+        pools.push_back(rootPool); // root pool
+
+        umf_fixed_memory_provider_params_handle_t params_fixed = nullptr;
+        umf_result = umfFixedMemoryProviderParamsCreate(
+            &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> {
+    const umf_memory_pool_ops_t *
+    getOps([[maybe_unused]] ::benchmark::State &state) override {
+        return umfJemallocPoolOps();
+    }
+
+    static std::string name() {
+        return "jemalloc_pool<" + Provider::name() + ">";
+    }
+};
+#endif
+
+#ifdef UMF_POOL_SCALABLE_ENABLED
+template <typename Provider>
+struct scalable_pool : public pool_interface<Provider> {
+    const umf_memory_pool_ops_t *
+    getOps([[maybe_unused]] ::benchmark::State &state) override {
+        return umfScalablePoolOps();
+    }
+
+    static std::string name() {
+        return "scalable_pool<" + Provider::name() + ">";
+    }
+};
+#endif
diff --git a/benchmark/multithread.cpp b/benchmark/multithread.cpp
index 8239c8cd4..fac2d063a 100644
--- a/benchmark/multithread.cpp
+++ b/benchmark/multithread.cpp
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -27,8 +27,9 @@ struct bench_params {
     size_t alloc_size = 64;
 };
 
-using poolCreateExtParams = std::tuple<umf_memory_pool_ops_t *, void *,
-                                       umf_memory_provider_ops_t *, void *>;
+using poolCreateExtParams =
+    std::tuple<const umf_memory_pool_ops_t *, const void *,
+               const umf_memory_provider_ops_t *, const void *>;
 
 static auto poolCreateExtUnique(poolCreateExtParams params) {
     umf_memory_pool_handle_t hPool;
@@ -91,7 +92,12 @@ static void mt_alloc_free(poolCreateExtParams params,
 }
 
 int main() {
-    auto osParams = umfOsMemoryProviderParamsDefault();
+    umf_os_memory_provider_params_handle_t osParams = nullptr;
+    umf_result_t res = umfOsMemoryProviderParamsCreate(&osParams);
+    if (res != UMF_RESULT_SUCCESS) {
+        std::cerr << "os memory provider params create failed" << std::endl;
+        return -1;
+    }
 
 #if defined(UMF_POOL_SCALABLE_ENABLED)
 
@@ -102,32 +108,40 @@ int main() {
 
     std::cout << "scalable_pool mt_alloc_free: ";
     mt_alloc_free(poolCreateExtParams{umfScalablePoolOps(), nullptr,
-                                      umfOsMemoryProviderOps(), &osParams},
+                                      umfOsMemoryProviderOps(), osParams},
                   params);
 #else
     std::cout << "skipping scalable_pool mt_alloc_free" << std::endl;
 #endif
 
-#if defined(UMF_BUILD_LIBUMF_POOL_JEMALLOC)
+#if defined(UMF_POOL_JEMALLOC_ENABLED)
     std::cout << "jemalloc_pool mt_alloc_free: ";
     mt_alloc_free(poolCreateExtParams{umfJemallocPoolOps(), nullptr,
-                                      umfOsMemoryProviderOps(), &osParams});
+                                      umfOsMemoryProviderOps(), osParams});
 #else
     std::cout << "skipping jemalloc_pool mt_alloc_free" << std::endl;
 #endif
 
-#if defined(UMF_BUILD_LIBUMF_POOL_DISJOINT)
-    auto disjointParams = umfDisjointPoolParamsDefault();
+    // NOTE: disjoint pool is always enabled
+    umf_disjoint_pool_params_handle_t hDisjointParams = nullptr;
+    umf_result_t ret = umfDisjointPoolParamsCreate(&hDisjointParams);
+    if (ret != UMF_RESULT_SUCCESS) {
+        std::cerr << "disjoint pool params create failed" << std::endl;
+        return -1;
+    }
 
     std::cout << "disjoint_pool mt_alloc_free: ";
-    mt_alloc_free(poolCreateExtParams{umfDisjointPoolOps(), &disjointParams,
-                                      umfOsMemoryProviderOps(), &osParams});
-#else
-    std::cout << "skipping disjoint_pool mt_alloc_free" << std::endl;
-#endif
+    mt_alloc_free(poolCreateExtParams{umfDisjointPoolOps(), hDisjointParams,
+                                      umfOsMemoryProviderOps(), osParams});
 
     // ctest looks for "PASSED" in the output
     std::cout << "PASSED" << std::endl;
 
+    ret = umfDisjointPoolParamsDestroy(hDisjointParams);
+    if (ret != UMF_RESULT_SUCCESS) {
+        std::cerr << "disjoint pool params destroy failed" << std::endl;
+        return -1;
+    }
+
     return 0;
 }
diff --git a/benchmark/multithread.hpp b/benchmark/multithread.hpp
index e642d2987..a3ba37541 100644
--- a/benchmark/multithread.hpp
+++ b/benchmark/multithread.hpp
@@ -17,6 +17,7 @@
 #include <functional>
 #include <mutex>
 #include <numeric>
+#include <stdexcept>
 #include <thread>
 #include <vector>
 
diff --git a/benchmark/ubench.c b/benchmark/ubench.c
index 900b7b85c..5beaa62be 100644
--- a/benchmark/ubench.c
+++ b/benchmark/ubench.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -15,22 +15,19 @@
 
 #include <umf/ipc.h>
 #include <umf/memory_pool.h>
+#include <umf/pools/pool_disjoint.h>
 #include <umf/pools/pool_proxy.h>
 #include <umf/pools/pool_scalable.h>
 #include <umf/providers/provider_level_zero.h>
 #include <umf/providers/provider_os_memory.h>
 
-#ifdef UMF_BUILD_LIBUMF_POOL_DISJOINT
-#include <umf/pools/pool_disjoint.h>
-#endif
-
-#ifdef UMF_BUILD_LIBUMF_POOL_JEMALLOC
+#ifdef UMF_POOL_JEMALLOC_ENABLED
 #include <umf/pools/pool_jemalloc.h>
 #endif
 
 #include "utils_common.h"
 
-#if (defined UMF_BUILD_GPU_TESTS)
+#if (defined UMF_PROVIDER_LEVEL_ZERO_ENABLED && defined UMF_BUILD_GPU_TESTS)
 #include "utils_level_zero.h"
 #endif
 
@@ -52,7 +49,7 @@
 #include "ubench.h"
 // BENCHMARK CONFIG
 #define N_ITERATIONS 1000
-#define ALLOC_SIZE (util_get_page_size())
+#define ALLOC_SIZE (utils_get_page_size())
 
 // OS MEMORY PROVIDER CONFIG
 #define OS_MEMORY_PROVIDER_TRACE (0)
@@ -123,22 +120,6 @@ UBENCH_EX(simple, glibc_malloc) {
 
 ////////////////// OS MEMORY PROVIDER
 
-static umf_os_memory_provider_params_t UMF_OS_MEMORY_PROVIDER_PARAMS = {
-    /* .protection = */ UMF_PROTECTION_READ | UMF_PROTECTION_WRITE,
-    /* .visibility = */ UMF_MEM_MAP_PRIVATE,
-    /* .shm_name = */ NULL,
-
-    // NUMA config
-    /* .numa_list = */ NULL,
-    /* .numa_list_len = */ 0,
-
-    /* .numa_mode = */ UMF_NUMA_MODE_DEFAULT,
-    /* .part_size = */ 0,
-
-    /* .partitions = */ NULL,
-    /* .partitions_len = */ 0,
-};
-
 static void *w_umfMemoryProviderAlloc(void *provider, size_t size,
                                       size_t alignment) {
     void *ptr = NULL;
@@ -170,9 +151,17 @@ UBENCH_EX(simple, os_memory_provider) {
 
     umf_result_t umf_result;
     umf_memory_provider_handle_t os_memory_provider = NULL;
-    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(),
-                                         &UMF_OS_MEMORY_PROVIDER_PARAMS,
+    umf_os_memory_provider_params_handle_t os_params = NULL;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "error: umfOsMemoryProviderParamsCreate() failed\n");
+        exit(-1);
+    }
+
+    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(), os_params,
                                          &os_memory_provider);
+    umfOsMemoryProviderParamsDestroy(os_params);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "error: umfMemoryProviderCreate() failed\n");
         exit(-1);
@@ -214,9 +203,17 @@ UBENCH_EX(simple, proxy_pool_with_os_memory_provider) {
 
     umf_result_t umf_result;
     umf_memory_provider_handle_t os_memory_provider = NULL;
-    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(),
-                                         &UMF_OS_MEMORY_PROVIDER_PARAMS,
+    umf_os_memory_provider_params_handle_t os_params = NULL;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "error: umfOsMemoryProviderParamsCreate() failed\n");
+        exit(-1);
+    }
+
+    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(), os_params,
                                          &os_memory_provider);
+    umfOsMemoryProviderParamsDestroy(os_params);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "error: umfMemoryProviderCreate() failed\n");
         exit(-1);
@@ -243,7 +240,6 @@ UBENCH_EX(simple, proxy_pool_with_os_memory_provider) {
     free(array);
 }
 
-#if (defined UMF_BUILD_LIBUMF_POOL_DISJOINT)
 ////////////////// DISJOINT POOL WITH OS MEMORY PROVIDER
 
 UBENCH_EX(simple, disjoint_pool_with_os_memory_provider) {
@@ -251,24 +247,63 @@ UBENCH_EX(simple, disjoint_pool_with_os_memory_provider) {
 
     umf_result_t umf_result;
     umf_memory_provider_handle_t os_memory_provider = NULL;
-    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(),
-                                         &UMF_OS_MEMORY_PROVIDER_PARAMS,
+    umf_os_memory_provider_params_handle_t os_params = NULL;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "error: umfOsMemoryProviderParamsCreate() failed\n");
+        exit(-1);
+    }
+
+    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(), os_params,
                                          &os_memory_provider);
+    umfOsMemoryProviderParamsDestroy(os_params);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "error: umfMemoryProviderCreate() failed\n");
         exit(-1);
     }
 
-    umf_disjoint_pool_params_t disjoint_memory_pool_params = {0};
-    disjoint_memory_pool_params.SlabMinSize = DISJOINT_POOL_SLAB_MIN_SIZE;
-    disjoint_memory_pool_params.MaxPoolableSize =
-        DISJOINT_POOL_MAX_POOLABLE_SIZE;
-    disjoint_memory_pool_params.Capacity = DISJOINT_POOL_CAPACITY;
-    disjoint_memory_pool_params.MinBucketSize = DISJOINT_POOL_MIN_BUCKET_SIZE;
+    umf_disjoint_pool_params_handle_t disjoint_memory_pool_params = NULL;
+    umf_result = umfDisjointPoolParamsCreate(&disjoint_memory_pool_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "ERROR: umfDisjointPoolParamsCreate failed\n");
+        exit(-1);
+    }
+
+    umf_result = umfDisjointPoolParamsSetSlabMinSize(
+        disjoint_memory_pool_params, DISJOINT_POOL_SLAB_MIN_SIZE);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "error: umfDisjointPoolParamsSetSlabMinSize() failed\n");
+        exit(-1);
+    }
+
+    umf_result = umfDisjointPoolParamsSetMaxPoolableSize(
+        disjoint_memory_pool_params, DISJOINT_POOL_MAX_POOLABLE_SIZE);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "error: umfDisjointPoolParamsSetMaxPoolableSize() failed\n");
+        exit(-1);
+    }
+
+    umf_result = umfDisjointPoolParamsSetCapacity(disjoint_memory_pool_params,
+                                                  DISJOINT_POOL_CAPACITY);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "error: umfDisjointPoolParamsSetCapacity() failed\n");
+        exit(-1);
+    }
+
+    umf_result = umfDisjointPoolParamsSetMinBucketSize(
+        disjoint_memory_pool_params, DISJOINT_POOL_MIN_BUCKET_SIZE);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "error: umfDisjointPoolParamsSetMinBucketSize() failed\n");
+        exit(-1);
+    }
 
     umf_memory_pool_handle_t disjoint_pool;
     umf_result = umfPoolCreate(umfDisjointPoolOps(), os_memory_provider,
-                               &disjoint_memory_pool_params, 0, &disjoint_pool);
+                               disjoint_memory_pool_params, 0, &disjoint_pool);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "error: umfPoolCreate() failed\n");
         exit(-1);
@@ -283,12 +318,12 @@ UBENCH_EX(simple, disjoint_pool_with_os_memory_provider) {
     }
 
     umfPoolDestroy(disjoint_pool);
+    umfDisjointPoolParamsDestroy(disjoint_memory_pool_params);
     umfMemoryProviderDestroy(os_memory_provider);
     free(array);
 }
-#endif /* (defined UMF_BUILD_LIBUMF_POOL_DISJOINT) */
 
-#if (defined UMF_BUILD_LIBUMF_POOL_JEMALLOC)
+#if (defined UMF_POOL_JEMALLOC_ENABLED)
 ////////////////// JEMALLOC POOL WITH OS MEMORY PROVIDER
 
 UBENCH_EX(simple, jemalloc_pool_with_os_memory_provider) {
@@ -296,9 +331,17 @@ UBENCH_EX(simple, jemalloc_pool_with_os_memory_provider) {
 
     umf_result_t umf_result;
     umf_memory_provider_handle_t os_memory_provider = NULL;
-    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(),
-                                         &UMF_OS_MEMORY_PROVIDER_PARAMS,
+    umf_os_memory_provider_params_handle_t os_params = NULL;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "error: umfOsMemoryProviderParamsCreate() failed\n");
+        exit(-1);
+    }
+
+    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(), os_params,
                                          &os_memory_provider);
+    umfOsMemoryProviderParamsDestroy(os_params);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "error: umfMemoryProviderCreate() failed\n");
         exit(-1);
@@ -324,7 +367,7 @@ UBENCH_EX(simple, jemalloc_pool_with_os_memory_provider) {
     umfMemoryProviderDestroy(os_memory_provider);
     free(array);
 }
-#endif /* (defined UMF_BUILD_LIBUMF_POOL_JEMALLOC) */
+#endif /* (defined UMF_POOL_JEMALLOC_ENABLED) */
 
 #if (defined UMF_POOL_SCALABLE_ENABLED)
 ////////////////// SCALABLE (TBB) POOL WITH OS MEMORY PROVIDER
@@ -334,9 +377,17 @@ UBENCH_EX(simple, scalable_pool_with_os_memory_provider) {
 
     umf_result_t umf_result;
     umf_memory_provider_handle_t os_memory_provider = NULL;
-    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(),
-                                         &UMF_OS_MEMORY_PROVIDER_PARAMS,
+    umf_os_memory_provider_params_handle_t os_params = NULL;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "error: umfOsMemoryProviderParamsCreate() failed\n");
+        exit(-1);
+    }
+
+    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(), os_params,
                                          &os_memory_provider);
+    umfOsMemoryProviderParamsDestroy(os_params);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "error: umfMemoryProviderCreate() failed\n");
         exit(-1);
@@ -364,8 +415,7 @@ UBENCH_EX(simple, scalable_pool_with_os_memory_provider) {
 }
 #endif /* (defined UMF_POOL_SCALABLE_ENABLED) */
 
-#if (defined UMF_BUILD_LIBUMF_POOL_DISJOINT &&                                 \
-     defined UMF_BUILD_LEVEL_ZERO_PROVIDER && defined UMF_BUILD_GPU_TESTS)
+#if (defined UMF_PROVIDER_LEVEL_ZERO_ENABLED && defined UMF_BUILD_GPU_TESTS)
 static void do_ipc_get_put_benchmark(alloc_t *allocs, size_t num_allocs,
                                      size_t repeats,
                                      umf_ipc_handle_t *ipc_handles) {
@@ -388,54 +438,85 @@ static void do_ipc_get_put_benchmark(alloc_t *allocs, size_t num_allocs,
     }
 }
 
-int create_level_zero_params(level_zero_memory_provider_params_t *params) {
+static int create_level_zero_params(ze_context_handle_t *context,
+                                    ze_device_handle_t *device) {
     uint32_t driver_idx = 0;
     ze_driver_handle_t driver = NULL;
-    ze_context_handle_t context = NULL;
-    ze_device_handle_t device = NULL;
 
-    int ret = init_level_zero();
+    int ret = utils_ze_init_level_zero();
     if (ret != 0) {
-        fprintf(stderr, "Failed to init Level 0!\n");
+        fprintf(stderr, "Failed to init Level Zero!\n");
         return ret;
     }
 
-    ret = find_driver_with_gpu(&driver_idx, &driver);
+    ret = utils_ze_find_driver_with_gpu(&driver_idx, &driver);
     if (ret || driver == NULL) {
         fprintf(stderr, "Cannot find L0 driver with GPU device!\n");
         return ret;
     }
 
-    ret = create_context(driver, &context);
+    ret = utils_ze_create_context(driver, context);
     if (ret != 0) {
         fprintf(stderr, "Failed to create L0 context!\n");
         return ret;
     }
 
-    ret = find_gpu_device(driver, &device);
-    if (ret || device == NULL) {
+    ret = utils_ze_find_gpu_device(driver, device);
+    if (ret) {
         fprintf(stderr, "Cannot find GPU device!\n");
-        destroy_context(context);
+        utils_ze_destroy_context(*context);
         return ret;
     }
 
-    params->level_zero_context_handle = context;
-    params->level_zero_device_handle = device;
-    params->memory_type = UMF_MEMORY_TYPE_DEVICE;
-
     return ret;
 }
 
 UBENCH_EX(ipc, disjoint_pool_with_level_zero_provider) {
     const size_t BUFFER_SIZE = 100;
     const size_t N_BUFFERS = 1000;
-    level_zero_memory_provider_params_t level_zero_params;
+    umf_result_t umf_result;
+    ze_context_handle_t context = NULL;
+    ze_device_handle_t device = NULL;
+    umf_level_zero_memory_provider_params_handle_t level_zero_params = NULL;
 
-    int ret = create_level_zero_params(&level_zero_params);
+    int ret = create_level_zero_params(&context, &device);
     if (ret != 0) {
+        fprintf(stderr, "error: create_level_zero_params() failed\n");
         exit(-1);
     }
 
+    umf_result = umfLevelZeroMemoryProviderParamsCreate(&level_zero_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "error: umfLevelZeroMemoryProviderParamsCreate() failed\n");
+        goto err_destroy_context;
+    }
+
+    umf_result =
+        umfLevelZeroMemoryProviderParamsSetContext(level_zero_params, context);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "error: umfLevelZeroMemoryProviderParamsSetContext() failed\n");
+        goto err_destroy_params;
+    }
+
+    umf_result =
+        umfLevelZeroMemoryProviderParamsSetDevice(level_zero_params, device);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "error: umfLevelZeroMemoryProviderParamsSetDevice() failed\n");
+        goto err_destroy_params;
+    }
+
+    umf_result = umfLevelZeroMemoryProviderParamsSetMemoryType(
+        level_zero_params, UMF_MEMORY_TYPE_DEVICE);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(
+            stderr,
+            "error: umfLevelZeroMemoryProviderParamsSetMemoryType() failed\n");
+        goto err_destroy_params;
+    }
+
     alloc_t *allocs = alloc_array(N_BUFFERS);
     if (allocs == NULL) {
         fprintf(stderr, "error: alloc_array() failed\n");
@@ -448,28 +529,58 @@ UBENCH_EX(ipc, disjoint_pool_with_level_zero_provider) {
         goto err_free_allocs;
     }
 
-    umf_result_t umf_result;
     umf_memory_provider_handle_t provider = NULL;
     umf_result = umfMemoryProviderCreate(umfLevelZeroMemoryProviderOps(),
-                                         &level_zero_params, &provider);
+                                         level_zero_params, &provider);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "error: umfMemoryProviderCreate() failed\n");
         goto err_free_ipc_handles;
     }
 
-    umf_disjoint_pool_params_t disjoint_params = {0};
-    disjoint_params.SlabMinSize = BUFFER_SIZE * 10;
-    disjoint_params.MaxPoolableSize = 4ull * 1024ull * 1024ull;
-    disjoint_params.Capacity = 64ull * 1024ull;
-    disjoint_params.MinBucketSize = 64;
-    umf_pool_create_flags_t flags = UMF_POOL_CREATE_FLAG_OWN_PROVIDER;
+    umf_disjoint_pool_params_handle_t disjoint_params = NULL;
+    umf_result = umfDisjointPoolParamsCreate(&disjoint_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "ERROR: umfDisjointPoolParamsCreate failed\n");
+        goto err_provider_destroy;
+    }
+
+    umf_result =
+        umfDisjointPoolParamsSetSlabMinSize(disjoint_params, BUFFER_SIZE * 10);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "error: umfDisjointPoolParamsSetSlabMinSize() failed\n");
+        goto err_params_destroy;
+    }
+
+    umf_result = umfDisjointPoolParamsSetMaxPoolableSize(
+        disjoint_params, 4ull * 1024ull * 1024ull);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "error: umfDisjointPoolParamsSetMaxPoolableSize() failed\n");
+        goto err_params_destroy;
+    }
+
+    umf_result =
+        umfDisjointPoolParamsSetCapacity(disjoint_params, 64ull * 1024ull);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "error: umfDisjointPoolParamsSetCapacity() failed\n");
+        goto err_params_destroy;
+    }
+
+    umf_result = umfDisjointPoolParamsSetMinBucketSize(disjoint_params, 64);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "error: umfDisjointPoolParamsSetMinBucketSize() failed\n");
+        goto err_params_destroy;
+    }
+
+    umf_pool_create_flags_t flags = UMF_POOL_CREATE_FLAG_NONE;
     umf_memory_pool_handle_t pool;
-    umf_result = umfPoolCreate(umfDisjointPoolOps(), provider, &disjoint_params,
+    umf_result = umfPoolCreate(umfDisjointPoolOps(), provider, disjoint_params,
                                flags, &pool);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "error: umfPoolCreate() failed\n");
-        umfMemoryProviderDestroy(provider);
-        goto err_free_ipc_handles;
+        goto err_params_destroy;
     }
 
     for (size_t i = 0; i < N_BUFFERS; ++i) {
@@ -494,16 +605,27 @@ UBENCH_EX(ipc, disjoint_pool_with_level_zero_provider) {
 
     umfPoolDestroy(pool);
 
+err_params_destroy:
+    umfDisjointPoolParamsDestroy(disjoint_params);
+
+err_provider_destroy:
+    umfMemoryProviderDestroy(provider);
+
 err_free_ipc_handles:
     free(ipc_handles);
 
 err_free_allocs:
     free(allocs);
 
+err_destroy_params:
+    umfLevelZeroMemoryProviderParamsDestroy(level_zero_params);
+
 err_destroy_context:
-    destroy_context(level_zero_params.level_zero_context_handle);
+    utils_ze_destroy_context(context);
 }
-#endif /* (defined UMF_BUILD_LIBUMF_POOL_DISJOINT && defined UMF_BUILD_LEVEL_ZERO_PROVIDER && defined UMF_BUILD_GPU_TESTS) */
+#endif /* (defined UMF_BUILD_LEVEL_ZERO_PROVIDER && defined UMF_BUILD_GPU_TESTS) */
+
+// TODO add IPC benchmark for CUDA
 
 UBENCH_MAIN()
 
diff --git a/cmake/FindCUDA.cmake b/cmake/FindCUDA.cmake
new file mode 100644
index 000000000..cfc59b5ad
--- /dev/null
+++ b/cmake/FindCUDA.cmake
@@ -0,0 +1,40 @@
+# Copyright (C) 2024-2025 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+message(STATUS "Checking for module '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})
+
+if(WINDOWS)
+    find_file(CUDA_DLL NAMES "nvcuda.dll")
+    get_filename_component(CUDA_DLL_DIR ${CUDA_DLL} DIRECTORY)
+    set(CUDA_DLL_DIRS ${CUDA_DLL_DIR})
+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}")
+    message(STATUS "    CUDA_LIBRARY_DIRS = ${CUDA_LIBRARY_DIRS}")
+    if(WINDOWS)
+        message(STATUS "    CUDA_DLL_DIRS = ${CUDA_DLL_DIRS}")
+    endif()
+else()
+    set(MSG_NOT_FOUND "cuda NOT found (set CMAKE_PREFIX_PATH to point the "
+                      "location)")
+    if(CUDA_FIND_REQUIRED)
+        message(FATAL_ERROR ${MSG_NOT_FOUND})
+    else()
+        message(STATUS ${MSG_NOT_FOUND})
+    endif()
+endif()
diff --git a/cmake/FindJEMALLOC.cmake b/cmake/FindJEMALLOC.cmake
index 89d488ecc..524191dca 100644
--- a/cmake/FindJEMALLOC.cmake
+++ b/cmake/FindJEMALLOC.cmake
@@ -1,4 +1,4 @@
-# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -23,7 +23,7 @@ else()
     if(JEMALLOC_FIND_REQUIRED)
         message(FATAL_ERROR ${MSG_NOT_FOUND})
     else()
-        message(WARNING ${MSG_NOT_FOUND})
+        message(STATUS ${MSG_NOT_FOUND})
     endif()
 endif()
 
@@ -34,19 +34,14 @@ if(WINDOWS)
 endif()
 
 if(JEMALLOC_LIBRARY)
+    set(JEMALLOC_FOUND TRUE)
     message(STATUS "  Found jemalloc using find_library()")
-    message(STATUS "    JEMALLOC_LIBRARIES = ${JEMALLOC_LIBRARIES}")
-    message(STATUS "    JEMALLOC_INCLUDE_DIRS = ${JEMALLOC_INCLUDE_DIRS}")
-    message(STATUS "    JEMALLOC_LIBRARY_DIRS = ${JEMALLOC_LIBRARY_DIRS}")
-    if(WINDOWS)
-        message(STATUS "    JEMALLOC_DLL_DIRS = ${JEMALLOC_DLL_DIRS}")
-    endif()
 else()
     set(MSG_NOT_FOUND
         "jemalloc NOT found (set CMAKE_PREFIX_PATH to point the location)")
     if(JEMALLOC_FIND_REQUIRED)
         message(FATAL_ERROR ${MSG_NOT_FOUND})
     else()
-        message(WARNING ${MSG_NOT_FOUND})
+        message(STATUS ${MSG_NOT_FOUND})
     endif()
 endif()
diff --git a/cmake/FindLIBHWLOC.cmake b/cmake/FindLIBHWLOC.cmake
index a7c9201a0..f9d1dfe38 100644
--- a/cmake/FindLIBHWLOC.cmake
+++ b/cmake/FindLIBHWLOC.cmake
@@ -1,7 +1,17 @@
-# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+function(print_hwloc_dirs)
+    message(STATUS "    LIBHWLOC_LIBRARIES = ${LIBHWLOC_LIBRARIES}")
+    message(STATUS "    LIBHWLOC_INCLUDE_DIRS = ${LIBHWLOC_INCLUDE_DIRS}")
+    message(STATUS "    LIBHWLOC_LIBRARY_DIRS = ${LIBHWLOC_LIBRARY_DIRS}")
+    message(STATUS "    LIBHWLOC_API_VERSION = ${LIBHWLOC_API_VERSION}")
+    if(WINDOWS)
+        message(STATUS "    LIBHWLOC_DLL_DIRS = ${LIBHWLOC_DLL_DIRS}")
+    endif()
+endfunction()
+
 message(STATUS "Checking for module 'libhwloc' using find_library()")
 
 find_library(LIBHWLOC_LIBRARY NAMES ${UMF_HWLOC_NAME})
@@ -45,20 +55,16 @@ if(WINDOWS)
 endif()
 
 if(LIBHWLOC_LIBRARY)
-    message(STATUS "  Found libhwloc using find_library()")
-    message(STATUS "    LIBHWLOC_LIBRARIES = ${LIBHWLOC_LIBRARIES}")
-    message(STATUS "    LIBHWLOC_INCLUDE_DIRS = ${LIBHWLOC_INCLUDE_DIRS}")
-    message(STATUS "    LIBHWLOC_LIBRARY_DIRS = ${LIBHWLOC_LIBRARY_DIRS}")
-    message(STATUS "    LIBHWLOC_API_VERSION = ${LIBHWLOC_API_VERSION}")
-    if(WINDOWS)
-        message(STATUS "    LIBHWLOC_DLL_DIRS = ${LIBHWLOC_DLL_DIRS}")
-    endif()
+    set(LIBHWLOC_FOUND TRUE)
+    message(STATUS "  Found libhwloc: ${LIBHWLOC_LIBRARY}")
 
     if(LIBHWLOC_FIND_VERSION)
         if(NOT LIBHWLOC_API_VERSION)
+            print_hwloc_dirs()
             message(FATAL_ERROR "Failed to retrieve libhwloc version")
         elseif(NOT LIBHWLOC_API_VERSION VERSION_GREATER_EQUAL
                LIBHWLOC_FIND_VERSION)
+            print_hwloc_dirs()
             message(
                 FATAL_ERROR
                     "    Required version: ${LIBHWLOC_FIND_VERSION}, found ${LIBHWLOC_API_VERSION}"
@@ -67,10 +73,10 @@ if(LIBHWLOC_LIBRARY)
     endif()
 else()
     set(MSG_NOT_FOUND
-        "libhwloc NOT found (set CMAKE_PREFIX_PATH to point the location)")
+        "libhwloc NOT found in the system (will fetch it from GitHub)")
     if(LIBHWLOC_FIND_REQUIRED)
         message(FATAL_ERROR ${MSG_NOT_FOUND})
     else()
-        message(WARNING ${MSG_NOT_FOUND})
+        message(STATUS ${MSG_NOT_FOUND})
     endif()
 endif()
diff --git a/cmake/FindLIBNUMA.cmake b/cmake/FindLIBNUMA.cmake
index 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 1d3e175fa..8fea0a743 100644
--- a/cmake/helpers.cmake
+++ b/cmake/helpers.cmake
@@ -1,4 +1,4 @@
-# Copyright (C) 2023-2024 Intel Corporation
+# Copyright (C) 2023-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -121,6 +121,22 @@ function(set_version_variables)
         return()
     endif()
 
+    # v1.5.0-dev1 - we're on a development tag -> UMF ver: "1.5.0-dev1"
+    string(REGEX MATCHALL "\^v([0-9]+\.[0-9]+\.[0-9]+)-(dev[0-9]?)\$" MATCHES
+                 ${GIT_VERSION})
+    if(MATCHES)
+        set(UMF_VERSION
+            "${CMAKE_MATCH_1}-${CMAKE_MATCH_2}"
+            PARENT_SCOPE)
+        set(UMF_CMAKE_VERSION
+            "${CMAKE_MATCH_1}"
+            PARENT_SCOPE)
+        set(UMF_VERSION_PRIVATE
+            0
+            PARENT_SCOPE)
+        return()
+    endif()
+
     # v1.5.0-rc1-19-gb8f7a32 -> UMF ver: "1.5.0-rc1.git19.gb8f7a32"
     string(REGEX MATCHALL "v([0-9.]*)-rc([0-9]*)-([0-9]*)-([0-9a-g]*)" MATCHES
                  ${GIT_VERSION})
@@ -141,6 +157,19 @@ function(set_version_variables)
         return()
     endif()
 
+    # v1.5.0-dev2-19-gb8f7a32 -> UMF ver: "1.5.0-dev2.git19.gb8f7a32"
+    string(REGEX MATCHALL "v([0-9.]*)-(dev[0-9]?)-([0-9]*)-([0-9a-g]*)" MATCHES
+                 ${GIT_VERSION})
+    if(MATCHES)
+        set(UMF_VERSION
+            "${CMAKE_MATCH_1}-${CMAKE_MATCH_2}.git${CMAKE_MATCH_3}.${CMAKE_MATCH_4}"
+            PARENT_SCOPE)
+        set(UMF_CMAKE_VERSION
+            "${CMAKE_MATCH_1}"
+            PARENT_SCOPE)
+        return()
+    endif()
+
     # v1.5.0-19-gb8f7a32 -> UMF ver: "1.5.0-git19.gb8f7a32"
     string(REGEX MATCHALL "v([0-9.]*)-([0-9]*)-([0-9a-g]*)" MATCHES
                  ${GIT_VERSION})
@@ -196,40 +225,52 @@ endfunction()
 
 function(add_umf_target_compile_options name)
     check_add_target_compile_options(${name} "-Wno-covered-switch-default")
-
+    target_compile_definitions(${name}
+                               PRIVATE ${UMF_COMMON_COMPILE_DEFINITIONS})
     if(NOT MSVC)
         target_compile_options(
             ${name}
             PRIVATE -fPIC
                     -Wall
                     -Wextra
-                    -Wpedantic
-                    -Wempty-body
-                    -Wunused-parameter
-                    -Wformat
                     -Wformat-security
-                    -Wcast-qual
-                    -Wunused-result
+                    -Wno-cast-qual # TODO: remove this when const qualifier drop
+                                   # will be solved in CTL
                     $<$<CXX_COMPILER_ID:GNU>:-fdiagnostics-color=auto>)
         if(CMAKE_BUILD_TYPE STREQUAL "Release")
             target_compile_definitions(${name} PRIVATE -D_FORTIFY_SOURCE=2)
         endif()
         if(UMF_DEVELOPER_MODE)
-            target_compile_options(${name} PRIVATE -fno-omit-frame-pointer
-                                                   -fstack-protector-strong)
+            target_compile_options(
+                ${name} PRIVATE -fno-omit-frame-pointer
+                                -fstack-protector-strong -Werror)
         endif()
-        if(UMF_USE_GCOV)
+        if(UMF_USE_COVERAGE)
             if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
-                message(FATAL_ERROR "To use gcov, the build type must be Debug")
+                message(
+                    FATAL_ERROR
+                        "To use the --coverage flag, the build type must be Debug"
+                )
             endif()
             target_compile_options(${name} PRIVATE --coverage)
+            if(${CMAKE_C_COMPILER} MATCHES "gcc")
+                # Fix for the following error: geninfo: ERROR: Unexpected
+                # negative count '-1' for provider_os_memory.c:1037. Perhaps you
+                # need to compile with '-fprofile-update=atomic
+                target_compile_options(${name} PRIVATE -fprofile-update=atomic
+                                                       -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}
             PRIVATE /MD$<$<CONFIG:Debug>:d>
                     $<$<CONFIG:Release>:/sdl>
-                    /analyze
+                    $<$<CXX_COMPILER_ID:MSVC>:/analyze>
                     /DYNAMICBASE
                     /W4
                     /Gy
@@ -240,6 +281,9 @@ function(add_umf_target_compile_options name)
                     # disable 4200 warning: nonstandard extension used:
                     # zero-sized array in struct/union
                     /wd4200)
+        if(UMF_DEVELOPER_MODE)
+            target_compile_options(${name} PRIVATE /WX)
+        endif()
         if(${CMAKE_C_COMPILER_ID} MATCHES "MSVC")
             target_compile_options(
                 ${name}
@@ -254,10 +298,12 @@ function(add_umf_target_link_options name)
     if(NOT MSVC)
         if(NOT APPLE)
             target_link_options(${name} PRIVATE "LINKER:-z,relro,-z,now")
-            if(UMF_USE_GCOV)
+            if(UMF_USE_COVERAGE)
                 if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
                     message(
-                        FATAL_ERROR "To use gcov, the build type must be Debug")
+                        FATAL_ERROR
+                            "To use the --coverage flag, the build type must be Debug"
+                    )
                 endif()
                 target_link_options(${name} PRIVATE --coverage)
             endif()
@@ -266,17 +312,17 @@ function(add_umf_target_link_options name)
         target_link_options(
             ${name}
             PRIVATE
-            /DYNAMICBASE
-            /HIGHENTROPYVA
+            LINKER:/DYNAMICBASE
+            LINKER:/HIGHENTROPYVA
             $<$<C_COMPILER_ID:MSVC>:/DEPENDENTLOADFLAG:0x2000>
             $<$<CXX_COMPILER_ID:MSVC>:/DEPENDENTLOADFLAG:0x2000>
-            /NXCOMPAT)
+            LINKER:/NXCOMPAT)
     endif()
 endfunction()
 
 function(add_umf_target_exec_options name)
     if(MSVC)
-        target_link_options(${name} PRIVATE /ALLOWISOLATION)
+        target_link_options(${name} PRIVATE LINKER:/ALLOWISOLATION)
     endif()
 endfunction()
 
@@ -333,7 +379,7 @@ function(add_umf_library)
 
         if(WINDOWS)
             target_link_options(${ARG_NAME} PRIVATE
-                                /DEF:${ARG_WINDOWS_DEF_FILE})
+                                LINKER:/DEF:${ARG_WINDOWS_DEF_FILE})
         elseif(LINUX)
             target_link_options(${ARG_NAME} PRIVATE
                                 "-Wl,--version-script=${ARG_LINUX_MAP_FILE}")
@@ -345,8 +391,10 @@ function(add_umf_library)
     target_include_directories(
         ${ARG_NAME}
         PRIVATE ${UMF_CMAKE_SOURCE_DIR}/include
+                ${UMF_CMAKE_SOURCE_DIR}/src
                 ${UMF_CMAKE_SOURCE_DIR}/src/utils
-                ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc)
+                ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc
+                ${UMF_CMAKE_SOURCE_DIR}/src/coarse)
     add_umf_target_compile_options(${ARG_NAME})
     add_umf_target_link_options(${ARG_NAME})
 endfunction()
@@ -417,12 +465,3 @@ macro(add_sanitizer_flag flag)
 
     set(CMAKE_REQUIRED_FLAGS ${SAVED_CMAKE_REQUIRED_FLAGS})
 endmacro()
-
-function(add_optional_symbol symbol)
-    set(UMF_OPTIONAL_SYMBOLS_WINDOWS
-        "${UMF_OPTIONAL_SYMBOLS_WINDOWS} \n    ${symbol}"
-        PARENT_SCOPE)
-    set(UMF_OPTIONAL_SYMBOLS_LINUX
-        "${UMF_OPTIONAL_SYMBOLS_LINUX} \n    ${symbol};"
-        PARENT_SCOPE)
-endfunction()
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 000000000..737bb1259
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,32 @@
+# Documentation
+
+To generate HTML documentation, run the `generate_docs.py` script from any sub-directory of the repository (most likely `build`).
+To display the proper version of UMF in the documentation title, set the `UMF_VERSION` variable before running the script.
+
+```bash
+cd build
+$ UMF_VERSION=<your version, e.g. "0.12.1"> python ../docs/generate_docs.py
+```
+
+Documentation can also be built using the build target 'docs' (see details below).
+
+This script will create `./docs_build` sub-directory, where the intermediate and final files
+will be created. HTML docs will be in the `./docs_build/generated/html` directory.
+
+## make docs
+
+To run documentation generation via build target use CMake commands below.
+To enable this target, python executable (in required version) has to be found in the system.
+
+```bash
+cmake -B build
+cmake --build build --target docs
+```
+
+## Requirements
+
+Script to generate HTML docs requires:
+
+* [Doxygen](http://www.doxygen.nl/) at least v1.9.1
+* [Python](https://www.python.org/downloads/) at least v3.8
+* and python pip requirements, as defined in `third_party/requirements.txt`
diff --git a/scripts/assets/images/intro_architecture.png b/docs/assets/images/intro_architecture.png
similarity index 100%
rename from scripts/assets/images/intro_architecture.png
rename to docs/assets/images/intro_architecture.png
diff --git a/scripts/docs_config/Doxyfile b/docs/config/Doxyfile
similarity index 99%
rename from scripts/docs_config/Doxyfile
rename to docs/config/Doxyfile
index 43ff2a603..9c520d46c 100644
--- a/scripts/docs_config/Doxyfile
+++ b/docs/config/Doxyfile
@@ -445,7 +445,7 @@ INLINE_SIMPLE_STRUCTS  = NO
 # types are typedef'ed and only the typedef is referenced, never the tag name.
 # The default value is: NO.
 
-TYPEDEF_HIDES_STRUCT   = NO
+TYPEDEF_HIDES_STRUCT   = YES
 
 # The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
 # cache is used to resolve symbols given their name and scope. Since this can be
@@ -466,7 +466,7 @@ LOOKUP_CACHE_SIZE      = 0
 # than 0 to get more control over the balance between CPU load and processing
 # speed. At this moment only the input processing can be done using multiple
 # threads. Since this is still an experimental feature the default is set to 1,
-# which efficively disables parallel processing. Please report any issues you
+# which effectively disables parallel processing. Please report any issues you
 # encounter. Generating dot graphs in parallel is controlled by the
 # DOT_NUM_THREADS setting.
 # Minimum value: 0, maximum value: 32, default value: 1.
@@ -2058,7 +2058,7 @@ GENERATE_XML           = YES
 # The default directory is: xml.
 # This tag requires that the tag GENERATE_XML is set to YES.
 
-XML_OUTPUT             = ../docs/xml
+XML_OUTPUT             = docs_build/doxyxml
 
 # If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
 # listings (including syntax highlighting and cross-referencing information) to
diff --git a/scripts/docs_config/api.rst b/docs/config/api.rst
similarity index 60%
rename from scripts/docs_config/api.rst
rename to docs/config/api.rst
index 1233f59f7..97e664d97 100644
--- a/scripts/docs_config/api.rst
+++ b/docs/config/api.rst
@@ -58,6 +58,9 @@ supported by the Proxy Pool.
 
 Scalable Pool
 ------------------------------------------
+
+A oneTBB-based memory pool manager.
+
 .. doxygenfile:: pool_scalable.h
     :sections: define enum typedef func var
 
@@ -80,6 +83,14 @@ and operate on the provider.
 .. doxygenfile:: memory_provider.h
     :sections: define enum typedef func var
 
+Fixed Memory Provider
+------------------------------------------
+
+A memory provider that can provide memory from a given preallocated buffer.
+
+.. doxygenfile:: provider_fixed_memory.h
+    :sections: define enum typedef func var
+
 OS Memory Provider
 ------------------------------------------
 
@@ -96,6 +107,30 @@ A memory provider that provides memory from L0 device.
 .. doxygenfile:: provider_level_zero.h
     :sections: define enum typedef func var
 
+CUDA Provider
+------------------------------------------
+
+A memory provider that provides memory from CUDA device.
+
+.. doxygenfile:: provider_cuda.h
+    :sections: define enum typedef func var
+
+DevDax Memory Provider
+------------------------------------------
+
+A memory provider that provides memory from a device DAX (a character device file like /dev/daxX.Y).
+
+.. doxygenfile:: provider_devdax_memory.h
+    :sections: define enum typedef func var
+
+File Memory Provider
+------------------------------------------
+
+A memory provider that provides memory by mapping a regular, extendable file.
+
+.. doxygenfile:: provider_file_memory.h
+    :sections: define enum typedef func var
+
 Memspace
 ==========================================
 
@@ -116,6 +151,15 @@ Mempolicy
 .. doxygenfile:: mempolicy.h
     :sections: define enum typedef func
 
+Memtarget
+==========================================
+
+TODO: Add general information about memtargets.
+
+Memtarget
+------------------------------------------
+.. doxygenfile:: memtarget.h
+    :sections: define enum typedef func
 
 Inter-Process Communication
 ==========================================
@@ -124,6 +168,26 @@ IPC API allows retrieving IPC handles for the memory buffers allocated from
 UMF memory pools. The memory provider used by the pool should support IPC 
 operations for this API to work. Otherwise IPC APIs return an error.
 
+IPC caching
+------------------------------------------
+
+UMF employs IPC caching to avoid multiple IPC handles being created for the same 
+coarse-grain memory region allocated by the memory provider. UMF guarantees that 
+for each coarse-grain memory region allocated by the memory provider, only one 
+IPC handle is created when the :any:`umfGetIPCHandle` function is called. All 
+subsequent calls to the :any:`umfGetIPCHandle` function for the pointer to the 
+same memory region will return the entry from the cache.
+
+The same is true for the :any:`umfOpenIPCHandle` function. The actual mapping
+of the IPC handle to the virtual address space is created only once, and all
+subsequent calls to open the same IPC handle will return the entry from the cache.
+The size of the cache for opened IPC handles is controlled by the ``UMF_MAX_OPENED_IPC_HANDLES``
+environment variable. By default, the cache size is unlimited. However, if the environment 
+variable is set and the cache size exceeds the limit, old items will be evicted. UMF tracks 
+the ref count for each entry in the cache and can evict only items with the ref count equal to 0. 
+The ref count is increased when the :any:`umfOpenIPCHandle` function is called and decreased 
+when the :any:`umfCloseIPCHandle` function is called for the corresponding IPC handle.
+
 .. _ipc-api:
 
 IPC API
diff --git a/scripts/docs_config/conf.py b/docs/config/conf.py
similarity index 77%
rename from scripts/docs_config/conf.py
rename to docs/config/conf.py
index 13a975983..ae698ba98 100644
--- a/scripts/docs_config/conf.py
+++ b/docs/config/conf.py
@@ -1,3 +1,5 @@
+import os
+
 # Configuration file for the Sphinx documentation builder.
 #
 # This file only contains a selection of the most common options. For a full
@@ -18,19 +20,26 @@
 # -- Project information -----------------------------------------------------
 
 project = "Intel Unified Memory Framework"
-copyright = "2023-2024, Intel"
+copyright = "2023-2025, Intel"
 author = "Intel"
 
 # The full version, including alpha/beta/rc tags
-release = "0.9.1"
-
+release = os.getenv("UMF_VERSION", "")
+print(
+    f"UMF_VERSION used in docs: {release}"
+    if release != ""
+    else "please set UMF_VERSION environment variable before running this script"
+)
 
 # -- General configuration ---------------------------------------------------
 
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
-extensions = ["breathe"]
+extensions = ["breathe", "sphinxcontrib.spelling"]
+
+spelling_show_suggestions = True
+spelling_word_list_filename = "spelling_exceptions.txt"
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
@@ -49,7 +58,9 @@
 # -- Extension configuration -------------------------------------------------
 
 # -- Options for breathe extension -------------------------------------------
-breathe_projects = {project: "../../docs/xml"}
+# 'doxyxml' dir is generated with Doxygen; it's supposed to be in a directory
+# one above the config directory.
+breathe_projects = {project: "../doxyxml"}
 breathe_default_project = project
 breathe_show_include = False
 breathe_default_members = ("members", "undoc-members")
diff --git a/scripts/docs_config/examples.rst b/docs/config/examples.rst
similarity index 76%
rename from scripts/docs_config/examples.rst
rename to docs/config/examples.rst
index 4098583a6..4eeea6aa9 100644
--- a/scripts/docs_config/examples.rst
+++ b/docs/config/examples.rst
@@ -31,11 +31,20 @@ the OS Memory Provider API::
 
     #include "umf/providers/provider_os_memory.h"
 
-Get a pointer to the OS memory provider operations struct and
-a copy of default parameters::
+Get a pointer to the OS memory provider operations struct::
 
     umf_memory_provider_ops_t *provider_ops = umfOsMemoryProviderOps();
-    umf_os_memory_provider_params_t params = umfOsMemoryProviderParamsDefault();
+
+Get a default OS memory provider parameters. The handle to the parameters object
+is returned by the :any:`umfOsMemoryProviderParamsCreate` function::
+
+    umf_os_memory_provider_params_handle_t params = NULL;
+
+    res = umfOsMemoryProviderParamsCreate(&params);
+    if (res != UMF_RESULT_SUCCESS) {
+        printf("Failed to create OS memory provider params!\n");
+        return -1;
+    }
 
 The handle to created memory ``provider`` object is returned as the last argument
 of :any:`umfMemoryProviderCreate`::
@@ -43,7 +52,10 @@ of :any:`umfMemoryProviderCreate`::
     umf_memory_provider_handle_t provider;
     umfMemoryProviderCreate(provider_ops, &params, &provider);
 
-With this handle we can allocate a chunk of memory, call :any:`umfMemoryProviderAlloc`::
+The ``params`` object can be destroyed after the provider is created::
+    umfOsMemoryProviderParamsDestroy(params);
+
+With the ``provider`` handle we can allocate a chunk of memory, call :any:`umfMemoryProviderAlloc`::
 
     size_t alloc_size = 5000;
     size_t alignment = 0;
@@ -111,7 +123,23 @@ Freeing memory is as easy as can be::
 GPU shared memory
 ==============================================================================
 
-You can find the full example code in the `examples/gpu_shared_memory/gpu_shared_memory.c`_ file
+You can find the full example code in the `examples/level_zero_shared_memory/level_zero_shared_memory.c`_ file
+or `examples/cuda_shared_memory/cuda_shared_memory.c`_ file in the UMF repository.
+
+TODO
+
+Memspace
+==============================================================================
+
+You can find the full examples code in the `examples/memspace`_ directory
+in the UMF repository.
+
+TODO
+
+Custom memory provider
+==============================================================================
+
+You can find the full examples code in the `examples/custom_file_provider/custom_file_provider.c`_ file
 in the UMF repository.
 
 TODO
@@ -150,7 +178,7 @@ by a different library and the caller of the :any:`umfGetIPCHandle` function may
 The :any:`umfGetIPCHandle` function returns the IPC handle and its size. The IPC handle is a byte-copyable opaque
 data structure. The :any:`umf_ipc_handle_t` type is defined as a pointer to a byte array. The size of the handle
 might be different for different memory provider types. The code snippet below demonstrates how the IPC handle can
-be serialized for marshalling purposes.
+be serialized for marshaling purposes.
 
 .. code-block:: c
 
@@ -166,12 +194,15 @@ to another process it can be opened by the :any:`umfOpenIPCHandle` function.
 
 .. code-block:: c
 
+    umf_ipc_handler_handle_t ipc_handler = 0;
+    umf_result = umfPoolGetIPCHandler(consumer_pool, &ipc_handler);
+
     void *mapped_buf = NULL;
-    umf_result = umfOpenIPCHandle(consumer_pool, ipc_handle, &mapped_buf);
+    umf_result = umfOpenIPCHandle(ipc_handler, ipc_handle, &mapped_buf);
 
-The :any:`umfOpenIPCHandle` function requires the memory pool handle and the IPC handle as input parameters. It maps
+The :any:`umfOpenIPCHandle` function requires the IPC handler and the IPC handle as input parameters. The IPC handler maps
 the handle to the current process address space and returns the pointer to the same memory region that was allocated
-in the producer process.
+in the producer process. To retrieve the IPC handler, the :any:`umfPoolGetIPCHandler` function is used.
 
 .. note::
     The virtual addresses of the memory region referred to by the IPC handle may not be the same in the producer and consumer processes.
@@ -193,8 +224,11 @@ function is called on the consumer side. The memory mappings on the consumer sid
 the :any:`umfCloseIPCHandle` function is called.
 
 .. _examples/basic/basic.c: https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/basic/basic.c
-.. _examples/gpu_shared_memory/gpu_shared_memory.c: https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/gpu_shared_memory/gpu_shared_memory.c
+.. _examples/level_zero_shared_memory/level_zero_shared_memory.c: https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/level_zero_shared_memory/level_zero_shared_memory.c
+.. _examples/cuda_shared_memory/cuda_shared_memory.c: https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/cuda_shared_memory/cuda_shared_memory.c
 .. _examples/ipc_level_zero/ipc_level_zero.c: https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/ipc_level_zero/ipc_level_zero.c
+.. _examples/custom_file_provider/custom_file_provider.c: https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/custom_file_provider/custom_file_provider.c
+.. _examples/memspace: https://github.com/oneapi-src/unified-memory-framework/blob/main/examples/memspace/
 .. _README: https://github.com/oneapi-src/unified-memory-framework/blob/main/README.md#memory-pool-managers
 .. _umf/ipc.h: https://github.com/oneapi-src/unified-memory-framework/blob/main/include/umf/ipc.h
 .. _provider_os_memory.h: https://github.com/oneapi-src/unified-memory-framework/blob/main/include/umf/providers/provider_os_memory.h
diff --git a/scripts/docs_config/glossary.rst b/docs/config/glossary.rst
similarity index 100%
rename from scripts/docs_config/glossary.rst
rename to docs/config/glossary.rst
diff --git a/scripts/docs_config/index.rst b/docs/config/index.rst
similarity index 100%
rename from scripts/docs_config/index.rst
rename to docs/config/index.rst
diff --git a/scripts/docs_config/introduction.rst b/docs/config/introduction.rst
similarity index 99%
rename from scripts/docs_config/introduction.rst
rename to docs/config/introduction.rst
index d47439047..f90b26b41 100644
--- a/scripts/docs_config/introduction.rst
+++ b/docs/config/introduction.rst
@@ -99,7 +99,7 @@ defined pool allocators if they implement the UMF interface.
 Memory Pools
 ============
 
-A memory pool consists of a pool allocator and a memory provider instancies 
+A memory pool consists of a pool allocator and a memory provider instances
 along with their properties and allocation policies. Memory pools are used by 
 the :ref:`allocation API <allocation API>` as a first argument. There is also a possibility to 
 retrieve a memory pool from an existing memory pointer that points to a memory 
diff --git a/docs/config/spelling_exceptions.txt b/docs/config/spelling_exceptions.txt
new file mode 100644
index 000000000..d4e40a3ec
--- /dev/null
+++ b/docs/config/spelling_exceptions.txt
@@ -0,0 +1,74 @@
+addr
+allocatable
+allocator
+allocators
+calloc
+CXL
+copyable
+customizable
+daxX
+deallocation
+deallocating
+deallocations
+Devdax
+dev
+Globals
+hMemtarget
+hPool
+hProvider
+highPtr
+io
+interprocess
+ipc
+jemalloc
+lowPtr
+malloc
+maxnode
+mem
+mempolicies
+mempolicy
+Mempolicy
+memspace
+Memspace
+memspaces
+Memtarget
+memtarget
+memtargets
+middleware
+multithreading
+Nodemask
+nodemask
+numa
+oneAPI
+oneTBB
+os
+params
+partList
+pid
+poolable
+preallocated
+providerIpcData
+providential
+ptr
+realloc
+Scalable
+scalable
+stdout
+Tiering
+tiering
+topologies
+umf
+umfGetIPCHandle
+umfMemoryProviderAlloc
+umfMemoryProviderGetLastNativeError
+umfMemoryProviderOpenIPCHandle
+umfOsMemoryProviderParamsDestroy
+umfPool
+umfPoolCalloc
+umfPoolDestroy
+umfPoolGetTag
+umfPoolMallocUsableSize
+umfPoolRealloc
+umfMemspaceUserFilter
+umfMemspaceMemtargetAdd
+unfreed
\ No newline at end of file
diff --git a/scripts/generate_docs.py b/docs/generate_docs.py
similarity index 71%
rename from scripts/generate_docs.py
rename to docs/generate_docs.py
index d5b2a0128..1697eacfe 100644
--- a/scripts/generate_docs.py
+++ b/docs/generate_docs.py
@@ -6,17 +6,20 @@
 """
 
 from pathlib import Path
-from shutil import rmtree
+from shutil import rmtree, copytree
 import subprocess  # nosec B404
 import time
 
 
 def _check_cwd() -> None:
-    script_path = Path(__file__).resolve().parent
     cwd = Path.cwd()
-    if script_path != cwd:
+    include_dir = Path(cwd, "../include")
+    # Verify if include dir is one level up (as defined in Doxyfile)
+    if not include_dir.exists():
         print(
-            f"{__file__} script has to be run from the 'scripts' directory. Terminating..."
+            f"Include directory {include_dir.resolve()} not found! "
+            "Please run this script from <repo_root_dir>/build!",
+            flush=True,
         )
         exit(1)
 
@@ -66,8 +69,17 @@ def _generate_html(config_path: Path, docs_path: Path) -> None:
 
 def main() -> None:
     _check_cwd()
-    config_path = Path("docs_config").resolve()
-    docs_path = Path("..", "docs").resolve()
+
+    script_dir = Path(__file__).resolve().parent
+    docs_build_path = Path("docs_build").resolve()
+
+    # Sphinx and breathe require access to a Doxygen generated dir ('doxyxml')
+    # so we copy the whole content of the 'docs' dir to the build dir.
+    copytree(Path(script_dir), docs_build_path, dirs_exist_ok=True)
+
+    config_path = Path(docs_build_path, "config").resolve()
+    docs_path = Path(docs_build_path, "generated").resolve()
+
     start = time.time()
     _prepare_docs_dir(docs_path)
     _generate_xml(config_path, docs_path)
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 918dc2809..91f47901c 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -18,7 +18,7 @@ set(EXAMPLE_NAME umf_example_basic)
 add_umf_executable(
     NAME ${EXAMPLE_NAME}
     SRCS basic/basic.c
-    LIBS umf ${LIBHWLOC_LIBRARIES})
+    LIBS umf ${UMF_HWLOC_NAME})
 
 target_include_directories(
     ${EXAMPLE_NAME} PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/utils
@@ -41,23 +41,58 @@ if(UMF_POOL_SCALABLE_ENABLED)
     endif()
 endif()
 
-if(UMF_BUILD_GPU_EXAMPLES
-   AND UMF_BUILD_LIBUMF_POOL_DISJOINT
-   AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
-    set(EXAMPLE_NAME umf_example_gpu_shared_memory)
+if(UMF_BUILD_GPU_EXAMPLES AND UMF_LEVEL_ZERO_ENABLED)
+    set(EXAMPLE_NAME umf_example_level_zero_shared_memory)
 
     add_umf_executable(
         NAME ${EXAMPLE_NAME}
-        SRCS gpu_shared_memory/gpu_shared_memory.c
-        LIBS disjoint_pool ze_loader umf)
+        SRCS level_zero_shared_memory/level_zero_shared_memory.c
+             common/examples_level_zero_helpers.c
+        LIBS ze_loader umf)
 
     target_include_directories(
         ${EXAMPLE_NAME}
-        PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/utils
+        PRIVATE ${LEVEL_ZERO_INCLUDE_DIRS} ${UMF_CMAKE_SOURCE_DIR}/src/utils
                 ${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}
+        COMMAND ${EXAMPLE_NAME}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+    set_tests_properties(${EXAMPLE_NAME} PROPERTIES LABELS "example")
+
+    if(WINDOWS)
+        # append PATH to DLLs
+        set_property(TEST ${EXAMPLE_NAME} PROPERTY ENVIRONMENT_MODIFICATION
+                                                   "${DLL_PATH_LIST}")
+    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_CUDA_ENABLED)
+    set(EXAMPLE_NAME umf_example_cuda_shared_memory)
+
+    add_umf_executable(
+        NAME ${EXAMPLE_NAME}
+        SRCS cuda_shared_memory/cuda_shared_memory.c
+        LIBS cuda umf)
+
+    target_include_directories(
+        ${EXAMPLE_NAME}
+        PRIVATE ${CUDA_INCLUDE_DIRS} ${UMF_CMAKE_SOURCE_DIR}/src/utils
+                ${UMF_CMAKE_SOURCE_DIR}/include
+                ${UMF_CMAKE_SOURCE_DIR}/examples/common)
+
+    target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS}
+                            ${CUDA_LIBRARY_DIRS})
 
     add_test(
         NAME ${EXAMPLE_NAME}
@@ -74,23 +109,22 @@ if(UMF_BUILD_GPU_EXAMPLES
 else()
     message(
         STATUS
-            "GPU shared memory example requires UMF_BUILD_GPU_EXAMPLES, "
-            "UMF_BUILD_LEVEL_ZERO_PROVIDER and UMF_BUILD_LIBUMF_POOL_DISJOINT "
-            "to be turned ON - skipping")
+            "GPU CUDA shared memory example requires UMF_BUILD_GPU_EXAMPLES and UMF_BUILD_CUDA_PROVIDER to be turned ON and installed CUDA libraries - skipping"
+    )
 endif()
 
 # TODO: it looks like there is some problem with IPC implementation in Level
 # Zero on windows
 if(UMF_BUILD_GPU_EXAMPLES
-   AND UMF_BUILD_LIBUMF_POOL_DISJOINT
-   AND UMF_BUILD_LEVEL_ZERO_PROVIDER
+   AND UMF_LEVEL_ZERO_ENABLED
    AND LINUX)
     set(EXAMPLE_NAME umf_example_ipc_level_zero)
 
     add_umf_executable(
         NAME ${EXAMPLE_NAME}
         SRCS ipc_level_zero/ipc_level_zero.c
-        LIBS disjoint_pool ze_loader umf)
+             common/examples_level_zero_helpers.c
+        LIBS ze_loader umf)
 
     target_include_directories(
         ${EXAMPLE_NAME}
@@ -98,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}
@@ -115,7 +150,7 @@ if(UMF_BUILD_GPU_EXAMPLES
 else()
     message(
         STATUS
-            "IPC Level 0 example requires UMF_BUILD_GPU_EXAMPLES, UMF_BUILD_LEVEL_ZERO_PROVIDER and UMF_BUILD_LIBUMF_POOL_DISJOINT to be turned ON - skipping"
+            "IPC Level Zero example requires UMF_BUILD_GPU_EXAMPLES and UMF_BUILD_LEVEL_ZERO_PROVIDER to be turned ON - skipping"
     )
 endif()
 
@@ -134,7 +169,8 @@ function(build_umf_ipc_example name)
             ${EX_NAME} PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/utils
                                ${UMF_CMAKE_SOURCE_DIR}/include)
 
-        target_link_directories(${EX_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS})
+        target_link_directories(${EX_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS}
+                                ${TBB_LIBRARY_DIRS})
     endforeach(loop_var)
 endfunction()
 
@@ -150,12 +186,13 @@ function(add_umf_ipc_example script)
         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
     set_tests_properties(${EXAMPLE_NAME} PROPERTIES LABELS "example")
+    set_tests_properties(${EXAMPLE_NAME} PROPERTIES TIMEOUT 60)
     if(NOT UMF_TESTS_FAIL_ON_SKIP)
         set_tests_properties(${EXAMPLE_NAME} PROPERTIES SKIP_RETURN_CODE 125)
     endif()
 endfunction()
 
-if(LINUX)
+if(LINUX AND UMF_POOL_SCALABLE_ENABLED)
     build_umf_ipc_example(ipc_ipcapi)
     add_umf_ipc_example(ipc_ipcapi_anon_fd)
     add_umf_ipc_example(ipc_ipcapi_shm)
@@ -165,3 +202,99 @@ else()
             "IPC examples with UMF pool API are supported on Linux only - skipping"
     )
 endif()
+
+if(LINUX)
+    set(UMF_TEST_SKIP_RETURN_CODE 125)
+
+    set(EXAMPLE_NAME umf_example_memspace_numa)
+
+    add_umf_executable(
+        NAME ${EXAMPLE_NAME}
+        SRCS memspace_numa/memspace_numa.c
+        LIBS umf ${UMF_HWLOC_NAME} numa)
+
+    target_include_directories(
+        ${EXAMPLE_NAME}
+        PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/utils
+                ${UMF_CMAKE_SOURCE_DIR}/include
+                ${UMF_CMAKE_SOURCE_DIR}/examples/common)
+
+    target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS})
+
+    add_test(
+        NAME ${EXAMPLE_NAME}
+        COMMAND ${EXAMPLE_NAME}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+    set_tests_properties(${EXAMPLE_NAME} PROPERTIES
+                         SKIP_RETURN_CODE ${UMF_TEST_SKIP_RETURN_CODE})
+
+    set(EXAMPLE_NAME umf_example_memspace_hmat)
+
+    add_umf_executable(
+        NAME ${EXAMPLE_NAME}
+        SRCS memspace_hmat/memspace_hmat.c
+        LIBS umf ${UMF_HWLOC_NAME} numa)
+
+    target_include_directories(
+        ${EXAMPLE_NAME}
+        PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/utils
+                ${UMF_CMAKE_SOURCE_DIR}/include
+                ${UMF_CMAKE_SOURCE_DIR}/examples/common)
+
+    target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS})
+
+    add_test(
+        NAME ${EXAMPLE_NAME}
+        COMMAND ${EXAMPLE_NAME}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+    set_tests_properties(${EXAMPLE_NAME} PROPERTIES
+                         SKIP_RETURN_CODE ${UMF_TEST_SKIP_RETURN_CODE})
+
+    if(UMF_POOL_SCALABLE_ENABLED)
+        set(EXAMPLE_NAME umf_example_custom_file_provider)
+
+        add_umf_executable(
+            NAME ${EXAMPLE_NAME}
+            SRCS custom_file_provider/custom_file_provider.c
+            LIBS umf ${UMF_HWLOC_NAME})
+
+        target_include_directories(
+            ${EXAMPLE_NAME} PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/utils
+                                    ${UMF_CMAKE_SOURCE_DIR}/include)
+
+        target_link_directories(${EXAMPLE_NAME} PRIVATE
+                                ${LIBHWLOC_LIBRARY_DIRS} ${TBB_LIBRARY_DIRS})
+
+        add_test(
+            NAME ${EXAMPLE_NAME}
+            COMMAND ${EXAMPLE_NAME}
+            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    endif()
+
+    if(UMF_POOL_JEMALLOC_ENABLED)
+        set(EXAMPLE_NAME umf_example_dram_and_fsdax)
+
+        add_umf_executable(
+            NAME ${EXAMPLE_NAME}
+            SRCS dram_and_fsdax/dram_and_fsdax.c
+            LIBS umf)
+
+        target_link_options(${EXAMPLE_NAME} PRIVATE "-Wl,--no-as-needed,-ldl")
+
+        target_link_directories(
+            ${EXAMPLE_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS}
+            ${JEMALLOC_LIBRARY_DIRS})
+
+        add_test(
+            NAME ${EXAMPLE_NAME}
+            COMMAND ${EXAMPLE_NAME}
+            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    endif()
+else()
+    message(
+        STATUS "Memspace examples API are supported on Linux only - skipping")
+    message(
+        STATUS "File provider example is supported on Linux only - skipping")
+endif()
diff --git a/examples/README.md b/examples/README.md
index e7823347e..70d114a63 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -24,7 +24,7 @@ cleans up and exits with an error status.
 ### Requirements
 * Level Zero headers and libraries
 * compatible GPU with installed driver
-* set UMF_BUILD_GPU_EXAMPLES, UMF_BUILD_LIBUMF_POOL_DISJOINT and UMF_BUILD_LEVEL_ZERO_PROVIDER CMake configuration flags to ON
+* set UMF_BUILD_GPU_EXAMPLES and UMF_BUILD_LEVEL_ZERO_PROVIDER CMake configuration flags to ON
 
 ## IPC example with Level Zero memory provider
 This example demonstrates how to use UMF IPC API. The example creates two
@@ -35,7 +35,7 @@ and build this example Level Zero development package should be installed.
 ### Requirements
 * Level Zero headers and libraries
 * compatible GPU with installed driver
-* set UMF_BUILD_GPU_EXAMPLES, UMF_BUILD_LIBUMF_POOL_DISJOINT and UMF_BUILD_LEVEL_ZERO_PROVIDER CMake configuration flags to ON
+* set UMF_BUILD_GPU_EXAMPLES and UMF_BUILD_LEVEL_ZERO_PROVIDER CMake configuration flags to ON
 
 ## IPC example with shared memory
 This example also demonstrates how to use UMF IPC API. The example creates two
diff --git a/examples/basic/basic.c b/examples/basic/basic.c
index d886c4af8..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,11 +22,18 @@ 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();
-    umf_os_memory_provider_params_t params = umfOsMemoryProviderParamsDefault();
+    const umf_memory_provider_ops_t *provider_ops = umfOsMemoryProviderOps();
+    umf_os_memory_provider_params_handle_t params = NULL;
     umf_memory_provider_handle_t provider;
 
-    res = umfMemoryProviderCreate(provider_ops, &params, &provider);
+    res = umfOsMemoryProviderParamsCreate(&params);
+    if (res != UMF_RESULT_SUCCESS) {
+        printf("Failed to create OS memory provider params!\n");
+        return -1;
+    }
+
+    res = umfMemoryProviderCreate(provider_ops, params, &provider);
+    umfOsMemoryProviderParamsDestroy(params);
     if (res != UMF_RESULT_SUCCESS) {
         printf("Failed to create a memory provider!\n");
         return -1;
@@ -62,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
new file mode 100644
index 000000000..d41ddaf77
--- /dev/null
+++ b/examples/cmake/FindCUDA.cmake
@@ -0,0 +1,36 @@
+# Copyright (C) 2024-2025 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+message(STATUS "Checking for module 'cuda' using find_library()")
+
+find_library(CUDA_LIBRARY NAMES libcuda cuda)
+set(CUDA_LIBRARIES ${CUDA_LIBRARY})
+
+get_filename_component(CUDA_LIB_DIR ${CUDA_LIBRARIES} DIRECTORY)
+set(CUDA_LIBRARY_DIRS ${CUDA_LIB_DIR})
+
+if(WINDOWS)
+    find_file(CUDA_DLL NAMES "nvcuda.dll")
+    get_filename_component(CUDA_DLL_DIR ${CUDA_DLL} DIRECTORY)
+    set(CUDA_DLL_DIRS ${CUDA_DLL_DIR})
+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}")
+    message(STATUS "    CUDA_LIBRARY_DIRS = ${CUDA_LIBRARY_DIRS}")
+    if(WINDOWS)
+        message(STATUS "    CUDA_DLL_DIRS = ${CUDA_DLL_DIRS}")
+    endif()
+else()
+    set(MSG_NOT_FOUND "cuda NOT found (set CMAKE_PREFIX_PATH to point the "
+                      "location)")
+    if(CUDA_FIND_REQUIRED)
+        message(FATAL_ERROR ${MSG_NOT_FOUND})
+    else()
+        message(WARNING ${MSG_NOT_FOUND})
+    endif()
+endif()
diff --git a/examples/cmake/FindJEMALLOC.cmake b/examples/cmake/FindJEMALLOC.cmake
new file mode 100644
index 000000000..6cd1ffede
--- /dev/null
+++ b/examples/cmake/FindJEMALLOC.cmake
@@ -0,0 +1,55 @@
+# Copyright (C) 2024-2025 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+message(
+    STATUS "Looking for the static 'libjemalloc.a' library using find_library()"
+)
+
+find_library(JEMALLOC_LIBRARY NAMES libjemalloc.a jemalloc.a)
+set(JEMALLOC_LIBRARIES ${JEMALLOC_LIBRARY})
+
+get_filename_component(JEMALLOC_LIB_DIR ${JEMALLOC_LIBRARIES} DIRECTORY)
+set(JEMALLOC_LIBRARY_DIRS ${JEMALLOC_LIB_DIR})
+
+find_file(JEMALLOC_HEADER NAMES "jemalloc/jemalloc.h")
+if(JEMALLOC_HEADER)
+    get_filename_component(JEMALLOC_INCLUDE_DIR_TBB ${JEMALLOC_HEADER}
+                           DIRECTORY)
+    get_filename_component(JEMALLOC_INCLUDE_DIR ${JEMALLOC_INCLUDE_DIR_TBB}
+                           DIRECTORY)
+    set(JEMALLOC_INCLUDE_DIRS ${JEMALLOC_INCLUDE_DIR})
+else()
+    set(MSG_NOT_FOUND "<jemalloc/jemalloc.h> header NOT found "
+                      "(set CMAKE_PREFIX_PATH to point the location)")
+    if(JEMALLOC_FIND_REQUIRED)
+        message(FATAL_ERROR ${MSG_NOT_FOUND})
+    else()
+        message(WARNING ${MSG_NOT_FOUND})
+    endif()
+endif()
+
+if(WINDOWS)
+    find_file(JEMALLOC_DLL NAMES "bin/jemalloc.dll" "jemalloc.dll")
+    get_filename_component(JEMALLOC_DLL_DIR ${JEMALLOC_DLL} DIRECTORY)
+    set(JEMALLOC_DLL_DIRS ${JEMALLOC_DLL_DIR})
+endif()
+
+if(JEMALLOC_LIBRARY)
+    set(JEMALLOC_FOUND TRUE)
+    message(STATUS "  Found jemalloc using find_library()")
+    message(STATUS "    JEMALLOC_LIBRARIES = ${JEMALLOC_LIBRARIES}")
+    message(STATUS "    JEMALLOC_INCLUDE_DIRS = ${JEMALLOC_INCLUDE_DIRS}")
+    message(STATUS "    JEMALLOC_LIBRARY_DIRS = ${JEMALLOC_LIBRARY_DIRS}")
+    if(WINDOWS)
+        message(STATUS "    JEMALLOC_DLL_DIRS = ${JEMALLOC_DLL_DIRS}")
+    endif()
+else()
+    set(MSG_NOT_FOUND
+        "jemalloc NOT found (set CMAKE_PREFIX_PATH to point the location)")
+    if(JEMALLOC_FIND_REQUIRED)
+        message(FATAL_ERROR ${MSG_NOT_FOUND})
+    else()
+        message(WARNING ${MSG_NOT_FOUND})
+    endif()
+endif()
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
new file mode 100644
index 000000000..4cf40b60d
--- /dev/null
+++ b/examples/cmake/FindLIBNUMA.cmake
@@ -0,0 +1,21 @@
+# Copyright (C) 2024-2025 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+message(STATUS "Checking for module 'libnuma' using find_library()")
+
+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
+        "libnuma NOT found (set CMAKE_PREFIX_PATH to point the location)")
+    if(LIBNUMA_FIND_REQUIRED)
+        message(FATAL_ERROR ${MSG_NOT_FOUND})
+    else()
+        message(WARNING ${MSG_NOT_FOUND})
+    endif()
+endif()
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/common/utils_level_zero.h b/examples/common/examples_level_zero_helpers.c
similarity index 95%
rename from examples/common/utils_level_zero.h
rename to examples/common/examples_level_zero_helpers.c
index 46f892278..5e00838c2 100644
--- a/examples/common/utils_level_zero.h
+++ b/examples/common/examples_level_zero_helpers.c
@@ -7,21 +7,12 @@
  *
  */
 
-#ifndef UMF_EXAMPLE_UTILS_LEVEL_ZERO_H
-#define UMF_EXAMPLE_UTILS_LEVEL_ZERO_H
-
 #include <stdio.h>
 #include <stdlib.h>
 
-// To use the Level Zero API, the Level Zero SDK has to be installed
-// on the system
-#ifdef _WIN32
-#include <ze_api.h>
-#else
-#include <level_zero/ze_api.h>
-#endif
+#include "examples_level_zero_helpers.h"
 
-static int init_level_zero(void) {
+int init_level_zero(void) {
     ze_init_flag_t flags = ZE_INIT_FLAG_GPU_ONLY;
     ze_result_t result = zeInit(flags);
     if (result != ZE_RESULT_SUCCESS) {
@@ -118,8 +109,7 @@ static inline int get_devices(ze_driver_handle_t driver, uint32_t *devices_num_,
     return ret;
 }
 
-static inline int find_driver_with_gpu(uint32_t *driver_idx,
-                                       ze_driver_handle_t *driver_) {
+int find_driver_with_gpu(uint32_t *driver_idx, ze_driver_handle_t *driver_) {
     int ret = 0;
     ze_result_t ze_result;
     uint32_t drivers_num = 0;
@@ -184,8 +174,7 @@ static inline int find_driver_with_gpu(uint32_t *driver_idx,
     return ret;
 }
 
-static inline int find_gpu_device(ze_driver_handle_t driver,
-                                  ze_device_handle_t *device_) {
+int find_gpu_device(ze_driver_handle_t driver, ze_device_handle_t *device_) {
     int ret = -1;
     uint32_t devices_num = 0;
     ze_device_handle_t *devices = NULL;
@@ -415,5 +404,3 @@ int destroy_context(ze_context_handle_t context) {
 
     return 0;
 }
-
-#endif // UMF_EXAMPLE_UTILS_LEVEL_ZERO_H
diff --git a/test/providers/level_zero_helpers.h b/examples/common/examples_level_zero_helpers.h
similarity index 52%
rename from test/providers/level_zero_helpers.h
rename to examples/common/examples_level_zero_helpers.h
index 6cd452c1c..2d8e92ff2 100644
--- a/test/providers/level_zero_helpers.h
+++ b/examples/common/examples_level_zero_helpers.h
@@ -1,25 +1,28 @@
 /*
+ *
  * Copyright (C) 2024 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
  */
 
-#ifndef UMF_TEST_LEVEL_ZERO_HELPERS_H
-#define UMF_TEST_LEVEL_ZERO_HELPERS_H
-
-#include <umf/providers/provider_level_zero.h>
-
-#include "ze_api.h"
+#ifndef UMF_EXAMPLES_LEVEL_ZERO_H
+#define UMF_EXAMPLES_LEVEL_ZERO_H
 
-#ifdef __cplusplus
-extern "C" {
+// To use the Level Zero API, the Level Zero SDK has to be installed
+// on the system
+#ifdef _WIN32
+#include <ze_api.h>
+#else
+#include <level_zero/ze_api.h>
 #endif
 
-int get_drivers(uint32_t *drivers_num_, ze_driver_handle_t **drivers_);
+int init_level_zero(void);
 
-int get_devices(ze_driver_handle_t driver, uint32_t *devices_num_,
-                ze_device_handle_t **devices_);
+int create_context(ze_driver_handle_t driver, ze_context_handle_t *context);
+
+int destroy_context(ze_context_handle_t context);
 
 int find_driver_with_gpu(uint32_t *driver_idx, ze_driver_handle_t *driver_);
 
@@ -30,19 +33,6 @@ int level_zero_fill(ze_context_handle_t context, ze_device_handle_t device,
                     size_t pattern_size);
 
 int level_zero_copy(ze_context_handle_t context, ze_device_handle_t device,
-                    void *dst_ptr, const void *src_ptr, size_t size);
-
-int create_context(ze_driver_handle_t driver, ze_context_handle_t *context);
-
-int destroy_context(ze_context_handle_t context);
-
-ze_memory_type_t get_mem_type(ze_context_handle_t context, void *ptr);
-
-level_zero_memory_provider_params_t
-create_level_zero_prov_params(umf_usm_memory_type_t memory_type);
-
-#ifdef __cplusplus
-}
-#endif
+                    void *dst_ptr, void *src_ptr, size_t size);
 
-#endif // UMF_TEST_LEVEL_ZERO_HELPERS_H
+#endif /* UMF_EXAMPLES_LEVEL_ZERO_H */
diff --git a/examples/common/examples_utils.h b/examples/common/examples_utils.h
new file mode 100644
index 000000000..9e4a93bcf
--- /dev/null
+++ b/examples/common/examples_utils.h
@@ -0,0 +1,16 @@
+/*
+ *
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+#ifndef UMF_EXAMPLE_UTILS_H
+#define UMF_EXAMPLE_UTILS_H
+
+// Needed for CI
+#define TEST_SKIP_ERROR_CODE 125
+
+#endif /* UMF_EXAMPLE_UTILS_H */
diff --git a/examples/cuda_shared_memory/CMakeLists.txt b/examples/cuda_shared_memory/CMakeLists.txt
new file mode 100644
index 000000000..d6aa60dad
--- /dev/null
+++ b/examples/cuda_shared_memory/CMakeLists.txt
@@ -0,0 +1,86 @@
+# 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
+
+cmake_minimum_required(VERSION 3.14.0 FATAL_ERROR)
+project(umf_example_cuda_shared_memory LANGUAGES C)
+enable_testing()
+
+set(UMF_EXAMPLE_DIR "${CMAKE_SOURCE_DIR}/..")
+list(APPEND CMAKE_MODULE_PATH "${UMF_EXAMPLE_DIR}/cmake")
+message(STATUS "CMAKE_MODULE_PATH=${CMAKE_MODULE_PATH}")
+
+find_package(PkgConfig)
+pkg_check_modules(LIBUMF libumf)
+if(NOT LIBUMF_FOUND)
+    find_package(LIBUMF REQUIRED libumf)
+endif()
+
+pkg_check_modules(LIBHWLOC hwloc>=2.3.0)
+if(NOT LIBHWLOC_FOUND)
+    find_package(LIBHWLOC 2.3.0 REQUIRED hwloc)
+endif()
+
+# 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} ...")
+
+# 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")
+
+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_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 ${CUDA_SM_LIBS})
+target_link_options(${EXAMPLE_NAME} PRIVATE "-Wl,--end-group")
+
+# an optional part - adds a test of this example
+add_test(
+    NAME ${EXAMPLE_NAME}
+    COMMAND ${EXAMPLE_NAME}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+set_tests_properties(${EXAMPLE_NAME} PROPERTIES LABELS "example-standalone")
+
+if(LINUX)
+    # set LD_LIBRARY_PATH
+    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:${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
new file mode 100644
index 000000000..883297edb
--- /dev/null
+++ b/examples/cuda_shared_memory/cuda_shared_memory.c
@@ -0,0 +1,183 @@
+/*
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+
+#include <umf/memory_pool.h>
+#include <umf/pools/pool_disjoint.h>
+#include <umf/providers/provider_cuda.h>
+
+// disable warning 4201: nonstandard extension used: nameless struct/union
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4201)
+#endif // _MSC_VER
+
+#include <cuda.h>
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif // _MSC_VER
+
+int main(void) {
+    // A result object for storing UMF API result status
+    umf_result_t res;
+
+    CUdevice cuDevice;
+    CUcontext cuContext;
+    int ret = 0;
+
+    // Initialize the CUDA driver API
+    cuInit(0);
+
+    // Get the handle to the first CUDA device
+    cuDeviceGet(&cuDevice, 0);
+
+    // Create a context on the device
+    cuCtxCreate(&cuContext, 0, cuDevice);
+
+    // Setup parameters for the CUDA Memory Provider. It will be used for
+    // allocating memory from CUDA devices.
+    umf_cuda_memory_provider_params_handle_t cu_memory_provider_params = NULL;
+    res = umfCUDAMemoryProviderParamsCreate(&cu_memory_provider_params);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create memory provider params!\n");
+        ret = -1;
+        goto cuda_destroy;
+    }
+
+    res = umfCUDAMemoryProviderParamsSetContext(cu_memory_provider_params,
+                                                cuContext);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set context in memory provider params!\n");
+        ret = -1;
+        goto provider_params_destroy;
+    }
+
+    res = umfCUDAMemoryProviderParamsSetDevice(cu_memory_provider_params,
+                                               cuDevice);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set device in memory provider params!\n");
+        ret = -1;
+        goto provider_params_destroy;
+    }
+    // Set the memory type to shared to allow the memory to be accessed on both
+    // CPU and GPU.
+    res = umfCUDAMemoryProviderParamsSetMemoryType(cu_memory_provider_params,
+                                                   UMF_MEMORY_TYPE_SHARED);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "Failed to set memory type in memory provider params!\n");
+        ret = -1;
+        goto provider_params_destroy;
+    }
+
+    // Create CUDA memory provider
+    umf_memory_provider_handle_t cu_memory_provider;
+    res =
+        umfMemoryProviderCreate(umfCUDAMemoryProviderOps(),
+                                cu_memory_provider_params, &cu_memory_provider);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create a memory provider!\n");
+        ret = -1;
+        goto provider_params_destroy;
+    }
+
+    printf("CUDA memory provider created at %p\n", (void *)cu_memory_provider);
+
+    // Setup parameters for the Disjoint Pool. It will be used for managing the
+    // memory allocated using memory provider.
+    umf_disjoint_pool_params_handle_t hDisjointParams = NULL;
+    res = umfDisjointPoolParamsCreate(&hDisjointParams);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "disjoint pool params create failed\n");
+        ret = -1;
+        goto memory_provider_destroy;
+    }
+    // Set the Slab Min Size to 64KB - the page size for GPU allocations
+    res = umfDisjointPoolParamsSetSlabMinSize(hDisjointParams, 64 * 1024L);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set the slab min size!\n");
+        ret = -1;
+        goto pool_params_destroy;
+    }
+    // We would keep only single slab per each allocation bucket
+    res = umfDisjointPoolParamsSetCapacity(hDisjointParams, 1);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set the capacity!\n");
+        ret = -1;
+        goto pool_params_destroy;
+    }
+    // Set the maximum poolable size to 64KB - objects with size above this
+    // limit will not be stored/allocated from the pool.
+    res = umfDisjointPoolParamsSetMaxPoolableSize(hDisjointParams, 64 * 1024L);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set the max poolable size!\n");
+        ret = -1;
+        goto pool_params_destroy;
+    }
+    // Enable tracing
+    res = umfDisjointPoolParamsSetTrace(hDisjointParams, 1);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set the pool trace!\n");
+        ret = -1;
+        goto pool_params_destroy;
+    }
+
+    // Create Disjoint Pool memory pool.
+    umf_memory_pool_handle_t cu_disjoint_memory_pool;
+    res =
+        umfPoolCreate(umfDisjointPoolOps(), cu_memory_provider, hDisjointParams,
+                      UMF_POOL_CREATE_FLAG_NONE, &cu_disjoint_memory_pool);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create a memory pool!\n");
+        ret = -1;
+        goto memory_provider_destroy;
+    }
+
+    printf("Disjoint Pool created at %p\n", (void *)cu_disjoint_memory_pool);
+
+    // Allocate some memory from the pool
+    int *ptr = umfPoolMalloc(cu_disjoint_memory_pool, sizeof(int));
+    if (ptr == NULL) {
+        fprintf(stderr, "Failed to allocate memory from the memory pool!\n");
+        ret = -1;
+        goto memory_pool_destroy;
+    }
+
+    // Use allocated memory
+    *ptr = 1;
+
+    // Free allocated memory
+    res = umfFree(ptr);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to free memory to the pool!\n");
+        ret = -1;
+        goto memory_pool_destroy;
+    }
+    printf("Freed memory at %p\n", (void *)ptr);
+
+    // Cleanup
+memory_pool_destroy:
+    umfPoolDestroy(cu_disjoint_memory_pool);
+
+pool_params_destroy:
+    umfDisjointPoolParamsDestroy(hDisjointParams);
+
+memory_provider_destroy:
+    umfMemoryProviderDestroy(cu_memory_provider);
+
+provider_params_destroy:
+    umfCUDAMemoryProviderParamsDestroy(cu_memory_provider_params);
+
+cuda_destroy:
+    ret = cuCtxDestroy(cuContext);
+    return ret;
+}
diff --git a/examples/custom_file_provider/CMakeLists.txt b/examples/custom_file_provider/CMakeLists.txt
new file mode 100644
index 000000000..9d4e336c7
--- /dev/null
+++ b/examples/custom_file_provider/CMakeLists.txt
@@ -0,0 +1,52 @@
+# Copyright (C) 2024 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+cmake_minimum_required(VERSION 3.14.0 FATAL_ERROR)
+project(umf_example_custom_file_provider LANGUAGES C)
+enable_testing()
+
+set(UMF_EXAMPLE_DIR "${CMAKE_SOURCE_DIR}/..")
+list(APPEND CMAKE_MODULE_PATH "${UMF_EXAMPLE_DIR}/cmake")
+message(STATUS "CMAKE_MODULE_PATH=${CMAKE_MODULE_PATH}")
+
+find_package(PkgConfig)
+pkg_check_modules(LIBUMF libumf)
+if(NOT LIBUMF_FOUND)
+    find_package(LIBUMF REQUIRED libumf)
+endif()
+
+pkg_check_modules(LIBHWLOC hwloc>=2.3.0)
+if(NOT LIBHWLOC_FOUND)
+    find_package(LIBHWLOC 2.3.0 REQUIRED hwloc)
+endif()
+
+pkg_check_modules(TBB tbb)
+if(NOT TBB_FOUND)
+    find_package(TBB REQUIRED tbb)
+endif()
+
+# build the example
+set(EXAMPLE_NAME umf_example_custom_file_provider)
+add_executable(${EXAMPLE_NAME} custom_file_provider.c)
+target_include_directories(${EXAMPLE_NAME} PRIVATE ${LIBUMF_INCLUDE_DIRS})
+target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS})
+target_link_libraries(${EXAMPLE_NAME} PRIVATE ${LIBUMF_LIBRARIES}
+                                              ${LIBHWLOC_LIBRARIES})
+
+add_test(
+    NAME ${EXAMPLE_NAME}
+    COMMAND ${EXAMPLE_NAME}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+set_tests_properties(${EXAMPLE_NAME} PROPERTIES LABELS "example-standalone")
+
+if(LINUX)
+    # set LD_LIBRARY_PATH
+    set_property(
+        TEST ${EXAMPLE_NAME}
+        PROPERTY
+            ENVIRONMENT_MODIFICATION
+            "LD_LIBRARY_PATH=path_list_append:${LIBUMF_LIBRARY_DIRS};LD_LIBRARY_PATH=path_list_append:${LIBHWLOC_LIBRARY_DIRS}"
+    )
+endif()
diff --git a/examples/custom_file_provider/custom_file_provider.c b/examples/custom_file_provider/custom_file_provider.c
new file mode 100644
index 000000000..dbf1bb092
--- /dev/null
+++ b/examples/custom_file_provider/custom_file_provider.c
@@ -0,0 +1,347 @@
+/*
+ *
+ * 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
+ *
+ */
+#define _GNU_SOURCE 1
+
+#include <fcntl.h>
+#include <linux/falloc.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#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)
+
+// Macro to align a value up to the nearest multiple of align
+#define ALIGN_UP(value, align) (((value) + (align)-1) & ~((align)-1))
+
+// Struct to represent the file provider
+typedef struct file_provider_t {
+    void *ptr;        // Pointer to the reserved memory
+    size_t poffset;   // Offset for the next allocation
+    int fd;           // File descriptor for the backing file
+    size_t foffset;   // Offset within the file for the next allocation
+    size_t page_size; // System page size
+} file_provider_t;
+
+// Struct to represent the file parameters
+typedef struct file_params_t {
+    const char *filename; // Filename for the backing file
+} file_params_t;
+
+// Function to initialize the file provider
+static umf_result_t file_init(const void *params, void **provider) {
+    file_provider_t *file_provider = NULL;
+
+    if (params == NULL || provider == NULL) {
+        fprintf(stderr, "Params or provider cannot be null\n");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    const file_params_t *file_params = params;
+    int page_size = 0;
+    umf_result_t ret = UMF_RESULT_SUCCESS;
+
+    // Allocate memory for the file provider
+    file_provider = malloc(sizeof(*file_provider));
+    if (!file_provider) {
+        fprintf(stderr, "Failed to allocate memory for file provider\n");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    // Open the file
+    file_provider->fd = open(file_params->filename, O_RDWR | O_CREAT, 0666);
+    if (file_provider->fd < 0) {
+        perror("open()");
+        fprintf(stderr, "Failed to open the file: %s\n", file_params->filename);
+        ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        goto cleanup_malloc;
+    }
+
+    // Reserve address space for subsequent allocations.
+    // This simplifies translation between addresses and offset in the file.
+    file_provider->ptr = mmap(NULL, ADDRESS_RESERVATION, PROT_NONE,
+                              MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+    if (file_provider->ptr == MAP_FAILED) {
+        perror("Failed to memory map anonymous memory");
+        ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        goto cleanup_fd;
+    }
+
+    // Get the page size
+    page_size = sysconf(_SC_PAGESIZE);
+    if (page_size < 0) {
+        perror("Failed to get system page size");
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+        goto cleanup_mmap;
+    }
+
+    // Initialize the file provider fields
+    file_provider->poffset = 0;
+    file_provider->foffset = 0;
+    file_provider->page_size = (size_t)page_size;
+    *provider = file_provider;
+
+    return UMF_RESULT_SUCCESS;
+
+cleanup_mmap:
+    munmap(file_provider->ptr, ADDRESS_RESERVATION);
+cleanup_fd:
+    close(file_provider->fd);
+cleanup_malloc:
+    free(file_provider);
+    return ret;
+}
+
+// Function to deinitialize the file 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
+static umf_result_t file_alloc(void *provider, size_t size, size_t alignment,
+                               void **ptr) {
+    file_provider_t *file_provider = (file_provider_t *)provider;
+    size_t page_size = file_provider->page_size;
+
+    if (alignment && (alignment % page_size) && (page_size % alignment)) {
+        fprintf(stderr,
+                "Wrong alignment: %zu (not a multiple or a divider of the "
+                "minimum page size (%zu))",
+                alignment, page_size);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    size = ALIGN_UP(size, page_size);
+
+    // calculate address for new allocation. All allocation are page aligned so
+    // if alignment is bigger than page size we have to adjust the address
+    uintptr_t ptr_offset =
+        (uintptr_t)file_provider->ptr + file_provider->poffset;
+    uintptr_t aligned_ptr =
+        alignment > page_size ? ALIGN_UP(ptr_offset, alignment) : ptr_offset;
+
+    size_t new_offset = aligned_ptr + size - (uintptr_t)file_provider->ptr;
+    if (new_offset + size > ADDRESS_RESERVATION) {
+        fprintf(stderr, "This example limits allocation up to 10GB\n");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    // Ensure the file is large enough to hold the new allocation
+    if (fallocate(file_provider->fd, 0, file_provider->foffset, size)) {
+        perror("Fallocate failed");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+    // Map the file in place of the reservation
+    void *ret = mmap((void *)aligned_ptr, size, PROT_READ | PROT_WRITE,
+                     MAP_FIXED | MAP_PRIVATE, file_provider->fd,
+                     file_provider->foffset);
+    if (ret == MAP_FAILED) {
+        perror("Memory map failed");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    file_provider->poffset = new_offset;
+    file_provider->foffset += size;
+    *ptr = ret;
+    return UMF_RESULT_SUCCESS;
+}
+
+// Function to free allocated memory from the file provider
+static umf_result_t file_free(void *provider, void *ptr, size_t size) {
+    if (ptr == NULL) {
+        fprintf(stderr, "ptr cannot be null\n");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    file_provider_t *file_provider = (file_provider_t *)provider;
+    if (size == 0) {
+        fprintf(stderr, "Size cannot be 0\n");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (ptr < file_provider->ptr ||
+        (uintptr_t)ptr >=
+            (uintptr_t)file_provider->ptr + file_provider->poffset) {
+        fprintf(stderr, "Ptr is not within the provider's memory\n");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    size = ALIGN_UP(size, file_provider->page_size);
+
+    // Replace allocation with a reservation to free memory
+    void *ptr2 = mmap(ptr, size, PROT_NONE,
+                      MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+
+    if (ptr2 == MAP_FAILED) {
+        perror("Failed to free memory");
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    // Free allocated blocks to the filesystem
+    if (fallocate(file_provider->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
+                  (uintptr_t)ptr - (uintptr_t)file_provider->ptr, size)) {
+        perror("Fallocate failed");
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+// Function to get the name of the file provider
+static const char *file_get_name(void *provider) {
+    (void)provider; // Unused parameter
+    return "File Provider";
+}
+
+// Function to get the last native error of the file provider
+// This function is needed only if the provider returns UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC
+static void file_get_last_native_error(void *provider, const char **ppMessage,
+                                       int32_t *pError) {
+    (void)provider; // Unused parameter
+    *ppMessage = "";
+    *pError = 0;
+}
+
+// Function to get the recommended page size of the file provider
+static umf_result_t file_get_recommended_page_size(void *provider, size_t size,
+                                                   size_t *pageSize) {
+    (void)size; // Unused parameter
+    file_provider_t *file_provider = (file_provider_t *)provider;
+    *pageSize = file_provider->page_size;
+    return UMF_RESULT_SUCCESS;
+}
+
+// Function to get the minimum page size of the file provider
+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;
+    *pageSize = file_provider->page_size;
+    return UMF_RESULT_SUCCESS;
+}
+
+// File provider operations
+static umf_memory_provider_ops_t file_ops = {
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
+    .initialize = file_init,
+    .finalize = file_deinit,
+    .alloc = file_alloc,
+    .free = file_free,
+    .get_name = file_get_name,
+    .get_last_native_error = file_get_last_native_error,
+    .get_recommended_page_size = file_get_recommended_page_size,
+    .get_min_page_size = file_get_min_page_size,
+};
+
+// Main function
+int main(void) {
+    // A result object for storing UMF API result status
+    umf_result_t res;
+    umf_memory_provider_handle_t provider;
+    file_params_t params;
+    params.filename = "/tmp/file_provider_example";
+
+    // Create a memory provider
+    res = umfMemoryProviderCreate(&file_ops, &params, &provider);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create a memory provider!\n");
+        return -1;
+    }
+    printf("OS memory provider created at %p\n", (void *)provider);
+
+    // Allocate memory from the memory provider
+    size_t alloc_size = 5000;
+    size_t alignment = 0;
+    void *ptr_provider = NULL;
+
+    res =
+        umfMemoryProviderAlloc(provider, alloc_size, alignment, &ptr_provider);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "Failed to allocate memory from the memory provider!\n");
+        goto memory_provider_destroy;
+    }
+
+    const char *strSource = "Allocated memory at";
+
+    // Write to the allocated memory
+    memset(ptr_provider, '\0', alloc_size);
+    strncpy(ptr_provider, strSource, alloc_size);
+    printf("%s %p with the memory provider at %p\n", (char *)ptr_provider,
+           (void *)ptr_provider, (void *)provider);
+
+    // Free the allocated memory
+    res = umfMemoryProviderFree(provider, ptr_provider, alloc_size);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to free memory to the provider!\n");
+        goto memory_provider_destroy;
+    }
+    printf("Freed memory at %p\n", ptr_provider);
+
+    // Create a memory pool
+    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;
+
+    res = umfPoolCreate(pool_ops, provider, pool_params, flags, &pool);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create a pool!\n");
+        goto memory_provider_destroy;
+    }
+    printf("Scalable memory pool created at %p\n", (void *)pool);
+
+    // Allocate some memory in the pool
+    size_t num = 1;
+    alloc_size = 128;
+
+    char *ptr = umfPoolCalloc(pool, num, alloc_size);
+    if (!ptr) {
+        fprintf(stderr, "Failed to allocate memory in the pool!\n");
+        goto memory_pool_destroy;
+    }
+
+    // Write a string to the allocated memory
+    strncpy(ptr, strSource, alloc_size);
+    printf("%s %p\n", ptr, (void *)ptr);
+
+    // Retrieve a memory pool from a pointer, available with memory tracking
+    umf_memory_pool_handle_t check_pool = umfPoolByPtr(ptr);
+    printf("Memory at %p has been allocated from the pool at %p\n", (void *)ptr,
+           (void *)check_pool);
+
+    // Retrieve a memory provider from a pool
+    umf_memory_provider_handle_t check_provider;
+    res = umfPoolGetMemoryProvider(pool, &check_provider);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to retrieve a memory provider for the pool!\n");
+        goto memory_pool_destroy;
+    }
+    printf("Pool at %p has been allocated from the provider at %p\n",
+           (void *)pool, (void *)check_provider);
+
+    // Clean up
+    umfFree(ptr);
+    umfPoolDestroy(pool);
+    umfMemoryProviderDestroy(provider);
+    return 0;
+
+memory_pool_destroy:
+    umfPoolDestroy(pool);
+memory_provider_destroy:
+    umfMemoryProviderDestroy(provider);
+    return -1;
+}
diff --git a/examples/gpu_shared_memory/CMakeLists.txt b/examples/dram_and_fsdax/CMakeLists.txt
similarity index 53%
rename from examples/gpu_shared_memory/CMakeLists.txt
rename to examples/dram_and_fsdax/CMakeLists.txt
index 259b47d08..dcb538085 100644
--- a/examples/gpu_shared_memory/CMakeLists.txt
+++ b/examples/dram_and_fsdax/CMakeLists.txt
@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 cmake_minimum_required(VERSION 3.14.0 FATAL_ERROR)
-project(umf_example_gpu_shared_memory LANGUAGES C)
+project(umf_example_dram_and_fsdax LANGUAGES C)
 enable_testing()
 
 set(UMF_EXAMPLE_DIR "${CMAKE_SOURCE_DIR}/..")
@@ -21,42 +21,15 @@ 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.16.1)
-
-message(
-    STATUS
-        "Installing level-zero ${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_GetProperties(level-zero-loader)
-if(NOT level-zero-loader_POPULATED)
-    FetchContent_Populate(level-zero-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}")
-
 # build the example
-set(EXAMPLE_NAME umf_example_gpu_shared_memory)
-add_executable(${EXAMPLE_NAME} gpu_shared_memory.c)
-target_include_directories(${EXAMPLE_NAME} PRIVATE ${LIBUMF_INCLUDE_DIRS}
-                                                   ${UMF_EXAMPLE_DIR}/common)
+set(EXAMPLE_NAME umf_example_dram_and_fsdax)
+add_executable(${EXAMPLE_NAME} dram_and_fsdax.c)
+target_include_directories(${EXAMPLE_NAME} PRIVATE ${LIBUMF_INCLUDE_DIRS})
+
 target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBUMF_LIBRARY_DIRS}
                         ${LIBHWLOC_LIBRARY_DIRS})
-target_link_options(${EXAMPLE_NAME} PRIVATE "-Wl,--start-group")
-target_link_libraries(${EXAMPLE_NAME} PRIVATE stdc++ libdisjoint_pool.a
-                                              ze_loader ${LIBUMF_LIBRARIES})
+
+target_link_libraries(${EXAMPLE_NAME} PRIVATE hwloc ${LIBUMF_LIBRARIES})
 
 # an optional part - adds a test of this example
 add_test(
diff --git a/examples/dram_and_fsdax/dram_and_fsdax.c b/examples/dram_and_fsdax/dram_and_fsdax.c
new file mode 100644
index 000000000..80c7ecc03
--- /dev/null
+++ b/examples/dram_and_fsdax/dram_and_fsdax.c
@@ -0,0 +1,169 @@
+/*
+ * 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 <stdio.h>
+#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>
+
+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;
+    umf_result_t umf_result;
+
+    umf_os_memory_provider_params_handle_t params_dram = NULL;
+    umf_result = umfOsMemoryProviderParamsCreate(&params_dram);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create OS memory provider params!\n");
+        return NULL;
+    }
+
+    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(), params_dram,
+                                         &provider_dram);
+    umfOsMemoryProviderParamsDestroy(params_dram);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Creation of the OS memory provider failed");
+        return NULL;
+    }
+
+    // Create a DRAM memory pool
+    umf_result = umfPoolCreate(umfJemallocPoolOps(), provider_dram, NULL,
+                               UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &pool_dram);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create a DRAM memory pool!\n");
+        umfMemoryProviderDestroy(provider_dram);
+        return NULL;
+    }
+
+    return pool_dram;
+}
+
+static umf_memory_pool_handle_t create_fsdax_pool(const char *path) {
+    umf_memory_provider_handle_t provider_fsdax = NULL;
+    umf_memory_pool_handle_t pool_fsdax;
+    umf_result_t umf_result;
+
+    umf_file_memory_provider_params_handle_t params_fsdax = NULL;
+    umf_result = umfFileMemoryProviderParamsCreate(&params_fsdax, path);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create the File Memory Provider params");
+        return NULL;
+    }
+    // FSDAX requires mapping the UMF_MEM_MAP_SHARED flag
+    umf_result = umfFileMemoryProviderParamsSetVisibility(params_fsdax,
+                                                          UMF_MEM_MAP_SHARED);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "Failed to set the visibility of the FSDAX file provider");
+        umfFileMemoryProviderParamsDestroy(params_fsdax);
+        return NULL;
+    }
+
+    umf_result = umfMemoryProviderCreate(umfFileMemoryProviderOps(),
+                                         params_fsdax, &provider_fsdax);
+    umfFileMemoryProviderParamsDestroy(params_fsdax);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create the FSDAX file provider");
+        return NULL;
+    }
+
+    // Create an FSDAX memory pool
+    umf_result = umfPoolCreate(umfJemallocPoolOps(), provider_fsdax, NULL,
+                               UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &pool_fsdax);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create an FSDAX memory pool!\n");
+        umfMemoryProviderDestroy(provider_fsdax);
+        return NULL;
+    }
+
+    return pool_fsdax;
+}
+
+int main(void) {
+    int ret = -1;
+
+    // This example requires:
+    // - the FSDAX device to be mounted in the OS (e.g. /mnt/pmem1) and
+    // - the UMF_TESTS_FSDAX_PATH environment variable to contain
+    //   a path to a file on this FSDAX device.
+    char *path = getenv("UMF_TESTS_FSDAX_PATH");
+    if (path == NULL || path[0] == 0) {
+        fprintf(
+            stderr,
+            "Warning: UMF_TESTS_FSDAX_PATH is not set, skipping testing ...\n");
+        return 0;
+    }
+
+    umf_memory_pool_handle_t dram_pool = create_dram_pool();
+    if (dram_pool == NULL) {
+        fprintf(stderr, "Failed to create a DRAM memory pool!\n");
+        return -1;
+    }
+
+    fprintf(stderr, "Created a DRAM memory pool\n");
+
+    umf_memory_pool_handle_t fsdax_pool = create_fsdax_pool(path);
+    if (fsdax_pool == NULL) {
+        fprintf(stderr, "Failed to create an FSDAX memory pool!\n");
+        goto err_destroy_dram_pool;
+    }
+
+    fprintf(stderr, "Created an FSDAX memory pool\n");
+
+    size_t size = 2 * 1024 * 1024; // == 2 MB
+
+    // Allocate from the DRAM memory pool
+    char *dram_buf = umfPoolCalloc(dram_pool, 1, size);
+    if (dram_buf == NULL) {
+        fprintf(stderr,
+                "Failed to allocate memory from the DRAM memory pool!\n");
+        goto err_destroy_pools;
+    }
+
+    fprintf(stderr, "Allocated memory from the DRAM memory pool\n");
+
+    // Allocate from the FSDAX memory pool
+    char *fsdax_buf = umfPoolCalloc(fsdax_pool, 1, size);
+    if (fsdax_buf == NULL) {
+        fprintf(stderr,
+                "Failed to allocate memory from the FSDAX memory pool!\n");
+        goto err_free_dram;
+    }
+
+    fprintf(stderr, "Allocated memory from the FSDAX memory pool\n");
+
+    // Use the allocation from DRAM
+    dram_buf[0] = '.';
+
+    // Use the allocation from FSDAX
+    fsdax_buf[0] = '.';
+
+    // success
+    ret = 0;
+
+    // The file memory provider does not support the free() operation,
+    // so we do not need to call: umfPoolFree(fsdax_pool, fsdax_buf);
+
+err_free_dram:
+    fprintf(stderr, "Freeing the allocation from the DRAM memory pool ...\n");
+    umfPoolFree(dram_pool, dram_buf);
+
+err_destroy_pools:
+    fprintf(stderr, "Destroying the FSDAX memory pool ...\n");
+    umfPoolDestroy(fsdax_pool);
+
+err_destroy_dram_pool:
+    fprintf(stderr, "Destroying the DRAM memory pool ...\n");
+    umfPoolDestroy(dram_pool);
+
+    return ret;
+}
diff --git a/examples/ipc_ipcapi/ipc_ipcapi_anon_fd.sh b/examples/ipc_ipcapi/ipc_ipcapi_anon_fd.sh
index 615271eeb..2eb9409da 100755
--- a/examples/ipc_ipcapi/ipc_ipcapi_anon_fd.sh
+++ b/examples/ipc_ipcapi/ipc_ipcapi_anon_fd.sh
@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024-2025 Intel Corporation
 #
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -16,16 +16,8 @@ PORT=$(( 1024 + ( $$ % ( 65535 - 1024 ))))
 # to obtain a duplicate of another process's file descriptor.
 # Permission to duplicate another process's file descriptor
 # is governed by a ptrace access mode PTRACE_MODE_ATTACH_REALCREDS check (see ptrace(2))
-# that can be changed using the /proc/sys/kernel/yama/ptrace_scope interface.
-PTRACE_SCOPE_FILE="/proc/sys/kernel/yama/ptrace_scope"
-VAL=0
-if [ -f $PTRACE_SCOPE_FILE ]; then
-	PTRACE_SCOPE_VAL=$(cat $PTRACE_SCOPE_FILE)
-	if [ $PTRACE_SCOPE_VAL -ne $VAL ]; then
-		echo "SKIP: ptrace_scope is not set to 0 (classic ptrace permissions) - skipping the test"
-		exit 125 # skip code defined in CMakeLists.txt
-	fi
-fi
+# In the producer binary used in this example prctl(PR_SET_PTRACER, getppid()) is used
+# to allow consumer to duplicate file descriptor of producer.
 
 UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
 
diff --git a/examples/ipc_ipcapi/ipc_ipcapi_consumer.c b/examples/ipc_ipcapi/ipc_ipcapi_consumer.c
index 05596bd16..2f55c473f 100644
--- a/examples/ipc_ipcapi/ipc_ipcapi_consumer.c
+++ b/examples/ipc_ipcapi/ipc_ipcapi_consumer.c
@@ -99,17 +99,33 @@ int main(int argc, char *argv[]) {
     int port = atoi(argv[1]);
 
     umf_memory_provider_handle_t OS_memory_provider = NULL;
-    umf_os_memory_provider_params_t os_params;
+    umf_os_memory_provider_params_handle_t os_params = NULL;
     enum umf_result_t umf_result;
 
-    os_params = umfOsMemoryProviderParamsDefault();
-    os_params.visibility = UMF_MEM_MAP_SHARED;
+    umf_result = umfOsMemoryProviderParamsCreate(&os_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(
+            stderr,
+            "[consumer] ERROR: creating OS memory provider params failed\n");
+        return -1;
+    }
+    umf_result =
+        umfOsMemoryProviderParamsSetVisibility(os_params, UMF_MEM_MAP_SHARED);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "[consumer] ERROR: setting visibility mode failed\n");
+        goto err_destroy_OS_params;
+    }
     if (argc >= 3) {
-        os_params.shm_name = argv[2];
+        umf_result = umfOsMemoryProviderParamsSetShmName(os_params, argv[2]);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            fprintf(stderr,
+                    "[consumer] ERROR: setting shared memory name failed\n");
+            goto err_destroy_OS_params;
+        }
     }
 
     // create OS memory provider
-    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(), &os_params,
+    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(), os_params,
                                          &OS_memory_provider);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr,
@@ -126,6 +142,13 @@ int main(int argc, char *argv[]) {
         goto err_destroy_OS_memory_provider;
     }
 
+    umf_ipc_handler_handle_t ipc_handler;
+    umf_result = umfPoolGetIPCHandler(scalable_pool, &ipc_handler);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "[producer] ERROR: get IPC handler failed\n");
+        goto err_destroy_scalable_pool;
+    }
+
     // connect to the producer
     producer_socket = consumer_connect_to_producer(port);
     if (producer_socket < 0) {
@@ -193,7 +216,7 @@ int main(int argc, char *argv[]) {
         len);
 
     void *SHM_ptr;
-    umf_result = umfOpenIPCHandle(scalable_pool, IPC_handle, &SHM_ptr);
+    umf_result = umfOpenIPCHandle(ipc_handler, IPC_handle, &SHM_ptr);
     if (umf_result == UMF_RESULT_ERROR_NOT_SUPPORTED) {
         fprintf(stderr,
                 "[consumer] SKIP: opening the IPC handle is not supported\n");
@@ -267,6 +290,9 @@ int main(int argc, char *argv[]) {
 err_destroy_OS_memory_provider:
     umfMemoryProviderDestroy(OS_memory_provider);
 
+err_destroy_OS_params:
+    umfOsMemoryProviderParamsDestroy(os_params);
+
     if (ret == 0) {
         fprintf(stderr, "[consumer] Shutting down (status OK) ...\n");
     } else if (ret == 1) {
diff --git a/examples/ipc_ipcapi/ipc_ipcapi_producer.c b/examples/ipc_ipcapi/ipc_ipcapi_producer.c
index fcb73650f..9082302ac 100644
--- a/examples/ipc_ipcapi/ipc_ipcapi_producer.c
+++ b/examples/ipc_ipcapi/ipc_ipcapi_producer.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -9,6 +9,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/prctl.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
@@ -69,18 +70,49 @@ int main(int argc, char *argv[]) {
 
     int port = atoi(argv[1]);
 
+    // The prctl() function with PR_SET_PTRACER is used here to allow parent process and its children
+    // to ptrace the current process. This is necessary because UMF's memory providers on Linux (except CUDA)
+    // use the pidfd_getfd(2) system call to duplicate another process's file descriptor, which is
+    // governed by ptrace permissions. By default on Ubuntu /proc/sys/kernel/yama/ptrace_scope is
+    // set to 1 ("restricted ptrace"), which prevents pidfd_getfd from working unless ptrace_scope
+    // is set to 0.
+    // To overcome this limitation without requiring users to change the ptrace_scope
+    // setting (which requires root privileges), we use prctl() to allow the consumer process
+    // to copy producer's file descriptor, even when ptrace_scope is set to 1.
+    ret = prctl(PR_SET_PTRACER, getppid());
+    if (ret == -1) {
+        perror("PR_SET_PTRACER may be not supported. prctl() call failed");
+        goto err_end;
+    }
+
     umf_memory_provider_handle_t OS_memory_provider = NULL;
-    umf_os_memory_provider_params_t os_params;
+    umf_os_memory_provider_params_handle_t os_params = NULL;
     enum umf_result_t umf_result;
 
-    os_params = umfOsMemoryProviderParamsDefault();
-    os_params.visibility = UMF_MEM_MAP_SHARED;
+    umf_result = umfOsMemoryProviderParamsCreate(&os_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(
+            stderr,
+            "[producer] ERROR: creating OS memory provider params failed\n");
+        return -1;
+    }
+    umf_result =
+        umfOsMemoryProviderParamsSetVisibility(os_params, UMF_MEM_MAP_SHARED);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "[producer] ERROR: setting visibility mode failed\n");
+        goto err_destroy_OS_params;
+    }
     if (argc >= 3) {
-        os_params.shm_name = argv[2];
+        umf_result = umfOsMemoryProviderParamsSetShmName(os_params, argv[2]);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            fprintf(stderr,
+                    "[producer] ERROR: setting shared memory name failed\n");
+            goto err_destroy_OS_params;
+        }
     }
 
     // create OS memory provider
-    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(), &os_params,
+    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(), os_params,
                                          &OS_memory_provider);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr,
@@ -240,6 +272,10 @@ int main(int argc, char *argv[]) {
 err_destroy_OS_memory_provider:
     umfMemoryProviderDestroy(OS_memory_provider);
 
+err_destroy_OS_params:
+    umfOsMemoryProviderParamsDestroy(os_params);
+
+err_end:
     if (ret == 0) {
         fprintf(stderr, "[producer] Shutting down (status OK) ...\n");
     } else if (ret == 1) {
diff --git a/examples/ipc_ipcapi/ipc_ipcapi_shm.sh b/examples/ipc_ipcapi/ipc_ipcapi_shm.sh
index db310d08d..57a344c1e 100755
--- a/examples/ipc_ipcapi/ipc_ipcapi_shm.sh
+++ b/examples/ipc_ipcapi/ipc_ipcapi_shm.sh
@@ -20,7 +20,7 @@ UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
 rm -f /dev/shm/${SHM_NAME}
 
 echo "Starting ipc_ipcapi_shm CONSUMER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_example_ipc_ipcapi_consumer $PORT $SHM_NAME &
+UMF_LOG=$UMF_LOG_VAL ./umf_example_ipc_ipcapi_consumer $PORT &
 
 echo "Waiting 1 sec ..."
 sleep 1
diff --git a/examples/ipc_level_zero/CMakeLists.txt b/examples/ipc_level_zero/CMakeLists.txt
index e38adf25f..726ced3f1 100644
--- a/examples/ipc_level_zero/CMakeLists.txt
+++ b/examples/ipc_level_zero/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -21,42 +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.16.1)
-
-message(
-    STATUS
-        "Installing level-zero ${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_GetProperties(level-zero-loader)
-if(NOT level-zero-loader_POPULATED)
-    FetchContent_Populate(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)
-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})
+add_executable(
+    ${EXAMPLE_NAME} ipc_level_zero.c
+                    ${UMF_EXAMPLE_DIR}/common/examples_level_zero_helpers.c)
+target_include_directories(${EXAMPLE_NAME}
+                           PRIVATE ${IPC_LEVEL_ZERO_SM_INCLUDE_DIRS})
+target_link_directories(${EXAMPLE_NAME} PRIVATE
+                        ${IPC_LEVEL_ZERO_SM_LIBRARY_DIRS})
 target_link_options(${EXAMPLE_NAME} PRIVATE "-Wl,--start-group")
-target_link_libraries(${EXAMPLE_NAME} PRIVATE stdc++ libdisjoint_pool.a
-                                              ze_loader ${LIBUMF_LIBRARIES})
+target_link_libraries(${EXAMPLE_NAME} PRIVATE stdc++ ze_loader
+                                              ${LIBUMF_LIBRARIES})
+target_link_options(${EXAMPLE_NAME} PRIVATE "-Wl,--end-group")
 
 # an optional part - adds a test of this example
 add_test(
@@ -67,10 +54,13 @@ add_test(
 set_tests_properties(${EXAMPLE_NAME} PROPERTIES LABELS "example-standalone")
 
 if(LINUX)
+    # set LD_LIBRARY_PATH
+    string(JOIN ":" IPC_LEVEL_ZERO_SM_LIBRARY_DIRS_JOINED
+           ${IPC_LEVEL_ZERO_SM_LIBRARY_DIRS})
     set_property(
         TEST ${EXAMPLE_NAME}
         PROPERTY
             ENVIRONMENT_MODIFICATION
-            "LD_LIBRARY_PATH=path_list_append:${LIBUMF_LIBRARY_DIRS};LD_LIBRARY_PATH=path_list_append:${LIBHWLOC_LIBRARY_DIRS}"
+            "LD_LIBRARY_PATH=path_list_prepend:${IPC_LEVEL_ZERO_SM_LIBRARY_DIRS_JOINED}"
     )
 endif()
diff --git a/examples/ipc_level_zero/ipc_level_zero.c b/examples/ipc_level_zero/ipc_level_zero.c
index e7991fce6..a7901cb09 100644
--- a/examples/ipc_level_zero/ipc_level_zero.c
+++ b/examples/ipc_level_zero/ipc_level_zero.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -8,44 +8,90 @@
  */
 
 #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 "utils_level_zero.h"
+#include "examples_level_zero_helpers.h"
 
 int create_level_zero_pool(ze_context_handle_t context,
                            ze_device_handle_t device,
                            umf_memory_pool_handle_t *pool) {
     // setup params
-    level_zero_memory_provider_params_t params;
-    params.level_zero_context_handle = context;
-    params.level_zero_device_handle = device;
-    params.memory_type = UMF_MEMORY_TYPE_DEVICE;
+    umf_level_zero_memory_provider_params_handle_t provider_params = NULL;
+
+    umf_result_t umf_result =
+        umfLevelZeroMemoryProviderParamsCreate(&provider_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "ERROR: Failed to create Level Zero memory provider params!\n");
+        return -1;
+    }
+
+    umf_result =
+        umfLevelZeroMemoryProviderParamsSetContext(provider_params, context);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "ERROR: Failed to set context in Level Zero memory "
+                        "provider params!\n");
+        umfLevelZeroMemoryProviderParamsDestroy(provider_params);
+        return -1;
+    }
+
+    umf_result =
+        umfLevelZeroMemoryProviderParamsSetDevice(provider_params, device);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "ERROR: Failed to set device in Level Zero memory "
+                        "provider params!\n");
+        umfLevelZeroMemoryProviderParamsDestroy(provider_params);
+        return -1;
+    }
+
+    umf_result = umfLevelZeroMemoryProviderParamsSetMemoryType(
+        provider_params, UMF_MEMORY_TYPE_DEVICE);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "ERROR: Failed to set memory type in Level Zero memory "
+                        "provider params!\n");
+        umfLevelZeroMemoryProviderParamsDestroy(provider_params);
+        return -1;
+    }
 
     // create Level Zero provider
     umf_memory_provider_handle_t provider = 0;
-    umf_result_t umf_result = umfMemoryProviderCreate(
-        umfLevelZeroMemoryProviderOps(), &params, &provider);
+    umf_result = umfMemoryProviderCreate(umfLevelZeroMemoryProviderOps(),
+                                         provider_params, &provider);
+    umfLevelZeroMemoryProviderParamsDestroy(provider_params);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr,
                 "ERROR: Failed to create Level Zero memory provider!\n");
         return -1;
     }
 
+    umf_disjoint_pool_params_handle_t disjoint_params = NULL;
+    umf_result = umfDisjointPoolParamsCreate(&disjoint_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "ERROR: Failed to create pool params!\n");
+        goto provider_destroy;
+    }
+
     // create pool
     umf_pool_create_flags_t flags = UMF_POOL_CREATE_FLAG_OWN_PROVIDER;
-    umf_disjoint_pool_params_t disjoint_params = umfDisjointPoolParamsDefault();
-    umf_result = umfPoolCreate(umfDisjointPoolOps(), provider, &disjoint_params,
+    umf_result = umfPoolCreate(umfDisjointPoolOps(), provider, disjoint_params,
                                flags, pool);
+    umfDisjointPoolParamsDestroy(disjoint_params);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "ERROR: Failed to create pool!\n");
-        return -1;
+        goto provider_destroy;
     }
 
     return 0;
+
+provider_destroy:
+    umfMemoryProviderDestroy(provider);
+
+    return -1;
 }
 
 int main(void) {
@@ -58,7 +104,7 @@ int main(void) {
     const size_t BUFFER_PATTERN = 0x42;
     int ret = init_level_zero();
     if (ret != 0) {
-        fprintf(stderr, "ERROR: Failed to init Level 0!\n");
+        fprintf(stderr, "ERROR: Failed to init Level Zero!\n");
         return ret;
     }
 
@@ -134,14 +180,21 @@ int main(void) {
 
     fprintf(stdout, "Consumer pool created.\n");
 
+    umf_ipc_handler_handle_t ipc_handler = 0;
+    umf_result = umfPoolGetIPCHandler(consumer_pool, &ipc_handler);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "ERROR: Failed to get IPC handler!\n");
+        return -1;
+    }
+
     void *mapped_buf = NULL;
-    umf_result = umfOpenIPCHandle(consumer_pool, ipc_handle, &mapped_buf);
+    umf_result = umfOpenIPCHandle(ipc_handler, ipc_handle, &mapped_buf);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "ERROR: Failed to open IPC handle!\n");
         return -1;
     }
 
-    fprintf(stdout, "IPC handle opened in the consumer pool.\n");
+    fprintf(stdout, "IPC handle opened.\n");
 
     size_t *tmp_buf = malloc(BUFFER_SIZE);
     ret = level_zero_copy(consumer_context, device, tmp_buf, mapped_buf,
diff --git a/examples/level_zero_shared_memory/CMakeLists.txt b/examples/level_zero_shared_memory/CMakeLists.txt
new file mode 100644
index 000000000..3fd8da5ab
--- /dev/null
+++ b/examples/level_zero_shared_memory/CMakeLists.txt
@@ -0,0 +1,65 @@
+# 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
+
+cmake_minimum_required(VERSION 3.14.0 FATAL_ERROR)
+project(umf_example_level_zero_shared_memory LANGUAGES C)
+enable_testing()
+
+set(UMF_EXAMPLE_DIR "${CMAKE_SOURCE_DIR}/..")
+list(APPEND CMAKE_MODULE_PATH "${UMF_EXAMPLE_DIR}/cmake")
+message(STATUS "CMAKE_MODULE_PATH=${CMAKE_MODULE_PATH}")
+
+find_package(PkgConfig)
+pkg_check_modules(LIBUMF libumf)
+if(NOT LIBUMF_FOUND)
+    find_package(LIBUMF REQUIRED libumf)
+endif()
+
+pkg_check_modules(LIBHWLOC hwloc>=2.3.0)
+if(NOT LIBHWLOC_FOUND)
+    find_package(LIBHWLOC 2.3.0 REQUIRED hwloc)
+endif()
+
+pkg_check_modules(ZE_LOADER ze_loader)
+if(NOT ZE_LOADER_FOUND)
+    find_package(ZE_LOADER REQUIRED ze_loader)
+endif()
+
+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
+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} ${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(
+    NAME ${EXAMPLE_NAME}
+    COMMAND ${EXAMPLE_NAME}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+set_tests_properties(${EXAMPLE_NAME} PROPERTIES LABELS "example-standalone")
+
+if(LINUX)
+    # set LD_LIBRARY_PATH
+    string(JOIN ":" LEVEL_ZERO_SM_LIBRARY_DIRS_JOINED
+           ${LEVEL_ZERO_SM_LIBRARY_DIRS})
+    set_property(
+        TEST ${EXAMPLE_NAME}
+        PROPERTY
+            ENVIRONMENT_MODIFICATION
+            "LD_LIBRARY_PATH=path_list_append:${LEVEL_ZERO_SM_LIBRARY_DIRS_JOINED}"
+    )
+endif()
diff --git a/examples/gpu_shared_memory/gpu_shared_memory.c b/examples/level_zero_shared_memory/level_zero_shared_memory.c
similarity index 50%
rename from examples/gpu_shared_memory/gpu_shared_memory.c
rename to examples/level_zero_shared_memory/level_zero_shared_memory.c
index 8d34e0f59..605f239f8 100644
--- a/examples/gpu_shared_memory/gpu_shared_memory.c
+++ b/examples/level_zero_shared_memory/level_zero_shared_memory.c
@@ -1,17 +1,19 @@
 /*
  *
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  */
 
+#include <stdio.h>
+
 #include <umf/memory_pool.h>
 #include <umf/pools/pool_disjoint.h>
 #include <umf/providers/provider_level_zero.h>
 
-#include "utils_level_zero.h"
+#include "examples_level_zero_helpers.h"
 
 int main(void) {
     // A result object for storing UMF API result status
@@ -25,7 +27,7 @@ int main(void) {
     // Initialize Level Zero
     int ret = init_level_zero();
     if (ret != 0) {
-        fprintf(stderr, "Failed to init Level 0!\n");
+        fprintf(stderr, "Failed to init Level Zero!\n");
         return ret;
     }
 
@@ -49,22 +51,51 @@ int main(void) {
 
     // Setup parameters for the Level Zero memory provider. It will be used for
     // allocating memory from Level Zero devices.
-    level_zero_memory_provider_params_t ze_memory_provider_params;
-    ze_memory_provider_params.level_zero_context_handle = hContext;
-    ze_memory_provider_params.level_zero_device_handle = hDevice;
+    umf_level_zero_memory_provider_params_handle_t ze_memory_provider_params =
+        NULL;
+    res = umfLevelZeroMemoryProviderParamsCreate(&ze_memory_provider_params);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create memory provider params!\n");
+        ret = -1;
+        goto level_zero_destroy;
+    }
+
+    res = umfLevelZeroMemoryProviderParamsSetContext(ze_memory_provider_params,
+                                                     hContext);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set context in memory provider params!\n");
+        ret = -1;
+        goto provider_params_destroy;
+    }
+
+    res = umfLevelZeroMemoryProviderParamsSetDevice(ze_memory_provider_params,
+                                                    hDevice);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set device in memory provider params!\n");
+        ret = -1;
+        goto provider_params_destroy;
+    }
+
     // Set the memory type to shared to allow the memory to be accessed on both
     // CPU and GPU.
-    ze_memory_provider_params.memory_type = UMF_MEMORY_TYPE_SHARED;
+    res = umfLevelZeroMemoryProviderParamsSetMemoryType(
+        ze_memory_provider_params, UMF_MEMORY_TYPE_SHARED);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "Failed to set memory type in memory provider params!\n");
+        ret = -1;
+        goto provider_params_destroy;
+    }
 
     // Create Level Zero memory provider
     umf_memory_provider_handle_t ze_memory_provider;
-    res = umfMemoryProviderCreate(umfLevelZeroMemoryProviderOps(),
-                                  &ze_memory_provider_params,
-                                  &ze_memory_provider);
+    res =
+        umfMemoryProviderCreate(umfLevelZeroMemoryProviderOps(),
+                                ze_memory_provider_params, &ze_memory_provider);
     if (res != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "Failed to create a memory provider!\n");
         ret = -1;
-        goto level_zero_destroy;
+        goto provider_params_destroy;
     }
 
     printf("Level Zero memory provider created at %p\n",
@@ -72,34 +103,61 @@ int main(void) {
 
     // Setup parameters for the Disjoint Pool. It will be used for managing the
     // memory allocated using memory provider.
-    umf_disjoint_pool_params_t disjoint_memory_pool_params =
-        umfDisjointPoolParamsDefault();
+    umf_disjoint_pool_params_handle_t disjoint_memory_pool_params = NULL;
+    res = umfDisjointPoolParamsCreate(&disjoint_memory_pool_params);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create pool params!\n");
+        ret = -1;
+        goto memory_provider_destroy;
+    }
     // Set the Slab Min Size to 64KB - the page size for GPU allocations
-    disjoint_memory_pool_params.SlabMinSize = 64 * 1024L;
+    res = umfDisjointPoolParamsSetSlabMinSize(disjoint_memory_pool_params,
+                                              64 * 1024L);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set Slab Min Size!\n");
+        ret = -1;
+        goto disjoint_params_destroy;
+    }
     // We would keep only single slab per each allocation bucket
-    disjoint_memory_pool_params.Capacity = 1;
+    res = umfDisjointPoolParamsSetCapacity(disjoint_memory_pool_params, 1);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set Capacity!\n");
+        ret = -1;
+        goto disjoint_params_destroy;
+    }
     // Set the maximum poolable size to 64KB - objects with size above this
     // limit will not be stored/allocated from the pool.
-    disjoint_memory_pool_params.MaxPoolableSize = 64 * 1024L;
+    res = umfDisjointPoolParamsSetMaxPoolableSize(disjoint_memory_pool_params,
+                                                  64 * 1024L);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set Max Poolable Size!\n");
+        ret = -1;
+        goto disjoint_params_destroy;
+    }
     // Enable tracing
-    disjoint_memory_pool_params.PoolTrace = 1;
+    res = umfDisjointPoolParamsSetTrace(disjoint_memory_pool_params, 1);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set Trace!\n");
+        ret = -1;
+        goto disjoint_params_destroy;
+    }
 
     // Create Disjoint Pool memory pool.
     umf_memory_pool_handle_t ze_disjoint_memory_pool;
     res = umfPoolCreate(umfDisjointPoolOps(), ze_memory_provider,
-                        &disjoint_memory_pool_params, UMF_POOL_CREATE_FLAG_NONE,
+                        disjoint_memory_pool_params, UMF_POOL_CREATE_FLAG_NONE,
                         &ze_disjoint_memory_pool);
     if (res != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "Failed to create a memory pool!\n");
         ret = -1;
-        goto memory_provider_destroy;
+        goto disjoint_params_destroy;
     }
 
     printf("Disjoint Pool created at %p\n", (void *)ze_disjoint_memory_pool);
 
     // 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;
@@ -121,10 +179,16 @@ int main(void) {
 memory_pool_destroy:
     umfPoolDestroy(ze_disjoint_memory_pool);
 
+disjoint_params_destroy:
+    umfDisjointPoolParamsDestroy(disjoint_memory_pool_params);
+
 memory_provider_destroy:
     umfMemoryProviderDestroy(ze_memory_provider);
 
+provider_params_destroy:
+    umfLevelZeroMemoryProviderParamsDestroy(ze_memory_provider_params);
+
 level_zero_destroy:
-    ret = destroy_context(hContext);
+    destroy_context(hContext);
     return ret;
 }
diff --git a/examples/memspace_hmat/CMakeLists.txt b/examples/memspace_hmat/CMakeLists.txt
new file mode 100644
index 000000000..5f0fffaa1
--- /dev/null
+++ b/examples/memspace_hmat/CMakeLists.txt
@@ -0,0 +1,58 @@
+# Copyright (C) 2024 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+cmake_minimum_required(VERSION 3.14.0 FATAL_ERROR)
+project(umf_example_memspace_hmat LANGUAGES C)
+enable_testing()
+
+set(UMF_EXAMPLE_DIR "${CMAKE_SOURCE_DIR}/..")
+list(APPEND CMAKE_MODULE_PATH "${UMF_EXAMPLE_DIR}/cmake")
+message(STATUS "CMAKE_MODULE_PATH=${CMAKE_MODULE_PATH}")
+
+find_package(PkgConfig)
+pkg_check_modules(LIBUMF libumf)
+if(NOT LIBUMF_FOUND)
+    find_package(LIBUMF REQUIRED libumf)
+endif()
+
+pkg_check_modules(LIBHWLOC hwloc>=2.3.0)
+if(NOT LIBHWLOC_FOUND)
+    find_package(LIBHWLOC 2.3.0 REQUIRED hwloc)
+endif()
+
+pkg_check_modules(LIBNUMA numa)
+if(NOT LIBNUMA_FOUND)
+    find_package(LIBNUMA REQUIRED numa)
+endif()
+
+# build the example
+set(EXAMPLE_NAME umf_example_memspace_hmat)
+add_executable(${EXAMPLE_NAME} memspace_hmat.c)
+target_include_directories(${EXAMPLE_NAME} PRIVATE ${LIBUMF_INCLUDE_DIRS}
+                                                   ../common)
+target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS}
+                        ${LIBNUMA_LIBRARY_DIRS})
+target_link_libraries(
+    ${EXAMPLE_NAME} PRIVATE ${LIBUMF_LIBRARIES} ${LIBHWLOC_LIBRARIES}
+                            ${LIBNUMA_LIBRARIES})
+
+add_test(
+    NAME ${EXAMPLE_NAME}
+    COMMAND ${EXAMPLE_NAME}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+set(UMF_TEST_SKIP_RETURN_CODE 125)
+set_tests_properties(${EXAMPLE_NAME} PROPERTIES LABELS "example-standalone")
+set_tests_properties(${EXAMPLE_NAME} PROPERTIES SKIP_RETURN_CODE
+                                                ${UMF_TEST_SKIP_RETURN_CODE})
+
+if(LINUX)
+    # set LD_LIBRARY_PATH
+    set_property(
+        TEST ${EXAMPLE_NAME}
+        PROPERTY
+            ENVIRONMENT_MODIFICATION
+            "LD_LIBRARY_PATH=path_list_append:${LIBUMF_LIBRARY_DIRS};LD_LIBRARY_PATH=path_list_append:${LIBHWLOC_LIBRARY_DIRS};LD_LIBRARY_PATH=path_list_append:${LIBNUMA_LIBRARY_DIRS}"
+    )
+endif()
diff --git a/examples/memspace_hmat/memspace_hmat.c b/examples/memspace_hmat/memspace_hmat.c
new file mode 100644
index 000000000..9f3f8d17e
--- /dev/null
+++ b/examples/memspace_hmat/memspace_hmat.c
@@ -0,0 +1,135 @@
+/*
+ *
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+#include <umf/mempolicy.h>
+#include <umf/memspace.h>
+
+#include <numa.h>
+#include <numaif.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "examples_utils.h"
+
+// Function to create a memory provider which allocates memory from the specified NUMA node
+int createMemoryProvider(umf_memory_provider_handle_t *hProvider,
+                         umf_const_memspace_handle_t hMemspace) {
+    int ret = 0;
+    umf_result_t result;
+    umf_mempolicy_handle_t hPolicy = NULL;
+    if (hMemspace == NULL) {
+        fprintf(stderr, "Memspace is NULL - do you have HMAT enabled?\n");
+        return 1;
+    }
+    // Create a mempolicy - mempolicy defines how we want to use memory from memspace.
+    // In this example, we want to bind memory to the best node in the memspace,
+    // for the thread that allocates memory.
+    result = umfMempolicyCreate(UMF_MEMPOLICY_BIND, &hPolicy);
+    if (result != UMF_RESULT_SUCCESS) {
+        ret = -1;
+        fprintf(stderr, "umfMempolicyCreate failed.\n");
+        goto error_mempolicy;
+    }
+
+    // Create a memory provider using the memory space and memory policy
+    result = umfMemoryProviderCreateFromMemspace(hMemspace, hPolicy, hProvider);
+    if (result != UMF_RESULT_SUCCESS) {
+        ret = -1;
+        fprintf(stderr, "umfMemoryProviderCreateFromMemspace failed.\n");
+        goto error_provider;
+    }
+
+    // After creating the memory provider, we can destroy the mempolicy
+error_provider:
+    umfMempolicyDestroy(hPolicy);
+error_mempolicy:
+    return ret;
+}
+
+int main(void) {
+    umf_memory_provider_handle_t hProvider = NULL;
+    umf_result_t ret;
+    void *ptr = NULL;
+    size_t size = 1024;
+    size_t alignment = 64;
+
+    // Check if NUMA is available
+    if (numa_available() < 0) {
+        fprintf(stderr, "NUMA is not available on this system.\n");
+        return TEST_SKIP_ERROR_CODE;
+    }
+
+    // Create the memory provider that allocates memory from the highest bandwidth numa nodes
+    ret = createMemoryProvider(&hProvider, umfMemspaceHighestBandwidthGet());
+    if (ret != UMF_RESULT_SUCCESS) {
+        return ret == 1 ? TEST_SKIP_ERROR_CODE : -1;
+    }
+
+    // Allocate memory from the memory provider
+    ret = umfMemoryProviderAlloc(hProvider, size, alignment, &ptr);
+    if (ret != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "umfMemoryProviderAlloc failed.\n");
+        umfMemoryProviderDestroy(hProvider);
+        return -1;
+    }
+
+    // Use the allocated memory (ptr) here
+    memset(ptr, 1, size);
+
+    // Lets check the NUMA node of the allocated memory
+    int nodeId;
+    int retm = get_mempolicy(&nodeId, NULL, 0, ptr, MPOL_F_ADDR | MPOL_F_NODE);
+    if (retm != 0) {
+        fprintf(stderr, "get_mempolicy failed.\n");
+        umfMemoryProviderFree(hProvider, ptr, size);
+        umfMemoryProviderDestroy(hProvider);
+        return -1;
+    }
+
+    printf("Allocated memory at %p from the highest bandwidth node: %d\n", ptr,
+           nodeId);
+
+    // Free the allocated memory
+    umfMemoryProviderFree(hProvider, ptr, size);
+
+    umfMemoryProviderDestroy(hProvider);
+
+    // Lets now allocate memory from the lowest latency node
+    ret = createMemoryProvider(&hProvider, umfMemspaceLowestLatencyGet());
+    if (ret != UMF_RESULT_SUCCESS) {
+        return -1;
+    }
+
+    ret = umfMemoryProviderAlloc(hProvider, size, alignment, &ptr);
+
+    if (ret != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "umfMemoryProviderAlloc failed.\n");
+        umfMemoryProviderDestroy(hProvider);
+        return -1;
+    }
+
+    memset(ptr, 1, size);
+
+    retm = get_mempolicy(&nodeId, NULL, 0, ptr, MPOL_F_ADDR | MPOL_F_NODE);
+    if (retm != 0) {
+        fprintf(stderr, "get_mempolicy failed.\n");
+        umfMemoryProviderFree(hProvider, ptr, size);
+        umfMemoryProviderDestroy(hProvider);
+        return -1;
+    }
+    printf("Allocated memory at %p from the lowest latency node: %d\n", ptr,
+           nodeId);
+
+    // Free the allocated memory
+    umfMemoryProviderFree(hProvider, ptr, size);
+
+    umfMemoryProviderDestroy(hProvider);
+
+    return 0;
+}
diff --git a/examples/memspace_numa/CMakeLists.txt b/examples/memspace_numa/CMakeLists.txt
new file mode 100644
index 000000000..d9c41a843
--- /dev/null
+++ b/examples/memspace_numa/CMakeLists.txt
@@ -0,0 +1,58 @@
+# Copyright (C) 2024 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+cmake_minimum_required(VERSION 3.14.0 FATAL_ERROR)
+project(umf_example_memspace_numa LANGUAGES C)
+enable_testing()
+
+set(UMF_EXAMPLE_DIR "${CMAKE_SOURCE_DIR}/..")
+list(APPEND CMAKE_MODULE_PATH "${UMF_EXAMPLE_DIR}/cmake")
+message(STATUS "CMAKE_MODULE_PATH=${CMAKE_MODULE_PATH}")
+
+find_package(PkgConfig)
+pkg_check_modules(LIBUMF libumf)
+if(NOT LIBUMF_FOUND)
+    find_package(LIBUMF REQUIRED libumf)
+endif()
+
+pkg_check_modules(LIBHWLOC hwloc>=2.3.0)
+if(NOT LIBHWLOC_FOUND)
+    find_package(LIBHWLOC 2.3.0 REQUIRED hwloc)
+endif()
+
+pkg_check_modules(LIBNUMA numa)
+if(NOT LIBNUMA_FOUND)
+    find_package(LIBNUMA REQUIRED numa)
+endif()
+
+# build the example
+set(EXAMPLE_NAME umf_example_memspace_numa)
+add_executable(${EXAMPLE_NAME} memspace_numa.c)
+target_include_directories(${EXAMPLE_NAME} PRIVATE ${LIBUMF_INCLUDE_DIRS}
+                                                   ../common)
+target_link_directories(${EXAMPLE_NAME} PRIVATE ${LIBHWLOC_LIBRARY_DIRS}
+                        ${LIBNUMA_LIBRARY_DIRS})
+target_link_libraries(
+    ${EXAMPLE_NAME} PRIVATE ${LIBUMF_LIBRARIES} ${LIBHWLOC_LIBRARIES}
+                            ${LIBNUMA_LIBRARIES})
+
+add_test(
+    NAME ${EXAMPLE_NAME}
+    COMMAND ${EXAMPLE_NAME}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+set(UMF_TEST_SKIP_RETURN_CODE 125)
+set_tests_properties(${EXAMPLE_NAME} PROPERTIES LABELS "example-standalone")
+set_tests_properties(${EXAMPLE_NAME} PROPERTIES SKIP_RETURN_CODE
+                                                ${UMF_TEST_SKIP_RETURN_CODE})
+
+if(LINUX)
+    # set LD_LIBRARY_PATH
+    set_property(
+        TEST ${EXAMPLE_NAME}
+        PROPERTY
+            ENVIRONMENT_MODIFICATION
+            "LD_LIBRARY_PATH=path_list_append:${LIBUMF_LIBRARY_DIRS};LD_LIBRARY_PATH=path_list_append:${LIBHWLOC_LIBRARY_DIRS};LD_LIBRARY_PATH=path_list_append:${LIBNUMA_LIBRARY_DIRS}"
+    )
+endif()
diff --git a/examples/memspace_numa/memspace_numa.c b/examples/memspace_numa/memspace_numa.c
new file mode 100644
index 000000000..b0e399fb2
--- /dev/null
+++ b/examples/memspace_numa/memspace_numa.c
@@ -0,0 +1,185 @@
+/*
+ *
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+#include <numa.h>
+#include <numaif.h>
+#include <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
+// by using umfMemspaceCreateFromNumaArray
+int createMemoryProviderFromArray(umf_memory_provider_handle_t *hProvider,
+                                  unsigned numa) {
+    int ret = 0;
+    umf_result_t result;
+    umf_memspace_handle_t hMemspace = NULL;
+    umf_mempolicy_handle_t hPolicy = NULL;
+
+    // Create a memspace - memspace is a list of memory sources.
+    // In this example, we create a memspace that contains single numa node;
+    result = umfMemspaceCreateFromNumaArray(&numa, 1, &hMemspace);
+    if (result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "umfMemspaceCreateFromNumaArray() failed.\n");
+        return -1;
+    }
+
+    // Create a mempolicy - mempolicy defines how we want to use memory from memspace.
+    // In this example, we want to bind memory to the specified numa node.
+    result = umfMempolicyCreate(UMF_MEMPOLICY_BIND, &hPolicy);
+    if (result != UMF_RESULT_SUCCESS) {
+        ret = -1;
+        fprintf(stderr, "umfMempolicyCreate failed().\n");
+        goto error_memspace;
+    }
+
+    // Create a memory provider using the memory space and memory policy
+    result = umfMemoryProviderCreateFromMemspace(hMemspace, hPolicy, hProvider);
+    if (result != UMF_RESULT_SUCCESS) {
+        ret = -1;
+        fprintf(stderr, "umfMemoryProviderCreateFromMemspace failed().\n");
+        goto error_mempolicy;
+    }
+
+    // After creating the memory provider, we can destroy the memspace and mempolicy
+error_mempolicy:
+    umfMempolicyDestroy(hPolicy);
+error_memspace:
+    umfMemspaceDestroy(hMemspace);
+    return ret;
+}
+
+// Function to create a memory provider which allocates memory from the specified NUMA node
+// by using filter function.
+int createMemoryProviderByFilter(umf_memory_provider_handle_t *hProvider,
+                                 unsigned numa) {
+    int ret = 0;
+    umf_result_t result;
+    umf_memspace_handle_t hMemspace = NULL;
+    umf_mempolicy_handle_t hPolicy = NULL;
+
+    umf_const_memspace_handle_t hostAll = umfMemspaceHostAllGet();
+    if (!hostAll) {
+        fprintf(stderr, "umfMemspaceHostAllGet() failed\n");
+        return -1;
+    }
+
+    // umfMemspaceHostAllGet() return immutable memspace, so we need to create a mutable copy
+    result = umfMemspaceClone(hostAll, &hMemspace);
+    if (result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "umfMempolicyClone() failed.\n");
+        return -1;
+    }
+
+    // Filter the memspace to contain only the specified numa node
+    result = umfMemspaceFilterById(hMemspace, &numa, 1);
+    if (result != UMF_RESULT_SUCCESS) {
+        ret = -1;
+        fprintf(stderr, "umfMemspaceFilterById() failed.\n");
+        goto error_memspace;
+    }
+
+    // Create a mempolicy - mempolicy defines how we want to use memory from memspace.
+    // In this example, we want to bind memory to the specified numa node.
+    result = umfMempolicyCreate(UMF_MEMPOLICY_BIND, &hPolicy);
+    if (result != UMF_RESULT_SUCCESS) {
+        ret = -1;
+        fprintf(stderr, "umfMempolicyCreate() failed.\n");
+        goto error_memspace;
+    }
+    // Create a memory provider using the memory space and memory policy
+    result = umfMemoryProviderCreateFromMemspace(hMemspace, hPolicy, hProvider);
+    if (result != UMF_RESULT_SUCCESS) {
+        ret = -1;
+        fprintf(stderr, "umfMemoryProviderCreateFromMemspace() failed.\n");
+        goto error_mempolicy;
+    }
+
+    // After creating the memory provider, we can destroy the memspace and mempolicy
+error_mempolicy:
+    umfMempolicyDestroy(hPolicy);
+error_memspace:
+    umfMemspaceDestroy(hMemspace);
+    return ret;
+}
+
+int use_memory_provider(umf_memory_provider_handle_t hProvider) {
+    // Allocate memory from the memory provider
+    void *ptr = NULL;
+    size_t size = 1024;
+    size_t alignment = 64;
+
+    umf_result_t ret = umfMemoryProviderAlloc(hProvider, size, alignment, &ptr);
+    if (ret != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "umfMemoryProviderAlloc failed.\n");
+        return 1;
+    }
+
+    // Use the allocated memory (ptr) here
+    memset(ptr, 1, size);
+
+    // Lets check the NUMA node of the allocated memory
+    int nodeId;
+    int retm = get_mempolicy(&nodeId, NULL, 0, ptr, MPOL_F_ADDR | MPOL_F_NODE);
+    if (retm != 0) {
+        umfMemoryProviderFree(hProvider, ptr, size);
+        fprintf(stderr, "get_mempolicy failed.\n");
+        return 1;
+    }
+    printf("Allocated memory at %p from numa_node %d\n", ptr, nodeId);
+    // Free the allocated memory
+    umfMemoryProviderFree(hProvider, ptr, size);
+
+    return 0;
+}
+
+int main(void) {
+    umf_memory_provider_handle_t hProvider = NULL;
+    umf_result_t ret;
+
+    // Check if NUMA is available
+    if (numa_available() < 0) {
+        fprintf(stderr, "NUMA is not available on this system.\n");
+        return TEST_SKIP_ERROR_CODE;
+    }
+
+    // Create the memory provider that allocates memory from the specified NUMA node
+    // In this example, we allocate memory from the NUMA node 0
+    ret = createMemoryProviderFromArray(&hProvider, 0);
+    if (ret != UMF_RESULT_SUCCESS) {
+        return -1;
+    }
+
+    if (use_memory_provider(hProvider)) {
+        goto error;
+    }
+
+    umfMemoryProviderDestroy(hProvider);
+
+    // We can achieve the same result by using filter functions
+    ret = createMemoryProviderByFilter(&hProvider, 0);
+    if (ret != UMF_RESULT_SUCCESS) {
+        return -1;
+    }
+
+    if (use_memory_provider(hProvider)) {
+        goto error;
+    }
+
+    umfMemoryProviderDestroy(hProvider);
+    return 0;
+error:
+    umfMemoryProviderDestroy(hProvider);
+
+    return 1;
+}
diff --git a/include/umf.h b/include/umf.h
index 3e2d82799..57bebef8a 100644
--- a/include/umf.h
+++ b/include/umf.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
diff --git a/include/umf/base.h b/include/umf/base.h
index ecc0abf55..ab306870c 100644
--- a/include/umf/base.h
+++ b/include/umf/base.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -28,7 +28,7 @@ extern "C" {
 #define UMF_MINOR_VERSION(_ver) (_ver & 0x0000ffff)
 
 /// @brief Current version of the UMF headers
-#define UMF_VERSION_CURRENT UMF_MAKE_VERSION(0, 9)
+#define UMF_VERSION_CURRENT UMF_MAKE_VERSION(0, 11)
 
 /// @brief Operation results
 typedef enum umf_result_t {
@@ -43,10 +43,54 @@ typedef enum umf_result_t {
     UMF_RESULT_ERROR_INVALID_ALIGNMENT =
         4,                              ///< Invalid alignment of an argument
     UMF_RESULT_ERROR_NOT_SUPPORTED = 5, ///< Operation not supported
-
-    UMF_RESULT_ERROR_UNKNOWN = 0x7ffffffe ///< Unknown or internal error
+    UMF_RESULT_ERROR_USER_SPECIFIC =
+        6, ///< Failure in user provider code (i.e in user provided callback)
+    UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE =
+        7, ///< External required dependency is unavailable or missing
+    UMF_RESULT_ERROR_OUT_OF_RESOURCES = 8, ///< Out of internal resources
+    UMF_RESULT_ERROR_UNKNOWN = 0x7ffffffe  ///< Unknown error
 } umf_result_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/ipc.h b/include/umf/ipc.h
index ffe38bfc8..ab47b0971 100644
--- a/include/umf/ipc.h
+++ b/include/umf/ipc.h
@@ -19,6 +19,8 @@ extern "C" {
 
 typedef struct umf_ipc_data_t *umf_ipc_handle_t;
 
+typedef void *umf_ipc_handler_handle_t;
+
 ///
 /// @brief Returns the size of IPC handles for the specified pool.
 /// @param hPool [in] Pool handle
@@ -44,11 +46,11 @@ umf_result_t umfPutIPCHandle(umf_ipc_handle_t ipcHandle);
 
 ///
 /// @brief Open IPC handle retrieved by umfGetIPCHandle.
-/// @param hPool [in] Pool handle where to open the the IPC handle.
+/// @param hIPCHandler [in] IPC Handler handle used to open the IPC handle.
 /// @param ipcHandle [in] IPC handle.
 /// @param ptr [out] pointer to the memory in the current process.
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
-umf_result_t umfOpenIPCHandle(umf_memory_pool_handle_t hPool,
+umf_result_t umfOpenIPCHandle(umf_ipc_handler_handle_t hIPCHandler,
                               umf_ipc_handle_t ipcHandle, void **ptr);
 
 ///
@@ -57,6 +59,13 @@ umf_result_t umfOpenIPCHandle(umf_memory_pool_handle_t hPool,
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 umf_result_t umfCloseIPCHandle(void *ptr);
 
+/// @brief Get handle to the IPC handler from existing pool.
+/// @param hPool [in] Pool handle
+/// @param hIPCHandler [out] handle to the IPC handler
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfPoolGetIPCHandler(umf_memory_pool_handle_t hPool,
+                                  umf_ipc_handler_handle_t *hIPCHandler);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/umf/memory_pool.h b/include/umf/memory_pool.h
index a93d400f9..c9b02214e 100644
--- a/include/umf/memory_pool.h
+++ b/include/umf/memory_pool.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -11,6 +11,7 @@
 #define UMF_MEMORY_POOL_H 1
 
 #include <umf/base.h>
+#include <umf/memory_pool_ops.h>
 #include <umf/memory_provider.h>
 
 #ifdef __cplusplus
@@ -22,12 +23,6 @@ extern "C" {
 ///        functions
 typedef struct umf_memory_pool_t *umf_memory_pool_handle_t;
 
-/// @brief This structure comprises function pointers used by corresponding umfPool*
-///        calls. Each memory pool implementation should initialize all function
-///        pointers.
-///
-typedef struct umf_memory_pool_ops_t umf_memory_pool_ops_t;
-
 /// @brief Supported pool creation flags
 typedef enum umf_pool_create_flag_t {
     UMF_POOL_CREATE_FLAG_NONE =
@@ -56,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
@@ -111,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
@@ -140,7 +136,7 @@ umf_result_t umfFree(void *ptr);
 /// * Implementations *must* store the error code in thread-local
 ///   storage prior to returning NULL from the allocation functions.
 ///
-/// * If the last allocation/de-allocation operation succeeded, the value returned by
+/// * If the last allocation/deallocation operation succeeded, the value returned by
 ///   this function is unspecified.
 ///
 /// * The application *may* call this function from simultaneous threads.
@@ -170,6 +166,30 @@ 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
+/// @param tag tag to be set
+/// @param oldTag [out][optional] previous tag set on the memory pool
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfPoolSetTag(umf_memory_pool_handle_t hPool, void *tag,
+                           void **oldTag);
+
+///
+/// @brief Retrieve the tag associated with the memory pool or NULL if no tag is set.
+/// @param hPool specified memory pool
+/// @param tag [out] tag associated with the memory pool
+/// @return UMF_RESULT_SUCCESS on success.
+umf_result_t umfPoolGetTag(umf_memory_pool_handle_t hPool, void **tag);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/umf/memory_pool_ops.h b/include/umf/memory_pool_ops.h
index 67afdd166..7b03ec8d2 100644
--- a/include/umf/memory_pool_ops.h
+++ b/include/umf/memory_pool_ops.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -17,6 +17,11 @@
 extern "C" {
 #endif
 
+/// @brief Version of the Memory Pool ops structure.
+/// NOTE: This is equal to the latest UMF version, in which the ops structure
+/// has been modified.
+#define UMF_POOL_OPS_VERSION_CURRENT UMF_MAKE_VERSION(0, 12)
+
 ///
 /// @brief This structure comprises function pointers used by corresponding umfPool*
 /// calls. Each memory pool implementation should initialize all function
@@ -24,7 +29,7 @@ extern "C" {
 ///
 typedef struct umf_memory_pool_ops_t {
     /// Version of the ops structure.
-    /// Should be initialized using UMF_VERSION_CURRENT.
+    /// Should be initialized using UMF_POOL_OPS_VERSION_CURRENT.
     uint32_t version;
 
     ///
@@ -37,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
@@ -89,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
@@ -120,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 cec8edbcf..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
@@ -17,6 +17,23 @@
 extern "C" {
 #endif
 
+/// @brief Memory visibility mode
+typedef enum umf_memory_visibility_t {
+    UMF_MEM_MAP_PRIVATE = 1, ///< private memory mapping
+    UMF_MEM_MAP_SHARED,      ///< shared memory mapping (Linux only)
+} umf_memory_visibility_t;
+
+/// @brief Protection of the memory allocations
+typedef enum umf_mem_protection_flags_t {
+    UMF_PROTECTION_NONE = (1 << 0),  ///< Memory allocations can not be accessed
+    UMF_PROTECTION_READ = (1 << 1),  ///< Memory allocations can be read.
+    UMF_PROTECTION_WRITE = (1 << 2), ///< Memory allocations can be written.
+    UMF_PROTECTION_EXEC = (1 << 3),  ///< Memory allocations can be executed.
+    /// @cond
+    UMF_PROTECTION_MAX // must be the last one
+    /// @endcond
+} umf_mem_protection_flags_t;
+
 /// @brief A struct containing memory provider specific set of functions
 typedef struct umf_memory_provider_t *umf_memory_provider_handle_t;
 
@@ -28,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
@@ -108,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_gpu.h b/include/umf/memory_provider_gpu.h
new file mode 100644
index 000000000..cc3cc3e3e
--- /dev/null
+++ b/include/umf/memory_provider_gpu.h
@@ -0,0 +1,31 @@
+/*
+ *
+ * Copyright (C) 2023-2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+#ifndef UMF_MEMORY_PROVIDER_GPU_H
+#define UMF_MEMORY_PROVIDER_GPU_H 1
+
+#include <umf/memory_provider.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// @brief USM memory allocation type
+typedef enum umf_usm_memory_type_t {
+    UMF_MEMORY_TYPE_UNKNOWN = 0, ///< The memory pointed to is of unknown type
+    UMF_MEMORY_TYPE_HOST,        ///< The memory pointed to is a host allocation
+    UMF_MEMORY_TYPE_DEVICE, ///< The memory pointed to is a device allocation
+    UMF_MEMORY_TYPE_SHARED, ///< The memory pointed to is a shared ownership allocation
+} umf_usm_memory_type_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_MEMORY_PROVIDER_GPU_H */
diff --git a/include/umf/memory_provider_ops.h b/include/umf/memory_provider_ops.h
index a61e0aad0..8f383235c 100644
--- a/include/umf/memory_provider_ops.h
+++ b/include/umf/memory_provider_ops.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -16,125 +16,10 @@
 extern "C" {
 #endif
 
-///
-/// @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;
+/// @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, 12)
 
 ///
 /// @brief This structure comprises function pointers used by corresponding
@@ -143,7 +28,7 @@ typedef struct umf_memory_provider_ipc_ops_t {
 ///
 typedef struct umf_memory_provider_ops_t {
     /// Version of the ops structure.
-    /// Should be initialized using UMF_VERSION_CURRENT.
+    /// Should be initialized using UMF_PROVIDER_OPS_VERSION_CURRENT.
     uint32_t version;
 
     ///
@@ -152,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
@@ -226,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);
 
     ///
@@ -237,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 2d2d77728..4b4597ef3 100644
--- a/include/umf/memspace.h
+++ b/include/umf/memspace.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -14,6 +14,7 @@
 #include <umf/memory_pool.h>
 #include <umf/memory_provider.h>
 #include <umf/mempolicy.h>
+#include <umf/memtarget.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -57,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.
@@ -84,6 +86,106 @@ umf_const_memspace_handle_t umfMemspaceHighestBandwidthGet(void);
 ///
 umf_const_memspace_handle_t umfMemspaceLowestLatencyGet(void);
 
+/// \brief Creates new empty memspace, which can be populated with umfMemspaceMemtargetAdd()
+/// \param hMemspace [out] handle to the newly created memspace
+/// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+///
+umf_result_t umfMemspaceNew(umf_memspace_handle_t *hMemspace);
+
+/// \brief Returns number of memory targets in memspace.
+/// \param hMemspace handle to memspace
+/// \return number of memory targets in memspace
+///
+size_t umfMemspaceMemtargetNum(umf_const_memspace_handle_t hMemspace);
+
+/// \brief Returns memory target by index.
+/// \param hMemspace handle to memspace
+/// \param targetNum index of the memory target
+/// \return memory target handle on success or NULL on invalid input.
+///
+umf_const_memtarget_handle_t
+umfMemspaceMemtargetGet(umf_const_memspace_handle_t hMemspace,
+                        unsigned targetNum);
+
+/// \brief Adds memory target to memspace.
+///
+/// \details
+/// This function duplicates the memory target and then adds it to the memspace.
+/// This means that original memtarget handle and the handle of the duplicated memtarget are different
+/// and you cannot use it interchangeably.
+/// You can use `umfMemspaceMemtargetGet()` to retrieve new handle.
+///
+/// \param hMemspace handle to memspace
+/// \param hMemtarget handle to memory target
+/// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+///
+umf_result_t umfMemspaceMemtargetAdd(umf_memspace_handle_t hMemspace,
+                                     umf_const_memtarget_handle_t hMemtarget);
+
+/// \brief Removes memory target from memspace.
+///
+/// \param hMemspace handle to memspace
+/// \param hMemtarget handle to memory target
+/// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+///
+umf_result_t
+umfMemspaceMemtargetRemove(umf_memspace_handle_t hMemspace,
+                           umf_const_memtarget_handle_t hMemtarget);
+
+/// \brief Clones memspace.
+///
+/// \param hMemspace handle to memspace
+/// \param hNewMemspace [out] handle to the newly created memspace
+/// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+///
+umf_result_t umfMemspaceClone(umf_const_memspace_handle_t hMemspace,
+                              umf_memspace_handle_t *hNewMemspace);
+
+/// \brief Custom filter function for umfMemspaceUserFilter
+///
+/// \param hMemspace handle to memspace
+/// \param hMemtarget handle to memory target
+/// \param args user provided arguments
+/// \return zero if hMemtarget should be removed from memspace, positive otherwise, and negative on error
+///
+typedef int (*umf_memspace_filter_func_t)(
+    umf_const_memspace_handle_t hMemspace,
+    umf_const_memtarget_handle_t hMemtarget, void *args);
+
+/// \brief Removes all memory targets with non-matching numa node ids.
+///
+/// \param hMemspace handle to memspace
+/// \param ids array of numa node ids
+/// \param size size of the array
+/// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+/// If the error code is UMF_RESULT_UNKNOWN the memspace is corrupted, otherwise the memspace is not modified.
+///
+umf_result_t umfMemspaceFilterById(umf_memspace_handle_t hMemspace,
+                                   unsigned *ids, size_t size);
+
+/// \brief Filters out memory targets that capacity is less than specified size.
+///
+/// \param hMemspace handle to memspace
+/// \param size minimum capacity of memory target
+/// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+/// If the error code is UMF_RESULT_UNKNOWN the memspace is corrupted, otherwise the memspace is not modified.
+/// \details Negative values of size parameters are reserved for future
+/// extension of functionality of this function.
+///
+umf_result_t umfMemspaceFilterByCapacity(umf_memspace_handle_t hMemspace,
+                                         int64_t size);
+
+/// \brief Filters out memory targets based on user provided function
+///
+/// \param hMemspace handle to memspace
+/// \param filter user provided function
+/// \param args user provided arguments
+/// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+/// If the error code is UMF_RESULT_UNKNOWN the memspace is corrupted, otherwise the memspace is not modified.
+///
+umf_result_t umfMemspaceUserFilter(umf_memspace_handle_t hMemspace,
+                                   umf_memspace_filter_func_t filter,
+                                   void *args);
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/umf/memtarget.h b/include/umf/memtarget.h
new file mode 100644
index 000000000..55ca30919
--- /dev/null
+++ b/include/umf/memtarget.h
@@ -0,0 +1,53 @@
+/*
+ *
+ * Copyright (C) 2023-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+#ifndef UMF_MEMTARGET_H
+#define UMF_MEMTARGET_H 1
+
+#include <stddef.h>
+#include <umf/base.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct umf_memtarget_t *umf_memtarget_handle_t;
+typedef const struct umf_memtarget_t *umf_const_memtarget_handle_t;
+
+typedef enum umf_memtarget_type_t {
+    UMF_MEMTARGET_TYPE_UNKNOWN = 0,
+    UMF_MEMTARGET_TYPE_NUMA = 1,
+} umf_memtarget_type_t;
+
+/// \brief Gets the type of the memory target.
+/// \param hMemtarget handle to the memory target
+/// \param type [out] type of the memory target
+/// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfMemtargetGetType(umf_const_memtarget_handle_t hMemtarget,
+                                 umf_memtarget_type_t *type);
+
+/// \brief Get size of the memory target in bytes.
+/// \param hMemtarget handle to the memory target
+/// \param capacity [out] capacity of the memory target
+/// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfMemtargetGetCapacity(umf_const_memtarget_handle_t hMemtarget,
+                                     size_t *capacity);
+
+/// \brief Get physical ID of the memory target.
+/// \param hMemtarget handle to the memory target
+/// \param id [out] id of the memory target
+/// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfMemtargetGetId(umf_const_memtarget_handle_t hMemtarget,
+                               unsigned *id);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_MEMTARGET_H */
diff --git a/include/umf/pools/pool_disjoint.h b/include/umf/pools/pool_disjoint.h
index 2fe5355a2..9f467d9a6 100644
--- a/include/umf/pools/pool_disjoint.h
+++ b/include/umf/pools/pool_disjoint.h
@@ -1,6 +1,11 @@
-// Copyright (C) 2023-2024 Intel Corporation
-// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+/*
+ *
+ * Copyright (C) 2023-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
 
 #pragma once
 #ifdef __cplusplus
@@ -16,67 +21,93 @@ extern "C" {
 ///        i.e. if multiple pools use the same shared limits, sum of those pools'
 ///        sizes cannot exceed MaxSize.
 typedef struct umf_disjoint_pool_shared_limits_t
-    umf_disjoint_pool_shared_limits_t;
+    *umf_disjoint_pool_shared_limits_handle_t;
 
-/// @brief Create a pool limits struct
-/// @param MaxSize specifies hard limit for memory allocated from a provider
-/// @return pointer to created pool limits struct
-umf_disjoint_pool_shared_limits_t *
+struct umf_disjoint_pool_params_t;
+/// @brief handle to the parameters of the disjoint pool.
+typedef struct umf_disjoint_pool_params_t *umf_disjoint_pool_params_handle_t;
+
+/// @brief Create a pool limits struct.
+/// @param MaxSize specifies hard limit for memory allocated from a provider.
+/// @return handle to the created shared limits struct.
+umf_disjoint_pool_shared_limits_handle_t
 umfDisjointPoolSharedLimitsCreate(size_t MaxSize);
 
-/// @brief Destroy previously created pool limits struct
-/// @param PoolLimits pointer to a pool limits struct
-void umfDisjointPoolSharedLimitsDestroy(
-    umf_disjoint_pool_shared_limits_t *PoolLimits);
-
-/// @brief Configuration of Disjoint Pool
-typedef struct umf_disjoint_pool_params_t {
-    /// Minimum allocation size that will be requested from the system.
-    /// By default this is the minimum allocation size of each memory type.
-    size_t SlabMinSize;
-
-    /// Allocations up to this limit will be subject to chunking/pooling
-    size_t MaxPoolableSize;
-
-    /// When pooling, each bucket will hold a max of 'Capacity' unfreed slabs
-    size_t Capacity;
-
-    /// Holds the minimum bucket size valid for allocation of a memory type.
-    /// This value must be a power of 2.
-    size_t MinBucketSize;
-
-    /// Holds size of the pool managed by the allocator.
-    size_t CurPoolSize;
-
-    /// Whether to print pool usage statistics
-    int PoolTrace;
-
-    /// Memory limits that can be shared between multitple pool instances,
-    /// i.e. if multiple pools use the same SharedLimits sum of those pools'
-    /// sizes cannot exceed MaxSize.
-    umf_disjoint_pool_shared_limits_t *SharedLimits;
-
-    /// Name used in traces
-    const char *Name;
-} umf_disjoint_pool_params_t;
-
-umf_memory_pool_ops_t *umfDisjointPoolOps(void);
-
-/// @brief Create default params struct for disjoint pool
-static inline umf_disjoint_pool_params_t umfDisjointPoolParamsDefault(void) {
-    umf_disjoint_pool_params_t params = {
-        0,                                         /* SlabMinSize */
-        0,                                         /* MaxPoolableSize */
-        0,                                         /* Capacity */
-        UMF_DISJOINT_POOL_MIN_BUCKET_DEFAULT_SIZE, /* MinBucketSize */
-        0,                                         /* CurPoolSize */
-        0,                                         /* PoolTrace */
-        NULL,                                      /* SharedLimits */
-        "disjoint_pool"                            /* Name */
-    };
-
-    return params;
-}
+/// @brief Destroy previously created pool limits struct.
+/// @param hSharedLimits handle to the shared limits struct.
+/// @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.
+/// @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
+umfDisjointPoolParamsCreate(umf_disjoint_pool_params_handle_t *hParams);
+
+/// @brief  Destroy parameters struct.
+/// @param  hParams handle to the parameters of the disjoint pool.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfDisjointPoolParamsDestroy(umf_disjoint_pool_params_handle_t hParams);
+
+/// @brief Set minimum allocation size that will be requested from the memory provider.
+/// @param hParams handle to the parameters of the disjoint pool.
+/// @param slabMinSize minimum allocation size.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfDisjointPoolParamsSetSlabMinSize(umf_disjoint_pool_params_handle_t hParams,
+                                    size_t slabMinSize);
+
+/// @brief Set size limit for allocations that are subject to pooling.
+/// @param hParams handle to the parameters of the disjoint pool.
+/// @param maxPoolableSize maximum poolable size.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfDisjointPoolParamsSetMaxPoolableSize(
+    umf_disjoint_pool_params_handle_t hParams, size_t maxPoolableSize);
+
+/// @brief Set maximum capacity of each bucket. Each bucket will hold a
+///        max of \p maxCapacity unfreed slabs.
+/// @param hParams handle to the parameters of the disjoint pool.
+/// @param maxCapacity maximum capacity of each bucket.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfDisjointPoolParamsSetCapacity(umf_disjoint_pool_params_handle_t hParams,
+                                 size_t maxCapacity);
+
+/// @brief Set minimum bucket allocation size.
+/// @param hParams handle to the parameters of the disjoint pool.
+/// @param minBucketSize minimum bucket size. Must be power of 2.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfDisjointPoolParamsSetMinBucketSize(umf_disjoint_pool_params_handle_t hParams,
+                                      size_t minBucketSize);
+
+/// @brief Set trace level for pool usage statistics.
+/// @param hParams handle to the parameters of the disjoint pool.
+/// @param poolTrace trace level.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfDisjointPoolParamsSetTrace(umf_disjoint_pool_params_handle_t hParams,
+                              int poolTrace);
+
+/// @brief Set shared limits for disjoint pool.
+/// @param hParams handle to the parameters of the disjoint pool.
+/// @param hSharedLimits handle to the shared limits.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfDisjointPoolParamsSetSharedLimits(
+    umf_disjoint_pool_params_handle_t hParams,
+    umf_disjoint_pool_shared_limits_handle_t hSharedLimits);
+
+/// @brief Set custom name of the disjoint pool to be used in the traces.
+/// @param hParams handle to the parameters of the disjoint pool.
+/// @param name custom name of the pool. Name longer than 64 characters will be truncated.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfDisjointPoolParamsSetName(umf_disjoint_pool_params_handle_t hParams,
+                             const char *name);
+
+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 dfd75746b..8d5b090d6 100644
--- a/include/umf/pools/pool_jemalloc.h
+++ b/include/umf/pools/pool_jemalloc.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -14,16 +14,36 @@
 extern "C" {
 #endif
 
-#include <stdbool.h>
 #include <umf/memory_pool_ops.h>
 
-/// @brief Configuration of Jemalloc Pool
-typedef struct umf_jemalloc_pool_params_t {
-    /// Set to true if umfMemoryProviderFree() should never be called.
-    bool disable_provider_free;
-} umf_jemalloc_pool_params_t;
+struct umf_jemalloc_pool_params_t;
 
-umf_memory_pool_ops_t *umfJemallocPoolOps(void);
+/// @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 3b9945f0b..f93e8d38e 100644
--- a/include/umf/pools/pool_scalable.h
+++ b/include/umf/pools/pool_scalable.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -14,10 +14,48 @@
 extern "C" {
 #endif
 
+#include <stdbool.h>
+
 #include <umf/memory_pool.h>
 #include <umf/memory_provider.h>
 
-umf_memory_pool_ops_t *umfScalablePoolOps(void);
+struct umf_scalable_pool_params_t;
+
+/// @brief handle to the parameters of the scalable pool.
+typedef struct umf_scalable_pool_params_t *umf_scalable_pool_params_handle_t;
+
+/// @brief  Create a struct to store parameters of scalable 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
+umfScalablePoolParamsCreate(umf_scalable_pool_params_handle_t *hParams);
+
+/// @brief  Destroy parameters struct.
+/// @param  hParams handle to the parameters of the scalable pool.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfScalablePoolParamsDestroy(umf_scalable_pool_params_handle_t hParams);
+
+/// @brief  Set granularity of allocations that scalable pool requests from a memory provider.
+/// @param  hParams handle to the parameters of the scalable pool.
+/// @param  granularity granularity in bytes.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfScalablePoolParamsSetGranularity(umf_scalable_pool_params_handle_t hParams,
+                                    size_t granularity);
+
+/// @brief  Set if scalable pool should keep all memory allocated from memory provider till destruction.
+/// @param  hParams handle to the parameters of the scalable pool.
+/// @param  keepAllMemory \p true if the scalable pool should not call
+/// \p umfMemoryProviderFree until it is destroyed, \p false otherwise.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfScalablePoolParamsSetKeepAllMemory(umf_scalable_pool_params_handle_t hParams,
+                                      bool keepAllMemory);
+
+/// @brief  Return \p ops structure containing pointers to the scalable pool implementation.
+/// @return pointer to the \p umf_memory_pool_ops_t struct.
+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
new file mode 100644
index 000000000..0c07e7482
--- /dev/null
+++ b/include/umf/providers/provider_cuda.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#ifndef UMF_PROVIDER_CUDA_H
+#define UMF_PROVIDER_CUDA_H
+
+#include <umf/memory_provider_gpu.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct umf_cuda_memory_provider_params_t;
+
+typedef struct umf_cuda_memory_provider_params_t
+    *umf_cuda_memory_provider_params_handle_t;
+
+/// @brief  Create a struct to store parameters of the CUDA Memory Provider.
+/// @param  hParams [out] handle to the newly created parameters structure,
+///         initialized with the default (current) context and device ID.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfCUDAMemoryProviderParamsCreate(
+    umf_cuda_memory_provider_params_handle_t *hParams);
+
+/// @brief  Destroy parameters struct.
+/// @param  hParams handle to the parameters of the CUDA Memory Provider.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfCUDAMemoryProviderParamsDestroy(
+    umf_cuda_memory_provider_params_handle_t hParams);
+
+/// @brief  Set the CUDA context handle in the parameters struct.
+/// @param  hParams handle to the parameters of the CUDA Memory Provider.
+/// @param  hContext handle to the CUDA context.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfCUDAMemoryProviderParamsSetContext(
+    umf_cuda_memory_provider_params_handle_t hParams, void *hContext);
+
+/// @brief  Set the CUDA device handle in the parameters struct.
+/// @param  hParams handle to the parameters of the CUDA Memory Provider.
+/// @param  hDevice handle to the CUDA device.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfCUDAMemoryProviderParamsSetDevice(
+    umf_cuda_memory_provider_params_handle_t hParams, int hDevice);
+
+/// @brief  Set the memory type in the parameters struct.
+/// @param  hParams handle to the parameters of the CUDA Memory Provider.
+/// @param  memoryType memory type.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfCUDAMemoryProviderParamsSetMemoryType(
+    umf_cuda_memory_provider_params_handle_t hParams,
+    umf_usm_memory_type_t memoryType);
+
+/// @brief  Set the allocation flags in the parameters struct.
+/// @param  hParams handle to the parameters of the CUDA Memory Provider.
+/// @param  flags valid combination of CUDA allocation flags.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfCUDAMemoryProviderParamsSetAllocFlags(
+    umf_cuda_memory_provider_params_handle_t hParams, unsigned int flags);
+
+const umf_memory_provider_ops_t *umfCUDAMemoryProviderOps(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_PROVIDER_CUDA_H */
diff --git a/include/umf/providers/provider_devdax_memory.h b/include/umf/providers/provider_devdax_memory.h
new file mode 100644
index 000000000..91678ef7f
--- /dev/null
+++ b/include/umf/providers/provider_devdax_memory.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#ifndef UMF_DEVDAX_MEMORY_PROVIDER_H
+#define UMF_DEVDAX_MEMORY_PROVIDER_H
+
+#include <umf/providers/provider_os_memory.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// @cond
+#define UMF_DEVDAX_RESULTS_START_FROM 2000
+/// @endcond
+
+struct umf_devdax_memory_provider_params_t;
+
+typedef struct umf_devdax_memory_provider_params_t
+    *umf_devdax_memory_provider_params_handle_t;
+
+/// @brief  Create a struct to store parameters of the Devdax Memory Provider.
+/// @param  hParams [out] handle to the newly created parameters struct.
+/// @param  path [in] path of the device DAX.
+/// @param  size [in] size of the device DAX in bytes.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfDevDaxMemoryProviderParamsCreate(
+    umf_devdax_memory_provider_params_handle_t *hParams, const char *path,
+    size_t size);
+
+/// @brief  Destroy parameters struct.
+/// @param  hParams [in] handle to the parameters of the Devdax Memory Provider.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfDevDaxMemoryProviderParamsDestroy(
+    umf_devdax_memory_provider_params_handle_t hParams);
+
+/// @brief  Set a device DAX in the parameters struct. Overwrites the previous value.
+///         It provides an ability to use the same instance of params to create multiple
+///         instances of the provider for different DAX devices.
+/// @param  hParams [in] handle to the parameters of the Devdax Memory Provider.
+/// @param  path [in] path of the device DAX.
+/// @param  size [in] size of the device DAX in bytes.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfDevDaxMemoryProviderParamsSetDeviceDax(
+    umf_devdax_memory_provider_params_handle_t hParams, const char *path,
+    size_t size);
+
+/// @brief  Set the protection flags in the parameters struct.
+/// @param  hParams [in] handle to the parameters of the Devdax Memory Provider.
+/// @param  protection [in] combination of 'umf_mem_protection_flags_t' flags.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfDevDaxMemoryProviderParamsSetProtection(
+    umf_devdax_memory_provider_params_handle_t hParams, unsigned protection);
+
+/// @brief Devdax Memory Provider operation results
+typedef enum umf_devdax_memory_provider_native_error {
+    UMF_DEVDAX_RESULT_SUCCESS = UMF_DEVDAX_RESULTS_START_FROM, ///< Success
+    UMF_DEVDAX_RESULT_ERROR_ALLOC_FAILED,        ///< Memory allocation failed
+    UMF_DEVDAX_RESULT_ERROR_ADDRESS_NOT_ALIGNED, ///< Allocated address is not aligned
+    UMF_DEVDAX_RESULT_ERROR_FREE_FAILED,         ///< Memory deallocation failed
+    UMF_DEVDAX_RESULT_ERROR_PURGE_FORCE_FAILED, ///< Force purging failed
+} umf_devdax_memory_provider_native_error_t;
+
+const umf_memory_provider_ops_t *umfDevDaxMemoryProviderOps(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_DEVDAX_MEMORY_PROVIDER_H */
diff --git a/include/umf/providers/provider_file_memory.h b/include/umf/providers/provider_file_memory.h
new file mode 100644
index 000000000..fed5147cc
--- /dev/null
+++ b/include/umf/providers/provider_file_memory.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#ifndef UMF_FILE_MEMORY_PROVIDER_H
+#define UMF_FILE_MEMORY_PROVIDER_H
+
+#include <umf/providers/provider_os_memory.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// @cond
+#define UMF_FILE_RESULTS_START_FROM 3000
+/// @endcond
+
+struct umf_file_memory_provider_params_t;
+
+typedef struct umf_file_memory_provider_params_t
+    *umf_file_memory_provider_params_handle_t;
+
+/// @brief  Create a struct to store parameters of the File Memory Provider.
+/// @param  hParams [out] handle to the newly created parameters struct.
+/// @param  path path to the file.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfFileMemoryProviderParamsCreate(
+    umf_file_memory_provider_params_handle_t *hParams, const char *path);
+
+/// @brief  Destroy parameters struct.
+/// @param  hParams handle to the parameters of the File Memory Provider.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfFileMemoryProviderParamsDestroy(
+    umf_file_memory_provider_params_handle_t hParams);
+
+/// @brief  Set the path in the parameters struct.
+/// @param  hParams handle to the parameters of the File Memory Provider.
+/// @param  path path to the file.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfFileMemoryProviderParamsSetPath(
+    umf_file_memory_provider_params_handle_t hParams, const char *path);
+
+/// @brief  Set the protection in the parameters struct.
+/// @param  hParams handle to the parameters of the File Memory Provider.
+/// @param  protection protection. Combination of \p umf_mem_protection_flags_t flags
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfFileMemoryProviderParamsSetProtection(
+    umf_file_memory_provider_params_handle_t hParams, unsigned protection);
+
+/// @brief  Set the visibility in the parameters struct.
+/// @param  hParams handle to the parameters of the File Memory Provider.
+/// @param  visibility memory visibility mode.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfFileMemoryProviderParamsSetVisibility(
+    umf_file_memory_provider_params_handle_t hParams,
+    umf_memory_visibility_t visibility);
+
+/// @brief File Memory Provider operation results
+typedef enum umf_file_memory_provider_native_error {
+    UMF_FILE_RESULT_SUCCESS = UMF_FILE_RESULTS_START_FROM, ///< Success
+    UMF_FILE_RESULT_ERROR_ALLOC_FAILED,       ///< Memory allocation failed
+    UMF_FILE_RESULT_ERROR_FREE_FAILED,        ///< Memory deallocation failed
+    UMF_FILE_RESULT_ERROR_PURGE_FORCE_FAILED, ///< Force purging failed
+} umf_file_memory_provider_native_error_t;
+
+const umf_memory_provider_ops_t *umfFileMemoryProviderOps(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_FILE_MEMORY_PROVIDER_H */
diff --git a/include/umf/providers/provider_fixed_memory.h b/include/umf/providers/provider_fixed_memory.h
new file mode 100644
index 000000000..00273d565
--- /dev/null
+++ b/include/umf/providers/provider_fixed_memory.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#ifndef UMF_FIXED_MEMORY_PROVIDER_H
+#define UMF_FIXED_MEMORY_PROVIDER_H
+
+#include <umf/providers/provider_os_memory.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// @cond
+#define UMF_FIXED_RESULTS_START_FROM 4000
+/// @endcond
+
+struct umf_fixed_memory_provider_params_t;
+
+typedef struct umf_fixed_memory_provider_params_t
+    *umf_fixed_memory_provider_params_handle_t;
+
+/// @brief  Create a struct to store parameters of the Fixed Memory Provider.
+/// @param  hParams [out] handle to the newly created parameters struct.
+/// @param  ptr [in] pointer to the memory region.
+/// @param  size [in] size of the memory region in bytes.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfFixedMemoryProviderParamsCreate(
+    umf_fixed_memory_provider_params_handle_t *hParams, void *ptr, size_t size);
+
+/// @brief  Set the memory region in params struct. Overwrites the previous value.
+///         It provides an ability to use the same instance of params to create multiple
+///         instances of the provider for different memory regions.
+/// @param  hParams [in] handle to the parameters of the Fixed Memory Provider.
+/// @param  ptr [in] pointer to the memory region.
+/// @param  size [in] size of the memory region in bytes.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfFixedMemoryProviderParamsSetMemory(
+    umf_fixed_memory_provider_params_handle_t hParams, void *ptr, size_t size);
+
+/// @brief  Destroy parameters struct.
+/// @param  hParams [in] handle to the parameters of the Fixed Memory Provider.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfFixedMemoryProviderParamsDestroy(
+    umf_fixed_memory_provider_params_handle_t hParams);
+
+/// @brief Retrieve the operations structure for the Fixed Memory Provider.
+/// @return Pointer to the umf_memory_provider_ops_t structure.
+const umf_memory_provider_ops_t *umfFixedMemoryProviderOps(void);
+
+/// @brief Fixed Memory Provider operation results
+typedef enum umf_fixed_memory_provider_native_error {
+    UMF_FIXED_RESULT_SUCCESS = UMF_FIXED_RESULTS_START_FROM, ///< Success
+    UMF_FIXED_RESULT_ERROR_PURGE_FORCE_FAILED, ///< Force purging failed
+} umf_fixed_memory_provider_native_error_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_FIXED_MEMORY_PROVIDER_H */
diff --git a/include/umf/providers/provider_level_zero.h b/include/umf/providers/provider_level_zero.h
index f0c2acfbc..895922b4c 100644
--- a/include/umf/providers/provider_level_zero.h
+++ b/include/umf/providers/provider_level_zero.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -8,28 +8,90 @@
 #ifndef UMF_PROVIDER_LEVEL_ZERO_H
 #define UMF_PROVIDER_LEVEL_ZERO_H
 
-#include "umf/memory_provider.h"
+#include <umf/memory_provider_gpu.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/// @brief USM memory allocation type
-typedef enum umf_usm_memory_type_t {
-    UMF_MEMORY_TYPE_UNKNOWN = 0, ///< The memory pointed to is of unknown type
-    UMF_MEMORY_TYPE_HOST,        ///< The memory pointed to is a host allocation
-    UMF_MEMORY_TYPE_DEVICE, ///< The memory pointed to is a device allocation
-    UMF_MEMORY_TYPE_SHARED, ///< The memory pointed to is a shared ownership allocation
-} umf_usm_memory_type_t;
-
-/// @brief Level Zero Memory Provider settings struct
-typedef struct level_zero_memory_provider_params_t {
-    void *level_zero_context_handle;   ///< Handle to the Level Zero context
-    void *level_zero_device_handle;    ///< Handle to the Level Zero device
-    umf_usm_memory_type_t memory_type; ///< Allocation memory type
-} level_zero_memory_provider_params_t;
-
-umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void);
+typedef struct _ze_device_handle_t *ze_device_handle_t;
+typedef struct _ze_context_handle_t *ze_context_handle_t;
+
+struct umf_level_zero_memory_provider_params_t;
+
+/// @brief handle to the parameters of the Level Zero Memory Provider.
+typedef struct umf_level_zero_memory_provider_params_t
+    *umf_level_zero_memory_provider_params_handle_t;
+
+/// @brief  Create a struct to store parameters of the Level Zero Memory Provider.
+/// @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 umfLevelZeroMemoryProviderParamsCreate(
+    umf_level_zero_memory_provider_params_handle_t *hParams);
+
+/// @brief  Destroy parameters struct.
+/// @param  hParams handle to the parameters of the Level Zero Memory Provider.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfLevelZeroMemoryProviderParamsDestroy(
+    umf_level_zero_memory_provider_params_handle_t hParams);
+
+/// @brief  Set the Level Zero context handle in the parameters struct.
+/// @param  hParams handle to the parameters of the Level Zero Memory Provider.
+/// @param  hContext handle to the Level Zero context. Cannot be \p NULL.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfLevelZeroMemoryProviderParamsSetContext(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    ze_context_handle_t hContext);
+
+/// @brief  Set the Level Zero device handle in the parameters struct.
+/// @param  hParams handle to the parameters of the Level Zero Memory Provider.
+/// @param  hDevice handle to the Level Zero device. Can be \p NULL if memory type is \p UMF_MEMORY_TYPE_HOST.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfLevelZeroMemoryProviderParamsSetDevice(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    ze_device_handle_t hDevice);
+
+/// @brief  Set the memory type in the parameters struct.
+/// @param  hParams handle to the parameters of the Level Zero Memory Provider.
+/// @param  memoryType memory type.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfLevelZeroMemoryProviderParamsSetMemoryType(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    umf_usm_memory_type_t memoryType);
+
+/// @brief  Set the resident devices in the parameters struct.
+/// @param  hParams handle to the parameters of the Level Zero Memory Provider.
+/// @param  hDevices array of devices for which the memory should be made resident.
+/// @param  deviceCount number of devices for which the memory should be made resident.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfLevelZeroMemoryProviderParamsSetResidentDevices(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    ze_device_handle_t *hDevices, uint32_t deviceCount);
+
+typedef enum umf_level_zero_memory_provider_free_policy_t {
+    UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFAULT =
+        0, ///< Free memory immediately. Default.
+    UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_BLOCKING_FREE, ///< Blocks until all commands using the memory are complete before freeing.
+    UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFER_FREE, ///< Schedules the memory to be freed but does not free immediately.
+} umf_level_zero_memory_provider_free_policy_t;
+
+/// @brief  Set the memory free policy.
+/// @param  hParams handle to the parameters of the Level Zero Memory Provider.
+/// @param  policy memory free policy.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfLevelZeroMemoryProviderParamsSetFreePolicy(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    umf_level_zero_memory_provider_free_policy_t policy);
+
+/// @brief  Set the device ordinal in the parameters struct.
+/// @param  hParams handle to the parameters of the Level Zero Memory Provider.
+/// @param  deviceOrdinal device ordinal.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    uint32_t deviceOrdinal);
+
+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 1d4494547..17bea65b0 100644
--- a/include/umf/providers/provider_os_memory.h
+++ b/include/umf/providers/provider_os_memory.h
@@ -1,9 +1,11 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ *
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-*/
+ *
+ */
 
 #ifndef UMF_OS_MEMORY_PROVIDER_H
 #define UMF_OS_MEMORY_PROVIDER_H
@@ -18,29 +20,12 @@ extern "C" {
 #define UMF_OS_RESULTS_START_FROM 1000
 /// @endcond
 
-/// @brief Protection of the memory allocations
-typedef enum umf_mem_protection_flags_t {
-    UMF_PROTECTION_NONE = (1 << 0),  ///< Memory allocations can not be accessed
-    UMF_PROTECTION_READ = (1 << 1),  ///< Memory allocations can be read.
-    UMF_PROTECTION_WRITE = (1 << 2), ///< Memory allocations can be written.
-    UMF_PROTECTION_EXEC = (1 << 3),  ///< Memory allocations can be executed.
-    /// @cond
-    UMF_PROTECTION_MAX // must be the last one
-    /// @endcond
-} umf_mem_protection_flags_t;
-
-/// @brief Memory visibility mode
-typedef enum umf_memory_visibility_t {
-    UMF_MEM_MAP_PRIVATE = 1, ///< private memory mapping
-    UMF_MEM_MAP_SHARED, ///< shared memory mapping (supported on Linux only)
-} umf_memory_visibility_t;
-
 /// @brief Memory binding mode
 /// Specifies how memory is bound to NUMA nodes on systems that support NUMA.
 /// Not every mode is supported on every system.
 typedef enum umf_numa_mode_t {
     /// Default binding mode. Actual binding policy is system-specific. On
-    /// linux this corresponds to MPOL_DEFAULT. If this mode is specified,
+    /// Linux this corresponds to MPOL_DEFAULT. If this mode is specified,
     /// nodemask must be NULL and maxnode must be 0.
     UMF_NUMA_MODE_DEFAULT,
 
@@ -77,32 +62,77 @@ typedef struct umf_numa_split_partition_t {
     unsigned target;
 } umf_numa_split_partition_t;
 
-/// @brief Memory provider settings struct
-typedef struct umf_os_memory_provider_params_t {
-    /// Combination of 'umf_mem_protection_flags_t' flags
-    unsigned protection;
-    /// memory visibility mode
-    umf_memory_visibility_t visibility;
-    /// (optional) a name of a shared memory file (valid only in case of the shared memory visibility)
-    char *shm_name;
-
-    // NUMA config
-    /// ordered list of numa nodes
-    unsigned *numa_list;
-    /// length of numa_list
-    unsigned numa_list_len;
-
-    /// Describes how node list is interpreted
-    umf_numa_mode_t numa_mode;
-    /// part size for interleave mode - 0 means default (system specific)
-    /// It might be rounded up because of HW constraints
-    size_t part_size;
-
-    /// ordered list of the partitions for the split mode
-    umf_numa_split_partition_t *partitions;
-    /// len of the partitions array
-    unsigned partitions_len;
-} umf_os_memory_provider_params_t;
+struct umf_os_memory_provider_params_t;
+
+typedef struct umf_os_memory_provider_params_t
+    *umf_os_memory_provider_params_handle_t;
+
+/// @brief  Create a struct to store parameters of the OS memory provider.
+/// @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 umfOsMemoryProviderParamsCreate(
+    umf_os_memory_provider_params_handle_t *hParams);
+
+/// @brief  Destroy parameters struct.
+/// @param  hParams handle to the parameters of the OS memory provider.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfOsMemoryProviderParamsDestroy(
+    umf_os_memory_provider_params_handle_t hParams);
+
+/// @brief  Set protection flags for the OS memory provider.
+/// @param  hParams handle to the parameters of the OS memory provider.
+/// @param  protection combination of \p umf_mem_protection_flags_t flags.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfOsMemoryProviderParamsSetProtection(
+    umf_os_memory_provider_params_handle_t hParams, unsigned protection);
+
+/// @brief  Set visibility mode for the OS memory provider.
+/// @param  hParams handle to the parameters of the OS memory provider.
+/// @param  visibility memory visibility mode.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfOsMemoryProviderParamsSetVisibility(
+    umf_os_memory_provider_params_handle_t hParams,
+    umf_memory_visibility_t visibility);
+
+/// @brief  Set a name of a shared memory file for the OS memory provider.
+/// @param  hParams handle to the parameters of the OS memory provider.
+/// @param  shm_name a name of a shared memory file.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfOsMemoryProviderParamsSetShmName(
+    umf_os_memory_provider_params_handle_t hParams, const char *shm_name);
+
+/// @brief  Set NUMA nodes for the OS memory provider.
+/// @param  hParams handle to the parameters of the OS memory provider.
+/// @param  numa_list ordered list of NUMA nodes.
+/// @param  numa_list_len length of the numa_list.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfOsMemoryProviderParamsSetNumaList(
+    umf_os_memory_provider_params_handle_t hParams, unsigned *numa_list,
+    unsigned numa_list_len);
+
+/// @brief  Set NUMA mode for the OS memory provider.
+/// @param  hParams handle to the parameters of the OS memory provider.
+/// @param  numa_mode NUMA mode. Describes how node list is interpreted.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfOsMemoryProviderParamsSetNumaMode(
+    umf_os_memory_provider_params_handle_t hParams, umf_numa_mode_t numa_mode);
+
+/// @brief  Set part size for the interleave mode. 0 means default (system specific)
+///         It might be rounded up because of HW constraints.
+/// @param  hParams handle to the parameters of the OS memory provider.
+/// @param  part_size part size for interleave mode.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfOsMemoryProviderParamsSetPartSize(
+    umf_os_memory_provider_params_handle_t hParams, size_t part_size);
+
+/// @brief  Set partitions for the split mode.
+/// @param  hParams handle to the parameters of the OS memory provider.
+/// @param  partitions ordered list of the partitions for the split mode.
+/// @param  partitions_len length of the partitions array.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfOsMemoryProviderParamsSetPartitions(
+    umf_os_memory_provider_params_handle_t hParams,
+    umf_numa_split_partition_t *partitions, unsigned partitions_len);
 
 /// @brief OS Memory Provider operation results
 typedef enum umf_os_memory_provider_native_error {
@@ -116,24 +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);
-
-/// @brief Create default params for os memory provider
-static inline umf_os_memory_provider_params_t
-umfOsMemoryProviderParamsDefault(void) {
-    umf_os_memory_provider_params_t params = {
-        UMF_PROTECTION_READ | UMF_PROTECTION_WRITE, /* protection */
-        UMF_MEM_MAP_PRIVATE,                        /* visibility mode */
-        NULL, /* (optional) a name of a shared memory file (valid only in case of the shared memory visibility) */
-        NULL, /* numa_list */
-        0,    /* numa_list_len */
-        UMF_NUMA_MODE_DEFAULT, /* numa_mode */
-        0,                     /* part_size */
-        NULL,                  /* partitions */
-        0};                    /* partitions_len*/
-
-    return params;
-}
+const umf_memory_provider_ops_t *umfOsMemoryProviderOps(void);
 
 #ifdef __cplusplus
 }
diff --git a/licensing/third-party-programs.txt b/licensing/third-party-programs.txt
index 54520c141..8ee09e2e9 100644
--- a/licensing/third-party-programs.txt
+++ b/licensing/third-party-programs.txt
@@ -422,4 +422,544 @@ _______________________________________________________________________________
 
 _______________________________________________________________________________
 
+8. uthash:
+
+  Copyright (c) 2005-2018, Troy D. Hanson  http://troydhanson.github.com/uthash/
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+      * Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+  PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+  OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+_______________________________________________________________________________
+
+9. google benchmark
+
+   Copyright 2015 Google Inc. All rights reserved.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+   
+_______________________________________________________________________________
+
+9. NVIDIA runtime headers
+
+  Preface
+  -------
+
+  The Software License Agreement in Chapter 1 and the Supplement
+  in Chapter 2 contain license terms and conditions that govern
+  the use of NVIDIA software. By accepting this agreement, you
+  agree to comply with all the terms and conditions applicable
+  to the product(s) included herein.
+
+  1. License Agreement for NVIDIA Software Development Kits
+  ---------------------------------------------------------
+
+
+  Release Date: July 26, 2018
+  ---------------------------
+
+
+  Important NoticeRead before downloading, installing,
+  copying or using the licensed software:
+  -------------------------------------------------------
+
+  This license agreement, including exhibits attached
+  ("Agreement”) is a legal agreement between you and NVIDIA
+  Corporation ("NVIDIA") and governs your use of a NVIDIA
+  software development kit (“SDK”).
+
+  Each SDK has its own set of software and materials, but here
+  is a description of the types of items that may be included in
+  a SDK: source code, header files, APIs, data sets and assets
+  (examples include images, textures, models, scenes, videos,
+  native API input/output files), binary software, sample code,
+  libraries, utility programs, programming code and
+  documentation.
+
+  This Agreement can be accepted only by an adult of legal age
+  of majority in the country in which the SDK is used.
+
+  If you are entering into this Agreement on behalf of a company
+  or other legal entity, you represent that you have the legal
+  authority to bind the entity to this Agreement, in which case
+  “you” will mean the entity you represent.
+
+  If you don’t have the required age or authority to accept
+  this Agreement, or if you don’t accept all the terms and
+  conditions of this Agreement, do not download, install or use
+  the SDK.
+
+  You agree to use the SDK only for purposes that are permitted
+  by (a) this Agreement, and (b) any applicable law, regulation
+  or generally accepted practices or guidelines in the relevant
+  jurisdictions.
+
+
+  1.1. License
+
+
+  1.1.1. License Grant
+
+  Subject to the terms of this Agreement, NVIDIA hereby grants
+  you a non-exclusive, non-transferable license, without the
+  right to sublicense (except as expressly provided in this
+  Agreement) to:
+
+    1. Install and use the SDK,
+
+    2. Modify and create derivative works of sample source code
+      delivered in the SDK, and
+
+    3. Distribute those portions of the SDK that are identified
+      in this Agreement as distributable, as incorporated in
+      object code format into a software application that meets
+      the distribution requirements indicated in this Agreement.
+
+
+  1.1.2. Distribution Requirements
+
+  These are the distribution requirements for you to exercise
+  the distribution grant:
+
+    1. Your application must have material additional
+      functionality, beyond the included portions of the SDK.
+
+    2. The distributable portions of the SDK shall only be
+      accessed by your application.
+
+    3. The following notice shall be included in modifications
+      and derivative works of sample source code distributed:
+      “This software contains source code provided by NVIDIA
+      Corporation.”
+
+    4. Unless a developer tool is identified in this Agreement
+      as distributable, it is delivered for your internal use
+      only.
+
+    5. The terms under which you distribute your application
+      must be consistent with the terms of this Agreement,
+      including (without limitation) terms relating to the
+      license grant and license restrictions and protection of
+      NVIDIA’s intellectual property rights. Additionally, you
+      agree that you will protect the privacy, security and
+      legal rights of your application users.
+
+    6. You agree to notify NVIDIA in writing of any known or
+      suspected distribution or use of the SDK not in compliance
+      with the requirements of this Agreement, and to enforce
+      the terms of your agreements with respect to distributed
+      SDK.
+
+
+  1.1.3. Authorized Users
+
+  You may allow employees and contractors of your entity or of
+  your subsidiary(ies) to access and use the SDK from your
+  secure network to perform work on your behalf.
+
+  If you are an academic institution you may allow users
+  enrolled or employed by the academic institution to access and
+  use the SDK from your secure network.
+
+  You are responsible for the compliance with the terms of this
+  Agreement by your authorized users. If you become aware that
+  your authorized users didn’t follow the terms of this
+  Agreement, you agree to take reasonable steps to resolve the
+  non-compliance and prevent new occurrences.
+
+
+  1.1.4. Pre-Release SDK
+
+  The SDK versions identified as alpha, beta, preview or
+  otherwise as pre-release, may not be fully functional, may
+  contain errors or design flaws, and may have reduced or
+  different security, privacy, accessibility, availability, and
+  reliability standards relative to commercial versions of
+  NVIDIA software and materials. Use of a pre-release SDK may
+  result in unexpected results, loss of data, project delays or
+  other unpredictable damage or loss.
+
+  You may use a pre-release SDK at your own risk, understanding
+  that pre-release SDKs are not intended for use in production
+  or business-critical systems.
+
+  NVIDIA may choose not to make available a commercial version
+  of any pre-release SDK. NVIDIA may also choose to abandon
+  development and terminate the availability of a pre-release
+  SDK at any time without liability.
+
+
+  1.1.5. Updates
+
+  NVIDIA may, at its option, make available patches, workarounds
+  or other updates to this SDK. Unless the updates are provided
+  with their separate governing terms, they are deemed part of
+  the SDK licensed to you as provided in this Agreement. You
+  agree that the form and content of the SDK that NVIDIA
+  provides may change without prior notice to you. While NVIDIA
+  generally maintains compatibility between versions, NVIDIA may
+  in some cases make changes that introduce incompatibilities in
+  future versions of the SDK.
+
+
+  1.1.6. Third Party Licenses
+
+  The SDK may come bundled with, or otherwise include or be
+  distributed with, third party software licensed by a NVIDIA
+  supplier and/or open source software provided under an open
+  source license. Use of third party software is subject to the
+  third-party license terms, or in the absence of third party
+  terms, the terms of this Agreement. Copyright to third party
+  software is held by the copyright holders indicated in the
+  third-party software or license.
+
+
+  1.1.7. Reservation of Rights
+
+  NVIDIA reserves all rights, title, and interest in and to the
+  SDK, not expressly granted to you under this Agreement.
+
+
+  1.2. Limitations
+
+  The following license limitations apply to your use of the
+  SDK:
+
+    1. You may not reverse engineer, decompile or disassemble,
+      or remove copyright or other proprietary notices from any
+      portion of the SDK or copies of the SDK.
+
+    2. Except as expressly provided in this Agreement, you may
+      not copy, sell, rent, sublicense, transfer, distribute,
+      modify, or create derivative works of any portion of the
+      SDK. For clarity, you may not distribute or sublicense the
+      SDK as a stand-alone product.
+
+    3. Unless you have an agreement with NVIDIA for this
+      purpose, you may not indicate that an application created
+      with the SDK is sponsored or endorsed by NVIDIA.
+
+    4. You may not bypass, disable, or circumvent any
+      encryption, security, digital rights management or
+      authentication mechanism in the SDK.
+
+    5. You may not use the SDK in any manner that would cause it
+      to become subject to an open source software license. As
+      examples, licenses that require as a condition of use,
+      modification, and/or distribution that the SDK be:
+
+        a. Disclosed or distributed in source code form;
+
+        b. Licensed for the purpose of making derivative works;
+          or
+
+        c. Redistributable at no charge.
+
+    6. Unless you have an agreement with NVIDIA for this
+      purpose, you may not use the SDK with any system or
+      application where the use or failure of the system or
+      application can reasonably be expected to threaten or
+      result in personal injury, death, or catastrophic loss.
+      Examples include use in avionics, navigation, military,
+      medical, life support or other life critical applications.
+      NVIDIA does not design, test or manufacture the SDK for
+      these critical uses and NVIDIA shall not be liable to you
+      or any third party, in whole or in part, for any claims or
+      damages arising from such uses.
+
+    7. You agree to defend, indemnify and hold harmless NVIDIA
+      and its affiliates, and their respective employees,
+      contractors, agents, officers and directors, from and
+      against any and all claims, damages, obligations, losses,
+      liabilities, costs or debt, fines, restitutions and
+      expenses (including but not limited to attorney’s fees
+      and costs incident to establishing the right of
+      indemnification) arising out of or related to your use of
+      the SDK outside of the scope of this Agreement, or not in
+      compliance with its terms.
+
+
+  1.3. Ownership
+
+    1.  NVIDIA or its licensors hold all rights, title and
+      interest in and to the SDK and its modifications and
+      derivative works, including their respective intellectual
+      property rights, subject to your rights described in this
+      section. This SDK may include software and materials from
+      NVIDIA’s licensors, and these licensors are intended
+      third party beneficiaries that may enforce this Agreement
+      with respect to their intellectual property rights.
+
+    2.  You hold all rights, title and interest in and to your
+      applications and your derivative works of the sample
+      source code delivered in the SDK, including their
+      respective intellectual property rights, subject to
+      NVIDIA’s rights described in this section.
+
+    3. You may, but don’t have to, provide to NVIDIA
+      suggestions, feature requests or other feedback regarding
+      the SDK, including possible enhancements or modifications
+      to the SDK. For any feedback that you voluntarily provide,
+      you hereby grant NVIDIA and its affiliates a perpetual,
+      non-exclusive, worldwide, irrevocable license to use,
+      reproduce, modify, license, sublicense (through multiple
+      tiers of sublicensees), and distribute (through multiple
+      tiers of distributors) it without the payment of any
+      royalties or fees to you. NVIDIA will use feedback at its
+      choice. NVIDIA is constantly looking for ways to improve
+      its products, so you may send feedback to NVIDIA through
+      the developer portal at https://developer.nvidia.com.
+
+
+  1.4. No Warranties
+
+  THE SDK IS PROVIDED BY NVIDIA “AS IS” AND “WITH ALL
+  FAULTS.” TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND
+  ITS AFFILIATES EXPRESSLY DISCLAIM ALL WARRANTIES OF ANY KIND
+  OR NATURE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING,
+  BUT NOT LIMITED TO, ANY WARRANTIES OF MERCHANTABILITY, FITNESS
+  FOR A PARTICULAR PURPOSE, TITLE, NON-INFRINGEMENT, OR THE
+  ABSENCE OF ANY DEFECTS THEREIN, WHETHER LATENT OR PATENT. NO
+  WARRANTY IS MADE ON THE BASIS OF TRADE USAGE, COURSE OF
+  DEALING OR COURSE OF TRADE.
+
+
+  1.5. Limitation of Liability
+
+  TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND ITS
+  AFFILIATES SHALL NOT BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
+  PUNITIVE OR CONSEQUENTIAL DAMAGES, OR ANY LOST PROFITS, LOSS
+  OF USE, LOSS OF DATA OR LOSS OF GOODWILL, OR THE COSTS OF
+  PROCURING SUBSTITUTE PRODUCTS, ARISING OUT OF OR IN CONNECTION
+  WITH THIS AGREEMENT OR THE USE OR PERFORMANCE OF THE SDK,
+  WHETHER SUCH LIABILITY ARISES FROM ANY CLAIM BASED UPON BREACH
+  OF CONTRACT, BREACH OF WARRANTY, TORT (INCLUDING NEGLIGENCE),
+  PRODUCT LIABILITY OR ANY OTHER CAUSE OF ACTION OR THEORY OF
+  LIABILITY. IN NO EVENT WILL NVIDIA’S AND ITS AFFILIATES
+  TOTAL CUMULATIVE LIABILITY UNDER OR ARISING OUT OF THIS
+  AGREEMENT EXCEED US$10.00. THE NATURE OF THE LIABILITY OR THE
+  NUMBER OF CLAIMS OR SUITS SHALL NOT ENLARGE OR EXTEND THIS
+  LIMIT.
+
+  These exclusions and limitations of liability shall apply
+  regardless if NVIDIA or its affiliates have been advised of
+  the possibility of such damages, and regardless of whether a
+  remedy fails its essential purpose. These exclusions and
+  limitations of liability form an essential basis of the
+  bargain between the parties, and, absent any of these
+  exclusions or limitations of liability, the provisions of this
+  Agreement, including, without limitation, the economic terms,
+  would be substantially different.
+
+
+  1.6. Termination
+
+    1. This Agreement will continue to apply until terminated by
+      either you or NVIDIA as described below.
+
+    2. If you want to terminate this Agreement, you may do so by
+      stopping to use the SDK.
+
+    3. NVIDIA may, at any time, terminate this Agreement if:
+
+        a. (i) you fail to comply with any term of this
+          Agreement and the non-compliance is not fixed within
+          thirty (30) days following notice from NVIDIA (or
+          immediately if you violate NVIDIA’s intellectual
+          property rights);
+
+        b. (ii) you commence or participate in any legal
+          proceeding against NVIDIA with respect to the SDK; or
+
+        c. (iii) NVIDIA decides to no longer provide the SDK in
+          a country or, in NVIDIA’s sole discretion, the
+          continued use of it is no longer commercially viable.
+
+    4. Upon any termination of this Agreement, you agree to
+      promptly discontinue use of the SDK and destroy all copies
+      in your possession or control. Your prior distributions in
+      accordance with this Agreement are not affected by the
+      termination of this Agreement. Upon written request, you
+      will certify in writing that you have complied with your
+      commitments under this section. Upon any termination of
+      this Agreement all provisions survive except for the
+      license grant provisions.
+
+
+  1.7. General
+
+  If you wish to assign this Agreement or your rights and
+  obligations, including by merger, consolidation, dissolution
+  or operation of law, contact NVIDIA to ask for permission. Any
+  attempted assignment not approved by NVIDIA in writing shall
+  be void and of no effect. NVIDIA may assign, delegate or
+  transfer this Agreement and its rights and obligations, and if
+  to a non-affiliate you will be notified.
+
+  You agree to cooperate with NVIDIA and provide reasonably
+  requested information to verify your compliance with this
+  Agreement.
+
+  This Agreement will be governed in all respects by the laws of
+  the United States and of the State of Delaware as those laws
+  are applied to contracts entered into and performed entirely
+  within Delaware by Delaware residents, without regard to the
+  conflicts of laws principles. The United Nations Convention on
+  Contracts for the International Sale of Goods is specifically
+  disclaimed. You agree to all terms of this Agreement in the
+  English language.
+
+  The state or federal courts residing in Santa Clara County,
+  California shall have exclusive jurisdiction over any dispute
+  or claim arising out of this Agreement. Notwithstanding this,
+  you agree that NVIDIA shall still be allowed to apply for
+  injunctive remedies or an equivalent type of urgent legal
+  relief in any jurisdiction.
+
+  If any court of competent jurisdiction determines that any
+  provision of this Agreement is illegal, invalid or
+  unenforceable, such provision will be construed as limited to
+  the extent necessary to be consistent with and fully
+  enforceable under the law and the remaining provisions will
+  remain in full force and effect. Unless otherwise specified,
+  remedies are cumulative.
+
+  Each party acknowledges and agrees that the other is an
+  independent contractor in the performance of this Agreement.
+
+  The SDK has been developed entirely at private expense and is
+  “commercial items” consisting of “commercial computer
+  software” and “commercial computer software
+  documentation” provided with RESTRICTED RIGHTS. Use,
+  duplication or disclosure by the U.S. Government or a U.S.
+  Government subcontractor is subject to the restrictions in
+  this Agreement pursuant to DFARS 227.7202-3(a) or as set forth
+  in subparagraphs (c)(1) and (2) of the Commercial Computer
+  Software - Restricted Rights clause at FAR 52.227-19, as
+  applicable. Contractor/manufacturer is NVIDIA, 2788 San Tomas
+  Expressway, Santa Clara, CA 95051.
+
+  The SDK is subject to United States export laws and
+  regulations. You agree that you will not ship, transfer or
+  export the SDK into any country, or use the SDK in any manner,
+  prohibited by the United States Bureau of Industry and
+  Security or economic sanctions regulations administered by the
+  U.S. Department of Treasury’s Office of Foreign Assets
+  Control (OFAC), or any applicable export laws, restrictions or
+  regulations. These laws include restrictions on destinations,
+  end users and end use. By accepting this Agreement, you
+  confirm that you are not a resident or citizen of any country
+  currently embargoed by the U.S. and that you are not otherwise
+  prohibited from receiving the SDK.
+
+  Any notice delivered by NVIDIA to you under this Agreement
+  will be delivered via mail, email or fax. You agree that any
+  notices that NVIDIA sends you electronically will satisfy any
+  legal communication requirements. Please direct your legal
+  notices or other correspondence to NVIDIA Corporation, 2788
+  San Tomas Expressway, Santa Clara, California 95051, United
+  States of America, Attention: Legal Department.
+
+  This Agreement and any exhibits incorporated into this
+  Agreement constitute the entire agreement of the parties with
+  respect to the subject matter of this Agreement and supersede
+  all prior negotiations or documentation exchanged between the
+  parties relating to this SDK license. Any additional and/or
+  conflicting terms on documents issued by you are null, void,
+  and invalid. Any amendment or waiver under this Agreement
+  shall be in writing and signed by representatives of both
+  parties.
+
+
+  2. CUDA Toolkit Supplement to Software License Agreement for
+  NVIDIA Software Development Kits
+  ------------------------------------------------------------
+
+
+  Release date: August 16, 2018
+  -----------------------------
+
+  The terms in this supplement govern your use of the NVIDIA
+  CUDA Toolkit SDK under the terms of your license agreement
+  (“Agreement”) as modified by this supplement. Capitalized
+  terms used but not defined below have the meaning assigned to
+  them in the Agreement.
+
+  This supplement is an exhibit to the Agreement and is
+  incorporated as an integral part of the Agreement. In the
+  event of conflict between the terms in this supplement and the
+  terms in the Agreement, the terms in this supplement govern.
+
+
+  2.1. License Scope
+
+  The SDK is licensed for you to develop applications only for
+  use in systems with NVIDIA GPUs.
+
+
+  2.2. Distribution
+
+  The portions of the SDK that are distributable under the
+  Agreement are listed in Attachment A.
+
+
+  2.3. Operating Systems
+
+  Those portions of the SDK designed exclusively for use on the
+  Linux or FreeBSD operating systems, or other operating systems
+  derived from the source code to these operating systems, may
+  be copied and redistributed for use in accordance with this
+  Agreement, provided that the object code files are not
+  modified in any way (except for unzipping of compressed
+  files).
+
+
+  2.4. Audio and Video Encoders and Decoders
+
+  You acknowledge and agree that it is your sole responsibility
+  to obtain any additional third-party licenses required to
+  make, have made, use, have used, sell, import, and offer for
+  sale your products or services that include or incorporate any
+  third-party software and content relating to audio and/or
+  video encoders and decoders from, including but not limited
+  to, Microsoft, Thomson, Fraunhofer IIS, Sisvel S.p.A.,
+  MPEG-LA, and Coding Technologies. NVIDIA does not grant to you
+  under this Agreement any necessary patent or other rights with
+  respect to any audio and/or video encoders and decoders.
+
+
+  2.5. Licensing
+
+  If the distribution terms in this Agreement are not suitable
+  for your organization, or for any questions regarding this
+  Agreement, please contact NVIDIA at
+  nvidia-compute-license-questions@nvidia.com.
+
+_______________________________________________________________________________
+
 *Other names and brands may be claimed as the property of others.
diff --git a/scripts/README.md b/scripts/README.md
deleted file mode 100644
index e3a9ed533..000000000
--- a/scripts/README.md
+++ /dev/null
@@ -1,5 +0,0 @@
-The documentation HTML files are generated using the following dependencies:
- * [Python](https://www.python.org/downloads/) at least v3.8
- * [Doxygen](http://www.doxygen.nl/) at least v1.9.1
-
- To generate files run the `generate_docs.py` script from the `scripts` directory. Files will be generated to the `docs/html` directory relative to the main directory of this repository.
diff --git a/scripts/check_license/check_headers.sh b/scripts/check_license/check_headers.sh
new file mode 100755
index 000000000..aeb90e7a2
--- /dev/null
+++ b/scripts/check_license/check_headers.sh
@@ -0,0 +1,197 @@
+#!/usr/bin/env bash
+# Copyright (C) 2016-2025 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+# check-headers.sh - check copyright and license in source files
+
+SELF=$0
+
+function usage() {
+	echo "Usage: $SELF <source_root_path> <license_tag> [-h|-v|-a|-d]"
+	echo "   -h, --help          this help message"
+	echo "   -v, --verbose       verbose mode"
+	echo "   -a, --all           check all files (only modified files are checked by default)"
+	echo "   -d, --update_dates  change Copyright dates in all analyzed files (rather not use with -a)"
+}
+
+if [ "$#" -lt 2 ]; then
+	usage >&2
+	exit 2
+fi
+
+SOURCE_ROOT=$1
+shift
+LICENSE=$1
+shift
+
+PATTERN=`mktemp`
+TMP=`mktemp`
+TMP2=`mktemp`
+TEMPFILE=`mktemp`
+rm -f $PATTERN $TMP $TMP2
+
+if [ "$1" == "-h" -o "$1" == "--help" ]; then
+	usage
+	exit 0
+fi
+
+export GIT="git -C ${SOURCE_ROOT}"
+$GIT rev-parse || exit 1
+
+if [ -f $SOURCE_ROOT/.git/shallow ]; then
+	SHALLOW_CLONE=1
+	echo
+	echo "Warning: This is a shallow clone. Checking dates in copyright headers"
+	echo "         will be skipped in case of files that have no history."
+	echo
+else
+	SHALLOW_CLONE=0
+fi
+
+VERBOSE=0
+CHECK_ALL=0
+UPDATE_DATES=0
+while [ "$1" != "" ]; do
+	case $1 in
+	-v|--verbose)
+		VERBOSE=1
+		;;
+	-a|--all)
+		CHECK_ALL=1
+		;;
+	-d|--update_dates)
+		UPDATE_DATES=1
+		;;
+	esac
+	shift
+done
+
+if [ $CHECK_ALL -eq 0 ]; then
+	CURRENT_COMMIT=$($GIT --no-pager log --pretty=%H -1)
+	MERGE_BASE=$($GIT merge-base HEAD origin/main 2>/dev/null)
+	[ -z $MERGE_BASE ] && \
+		MERGE_BASE=$($GIT --no-pager log --pretty="%cN:%H" | grep GitHub 2>/dev/null | head -n1 | cut -d: -f2)
+	[ -z $MERGE_BASE -o "$CURRENT_COMMIT" = "$MERGE_BASE" ] && \
+		CHECK_ALL=1
+fi
+
+if [ $CHECK_ALL -eq 1 ]; then
+	echo "INFO: Checking copyright headers of all files..."
+	GIT_COMMAND="ls-tree -r --name-only HEAD"
+else
+	echo "INFO: Checking copyright headers of modified files only..."
+	GIT_COMMAND="diff --name-only $MERGE_BASE $CURRENT_COMMIT"
+fi
+
+FILES=$($GIT $GIT_COMMAND | ${SOURCE_ROOT}/scripts/check_license/file-exceptions.sh)
+
+RV=0
+for file in $FILES ; do
+	if [ $VERBOSE -eq 1 ]; then
+		echo "Checking file: $file"
+	fi
+	# The src_path is a path which should be used in every command except git.
+	# git is called with -C flag so filepaths should be relative to SOURCE_ROOT
+	src_path="${SOURCE_ROOT}/$file"
+	[ ! -f $src_path ] && continue
+	# ensure that file is UTF-8 encoded
+	ENCODING=`file -b --mime-encoding $src_path`
+	iconv -f $ENCODING -t "UTF-8" $src_path > $TEMPFILE
+
+	if ! grep -q "SPDX-License-Identifier: $LICENSE" $src_path; then
+		echo >&2 "error: no $LICENSE SPDX tag in file: $src_path"
+		RV=1
+	fi
+
+	if [ $SHALLOW_CLONE -eq 0 ]; then
+		$GIT log --no-merges --format="%ai %aE" -- $file | sort > $TMP
+	else
+		# mark the grafted commits (commits with no parents)
+		$GIT log --no-merges --format="%ai %aE grafted-%p-commit" -- $file | sort > $TMP
+	fi
+
+	# skip checking dates for non-Intel commits
+	[[ ! $(tail -n1 $TMP) =~ "@intel.com" ]] && continue
+
+	# skip checking dates for new files
+	[ $(cat $TMP | wc -l) -le 1 ] && continue
+
+	# grep out the grafted commits (commits with no parents)
+	# and skip checking dates for non-Intel commits
+	grep -v -e "grafted--commit" $TMP | grep -e "@intel.com" > $TMP2
+
+	[ $(cat $TMP2 | wc -l) -eq 0 ] && continue
+
+	FIRST=`head -n1 $TMP2`
+	LAST=` tail -n1 $TMP2`
+
+	YEARS=$(sed '
+/.*Copyright (C) [0-9-]\+ Intel Corporation/!d
+s/.*Copyright (C) \([0-9]\+\)-\([0-9]\+\).*/\1-\2/
+s/.*Copyright (C) \([0-9]\+\).*/\1/' "$src_path")
+	if [ -z "$YEARS" ]; then
+		echo >&2 "No copyright years in $src_path"
+		RV=1
+		continue
+	fi
+
+	HEADER_FIRST=`echo $YEARS | cut -d"-" -f1`
+	HEADER_LAST=` echo $YEARS | cut -d"-" -f2`
+
+	COMMIT_FIRST=`echo $FIRST | cut -d"-" -f1`
+	COMMIT_LAST=` echo $LAST  | cut -d"-" -f1`
+
+	if [ "$COMMIT_FIRST" != "" -a "$COMMIT_LAST" != "" ]; then
+    	if [ "$COMMIT_FIRST" -lt "$HEADER_FIRST" ]; then
+    	    RV=1
+    	fi
+
+    	if [[ -n "$COMMIT_FIRST" && -n "$COMMIT_LAST" ]]; then
+    	    if [[ $HEADER_FIRST -le $COMMIT_FIRST ]]; then
+    	        if [[ $HEADER_LAST -eq $COMMIT_LAST ]]; then
+    	            continue
+    	        else
+    	            NEW="$HEADER_FIRST-$COMMIT_LAST"
+    	            if [[ ${UPDATE_DATES} -eq 1 ]]; then
+    	                echo "Updating copyright date in $src_path: $YEARS -> $NEW"
+    	                sed -i "s/Copyright (C) ${YEARS}/Copyright (C) ${NEW}/g" "${src_path}"
+    	            else
+    	                echo "$file:1: error: wrong copyright date: (is: $YEARS, should be: $NEW)" >&2
+    	                RV=1
+    	            fi
+    	        fi
+    	    else
+    	        if [[ $COMMIT_FIRST -eq $COMMIT_LAST ]]; then
+    	            NEW=$COMMIT_LAST
+    	        else
+    	            NEW=$COMMIT_FIRST-$COMMIT_LAST
+    	        fi
+
+    	        if [[ "$YEARS" == "$NEW" ]]; then
+    	            continue
+    	        else
+    	            if [[ ${UPDATE_DATES} -eq 1 ]]; then
+    	                echo "Updating copyright date in $src_path: $YEARS -> $NEW"
+    	                sed -i "s/Copyright (C) ${YEARS}/Copyright (C) ${NEW}/g" "${src_path}"
+    	            else
+    	                echo "$file:1: error: wrong copyright date: (is: $YEARS, should be: $NEW)" >&2
+    	                RV=1
+    	            fi
+    	        fi
+    	    fi
+    	fi
+	else
+	    echo "error: unknown commit dates in file: $file" >&2
+	    RV=1
+	fi
+done
+rm -f $TMP $TMP2 $TEMPFILE
+
+# check if error found
+if [ $RV -eq 0 ]; then
+	echo "Copyright headers are OK."
+else
+	echo "Error(s) in copyright headers found!" >&2
+fi
+exit $RV
diff --git a/scripts/check_license/file-exceptions.sh b/scripts/check_license/file-exceptions.sh
new file mode 100755
index 000000000..10c556061
--- /dev/null
+++ b/scripts/check_license/file-exceptions.sh
@@ -0,0 +1,38 @@
+#!/bin/sh -e
+# Copyright (C) 2025 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+# You can add an exception file
+# list for license and copyright check
+grep -v -E -e 'benchmark/ubench.h' \
+           -e 'ChangeLog' \
+           -e 'CODEOWNERS$' \
+           -e 'docs/assets/.*' \
+           -e 'docs/config/spelling_exceptions.txt' \
+           -e 'docs/config/conf.py' \
+           -e 'docs/config/Doxyfile' \
+           -e 'include/umf/proxy_lib_new_delete.h' \
+           -e 'LICENSE.TXT' \
+           -e 'licensing/third-party-programs.txt' \
+           -e 'scripts/assets/images/.*' \
+           -e 'scripts/qemu/requirements.txt' \
+           -e 'src/uthash/.*' \
+           -e 'src/uthash/utlist.h' \
+           -e 'src/uthash/uthash.h' \
+           -e 'test/ctl/config.txt' \
+           -e 'test/supp/.*' \
+           -e 'third_party/requirements.txt' \
+           -e '.clang-format$' \
+           -e '.cmake-format$' \
+           -e '.cmake.in$' \
+           -e '.gitignore' \
+           -e '.json$' \
+           -e '.mailmap' \
+           -e '.md$' \
+           -e '.patch$' \
+           -e '.rst$' \
+           -e '.spellcheck-conf.toml' \
+           -e '.trivyignore' \
+           -e '.xml$' \
+           -e '.yml$'
diff --git a/scripts/coverage/coverage_capture.sh b/scripts/coverage/coverage_capture.sh
new file mode 100755
index 000000000..c77f1b141
--- /dev/null
+++ b/scripts/coverage/coverage_capture.sh
@@ -0,0 +1,49 @@
+#!/bin/bash
+# Copyright (C) 2024 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+# This script calculates coverage for a single build
+
+set -e
+
+[ "$1" != "" ] && OUTPUT_NAME="$1" || OUTPUT_NAME="output_coverage"
+
+set -x
+
+lcov --capture  --directory . \
+--exclude "/usr/*" \
+--exclude "*/build/*" \
+--exclude "*/benchmark/*" \
+--exclude "*/examples/*" \
+--exclude "*/test/*" \
+--exclude "*/src/critnib/*" \
+--exclude "*/src/ravl/*" \
+--exclude "*proxy_lib_new_delete.h" \
+--output-file $OUTPUT_NAME || \
+	( echo "RETRY after ERROR !!!:" && \
+	lcov --capture --directory . \
+	--exclude "/usr/*" \
+	--exclude "*/build/*" \
+	--exclude "*/benchmark/*" \
+	--exclude "*/examples/*" \
+	--exclude "*/test/*" \
+	--exclude "*/src/critnib/*" \
+	--exclude "*/src/ravl/*" \
+	--exclude "*proxy_lib_new_delete.h" \
+	--ignore-errors mismatch,unused,negative,corrupt \
+	--output-file $OUTPUT_NAME )
+
+# Most common UMF source code directory on most GH CI runners
+COMMON_UMF_DIR=/home/runner/work/unified-memory-framework/unified-memory-framework
+
+# Get the current UMF source code directory
+# This is ${CURRENT_UMF_DIR}/scripts/coverage/coverage_capture.sh file, so
+CURRENT_UMF_DIR=$(realpath $(dirname $0)/../..)
+
+# Coverage (lcov) has to be run in the same directory on all runners:
+# /home/runner/work/unified-memory-framework/unified-memory-framework/build
+# to be able to merge all results, so we have to replace the paths if they are different:
+if [ "$CURRENT_UMF_DIR" != "$COMMON_UMF_DIR" ]; then
+	sed -i "s|$CURRENT_UMF_DIR|$COMMON_UMF_DIR|g" $OUTPUT_NAME
+fi
diff --git a/scripts/coverage/merge_coverage_files.sh b/scripts/coverage/merge_coverage_files.sh
new file mode 100755
index 000000000..193600556
--- /dev/null
+++ b/scripts/coverage/merge_coverage_files.sh
@@ -0,0 +1,27 @@
+#!/bin/bash
+# Copyright (C) 2024 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#
+# Arguments: <PREFIX> <OUTPUT_NAME>
+#
+# This script looks for "${PREFIX}-*" lcov output files in the current directory,
+# merges them and saves the merged output in the $OUTPUT_NAME file.
+#
+
+[ "$1" != "" ] && PREFIX="$1" || PREFIX="exports-coverage"
+[ "$2" != "" ] && OUTPUT_NAME="$2" || OUTPUT_NAME="total_coverage"
+
+OPTS=""
+for file in $(ls -1 ${PREFIX}-*); do
+	OPTS="$OPTS -a $file"
+done
+
+set -x
+
+lcov $OPTS -o $OUTPUT_NAME  || \
+	( echo "RETRY after ERROR !!!:" && \
+	lcov $OPTS \
+	--ignore-errors mismatch,unused,negative,corrupt \
+	--output-file $OUTPUT_NAME )
diff --git a/scripts/qemu/configs/default.xml b/scripts/qemu/configs/default.xml
index 565468794..5d3198f60 100644
--- a/scripts/qemu/configs/default.xml
+++ b/scripts/qemu/configs/default.xml
@@ -50,16 +50,12 @@ Cell 2 |   0   |   1200MiB    | 17, 28, 10          |
       <interconnects>
         <latency initiator='0' target='0' type='access' value='10'/>
         <bandwidth initiator='0' target='0' type='access' value='10485760' unit='B'/>
-        
         <latency initiator='0' target='1' type='access' value='20'/>
         <bandwidth initiator='0' target='1' type='access' value='5242880' unit='B'/>
-        
         <latency initiator='0' target='2' type='access' value='16'/>
         <bandwidth initiator='0' target='2' type='access' value='1048576' unit='B'/>
-       
         <latency initiator='1' target='1' type='access' value='10'/>
         <bandwidth initiator='1' target='1' type='access' value='10485760' unit='B'/>
-        
         <latency initiator='1' target='2' type='access' value='27'/>
         <bandwidth initiator='1' target='2' type='access' value='1048576' unit='B'/>
       </interconnects>
diff --git a/scripts/qemu/configs/sock_8_var1_hmat.xml b/scripts/qemu/configs/sock_8_var1_hmat.xml
new file mode 100644
index 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/qemu_config.py b/scripts/qemu/parse_config.py
similarity index 70%
rename from scripts/qemu/qemu_config.py
rename to scripts/qemu/parse_config.py
index 20dc67c50..3d14fb344 100644
--- a/scripts/qemu/qemu_config.py
+++ b/scripts/qemu/parse_config.py
@@ -1,3 +1,10 @@
+"""
+ Copyright (C) 2023-2024 Intel Corporation
+
+ Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""
+
 import re
 import subprocess  # nosec
 import sys
@@ -6,10 +13,13 @@
 import psutil
 import shutil
 
-# If you want to manually run this script please install deps by: pip install -r requirements.txt
-# To get virsh please install libvirt-clients
+# This script parses the topology xml file and returns QEMU arguments.
+#
+# Before running this script:
+# - install python deps for this script: pip install -r requirements.txt
+# - install 'libvirt-clients' package (for virsh)
 #
-# Enable verbose mode by using environment variable ENABLE_VERBOSE=1
+# Enable verbose mode by setting environment variable: ENABLE_VERBOSE=1
 
 TopologyCfg = collections.namedtuple(
     "TopologyCfg", ["name", "hmat", "cpu_model", "cpu_options", "mem_options"]
@@ -20,7 +30,7 @@
 
 def enable_verbose():
     """
-    Parse command line arguments
+    Check if env var ENABLE_VERBOSE is set and enable verbose mode
     """
     global verbose_mode
     verbose_mode = os.getenv("ENABLE_VERBOSE", False)
@@ -43,9 +53,13 @@ def parse_topology_xml(tpg_file_name: str) -> TopologyCfg:
         result.check_returncode()
         libvirt_args = result.stdout.decode("utf-8").strip()
 
+        if verbose_mode != False:
+            print(f"\nFull libvirt_args: {libvirt_args}\n")
+
+        hmat_search = re.search(r"hmat=(\w+)", libvirt_args)
         tpg_cfg = {
             "name": re.search(r"guest=(\w+)", libvirt_args).group(1),
-            "hmat": "hmat=on" in libvirt_args,
+            "hmat": hmat_search.group(0) if hmat_search else "hmat=off",
             "cpu_model": re.search(r"cpu (\S+)", libvirt_args).group(1),
             "cpu_options": re.search("(?=-smp)(.*)threads=[0-9]+", libvirt_args).group(
                 0
@@ -67,7 +81,7 @@ def parse_topology_xml(tpg_file_name: str) -> TopologyCfg:
     except subprocess.CalledProcessError:
         sys.exit(f"\n XML file: {tpg_file_name} error in virsh parsing")
     except Exception:
-        sys.exit(f"\n Provided file is missing or missing virsh.")
+        sys.exit(f"\n Provided file ({tpg_file_name}) is missing or missing virsh.")
     return tpg
 
 
@@ -76,13 +90,16 @@ def get_qemu_args(tpg_file_name: str) -> str:
     Get QEMU arguments from topology xml file
     """
     tpg = parse_topology_xml(tpg_file_name)
-    qemu_args = f"-name {tpg.name} {calculate_memory(tpg)} -cpu {tpg.cpu_model} {tpg.cpu_options} {tpg.mem_options}"
+    qemu_args = (
+        f"-machine q35,usb=off,{tpg.hmat} -name {tpg.name} "
+        f"{calculate_memory(tpg)} -cpu {tpg.cpu_model} {tpg.cpu_options} {tpg.mem_options}"
+    )
     return qemu_args
 
 
 def calculate_memory(tpg: TopologyCfg) -> str:
     """
-    Memory used by QEMU
+    Total memory required by given QEMU config
     """
     if tpg.mem_options:
         mem_needed = 0
@@ -105,4 +122,6 @@ def calculate_memory(tpg: TopologyCfg) -> str:
         tpg_file_name = sys.argv[1]
     else:
         sys.exit(f"\n Usage: {sys.argv[0]} <tpg_file_name>")
+
+    # Print QEMU arguments as a result of this script
     print(get_qemu_args(tpg_file_name))
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/scripts/qemu/run-build.sh b/scripts/qemu/run-build.sh
index 91c2e4f61..724e6d7ff 100755
--- a/scripts/qemu/run-build.sh
+++ b/scripts/qemu/run-build.sh
@@ -1,31 +1,34 @@
 #!/bin/bash
-# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 set -e
 
-repo=$1
-branch=$2
+[ "$1" = "COVERAGE" ] && COVERAGE=ON || COVERAGE=OFF
 
-echo password | sudo -Sk apt update
-echo password | sudo -Sk apt install -y git cmake gcc g++ numactl libnuma-dev libhwloc-dev libjemalloc-dev libtbb-dev pkg-config valgrind hwloc
+# This is ${UMF_DIR}/scripts/qemu/run-build.sh file, so
+UMF_DIR=$(dirname $0)/../..
+cd $UMF_DIR
+pwd
 
-git clone $repo umf
-cd umf
-git checkout $branch
+echo password | sudo -Sk apt-get update
+echo password | sudo -Sk apt-get install -y git cmake gcc g++ pkg-config \
+    numactl libnuma-dev hwloc libhwloc-dev libtbb-dev valgrind lcov
 
 mkdir build
 cd build
 
 cmake .. \
     -DCMAKE_BUILD_TYPE=Debug \
+    -DUMF_QEMU_BUILD=1 \
     -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON \
+    -DUMF_BUILD_CUDA_PROVIDER=ON \
     -DUMF_FORMAT_CODE_STYLE=OFF \
     -DUMF_DEVELOPER_MODE=ON \
-    -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON \
     -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON \
     -DUMF_BUILD_EXAMPLES=ON \
+    -DUMF_USE_COVERAGE=${COVERAGE} \
     -DUMF_TESTS_FAIL_ON_SKIP=ON
 
 make -j $(nproc)
diff --git a/scripts/qemu/run-tests.sh b/scripts/qemu/run-tests.sh
index 00fdfb8fd..341e2f9ab 100755
--- a/scripts/qemu/run-tests.sh
+++ b/scripts/qemu/run-tests.sh
@@ -1,26 +1,48 @@
 #!/bin/bash
-# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+# If env var SHORT_RUN is set to true, part of the tests are skipped here.
+# For coverage, OS_FULL_NAME env variable has to be set to the name of the OS.
+
 set -e
 
+COVERAGE=$1
+XML_CONFIG_FILE=$2
+
+CONFIG_NAME=$(echo $XML_CONFIG_FILE | cut -d. -f1) # remove the '.xml' extension
+COVERAGE_DIR=${HOME}/coverage
+mkdir -p $COVERAGE_DIR
+
+# This is ${UMF_DIR}/scripts/qemu/run-build.sh file, so
+UMF_DIR=$(dirname $0)/../..
+cd $UMF_DIR
+UMF_DIR=$(pwd)
+
 # Drop caches, restores free memory on NUMA nodes
 echo password | sudo sync;
 echo password | sudo sh -c "/usr/bin/echo 3 > /proc/sys/vm/drop_caches"
-# Set ptrace value for IPC test
-echo password | sudo bash -c "echo 0 > /proc/sys/kernel/yama/ptrace_scope"
 
 numactl -H
 
-cd umf/build
+cd build
+echo "## Running all tests ..."
 ctest --verbose
 
-# run tests bound to a numa node
+echo "## Running tests bound to a numa node 0 and node 1 ..."
 numactl -N 0 ctest --output-on-failure
 numactl -N 1 ctest --output-on-failure
 
-# run tests under valgrind
-echo "Running tests under valgrind memcheck ..."
-../test/test_valgrind.sh .. . memcheck
+if [ "$COVERAGE" = "COVERAGE" ]; then
+	COVERAGE_FILE_NAME=exports-coverage-qemu-${OS_FULL_NAME}-${CONFIG_NAME}
+	echo "COVERAGE_FILE_NAME: $COVERAGE_FILE_NAME"
+	../scripts/coverage/coverage_capture.sh $COVERAGE_FILE_NAME
+	mv ./$COVERAGE_FILE_NAME $COVERAGE_DIR
+fi
 
+# run tests under valgrind only on long run or for default configuration
+if [ "${SHORT_RUN}" != "true" ] || [ "${CONFIG_NAME}" == "default" ]; then
+	echo "## Running tests under valgrind memcheck ..."
+	../test/test_valgrind.sh .. . memcheck
+fi
diff --git a/scripts/qemu/start_qemu.sh b/scripts/qemu/start_qemu.sh
index 0962dd98a..c4758ac17 100755
--- a/scripts/qemu/start_qemu.sh
+++ b/scripts/qemu/start_qemu.sh
@@ -3,28 +3,25 @@
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-set -x
 set -e
 
-config_file=$1
+# The config file name (should be located in ./configs/ sub-dir)
+config_name=$1
 
-python3 scripts/qemu/qemu_config.py $config_file
+# Parse the config file to get topology info and fix escaped single quotes
+parsed_config=$(python3 "$(dirname $0)/parse_config.py" "$(dirname $0)/configs/${config_name}" | sed s/''\''/'/g)
 
-if grep -q '<interconnects>' "$config_file"; then
-    hmat="on"
-else
-    hmat="off"
-fi
+set -x
 
 sudo qemu-system-x86_64 \
-    -drive file=./ubuntu-23.04-server-cloudimg-amd64.img,format=qcow2,index=0,media=disk,id=hd \
+    -drive file=./qemu_image.img,format=qcow2,index=0,media=disk,id=hd \
     -cdrom ./ubuntu-cloud-init.iso \
-    -machine q35,usb=off,hmat=$hmat \
     -enable-kvm \
     -net nic -net user,hostfwd=tcp::2222-:22 \
-    $(python3 scripts/qemu/qemu_config.py $config_file | sed s/''\''/'/g) \
+    ${parsed_config} \
     -daemonize -display none
 
+# Enable ssh connection to the VM
 until ssh-keyscan -p 2222 -H 127.0.0.1 >> ~/.ssh/known_hosts 2>/dev/null; do
     echo "Waiting for SSH..."
     sleep 1
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 76479926c..d11e04c4f 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,146 +1,119 @@
-# 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(UMF_LEVEL_ZERO_INCLUDE_DIR
+    ""
+    CACHE PATH "Directory containing the Level Zero headers")
+set(UMF_CUDA_INCLUDE_DIR
+    ""
+    CACHE PATH "Directory containing the CUDA headers")
+
+# Compose the UMF_ALL_CMAKE_VARIABLES variable containing CMake options that
+# will be saved in the constant string.
+list(SORT UMF_OPTIONS_LIST ORDER DESCENDING)
+foreach(_var ${UMF_OPTIONS_LIST})
+    # Preprocessor definitions containing '#' cannot be passed on to the
+    # compiler command line because many compilers do not support it.
+    if(NOT "${${_var}}" MATCHES "#")
+        set(UMF_ALL_CMAKE_VARIABLES
+            "${_var}:${${_var}},${UMF_ALL_CMAKE_VARIABLES}")
+    endif()
+endforeach()
+
 # Compile definitions for UMF library.
 #
 # TODO: Cleanup the compile definitions across all the CMake files
-set(UMF_COMMON_COMPILE_DEFINITIONS UMF_VERSION=${UMF_VERSION})
-
-if(UMF_BUILD_LEVEL_ZERO_PROVIDER)
-    include(FetchContent)
-
-    set(LEVEL_ZERO_LOADER_REPO "https://github.com/oneapi-src/level-zero.git")
-    set(LEVEL_ZERO_LOADER_TAG v1.16.1)
-
-    message(
-        STATUS
-            "Installing level-zero ${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_GetProperties(level-zero-loader)
-    if(NOT level-zero-loader_POPULATED)
-        FetchContent_Populate(level-zero-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}")
-endif()
+set(UMF_COMMON_COMPILE_DEFINITIONS
+    ${UMF_COMMON_COMPILE_DEFINITIONS} UMF_VERSION=${UMF_VERSION}
+    UMF_ALL_CMAKE_VARIABLES="${UMF_ALL_CMAKE_VARIABLES}")
 
 add_subdirectory(utils)
+add_subdirectory(base_alloc)
+add_subdirectory(coarse)
 
-set(UMF_LIBS $<BUILD_INTERFACE:umf_utils>)
-
-set(BA_SOURCES
-    ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_linear.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_global.c)
-
-if(LINUX)
-    set(BA_SOURCES ${BA_SOURCES}
-                   ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_linux.c)
-elseif(WINDOWS)
-    set(BA_SOURCES ${BA_SOURCES}
-                   ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_windows.c)
-elseif(MACOSX)
-    set(BA_SOURCES ${BA_SOURCES}
-                   ${CMAKE_CURRENT_SOURCE_DIR}/base_alloc/base_alloc_linux.c)
-endif()
-
-set(BA_SOURCES
-    ${BA_SOURCES}
-    PARENT_SCOPE)
+set(UMF_LIBS umf_utils umf_ba umf_coarse)
 
 set(HWLOC_DEPENDENT_SOURCES topology.c)
 
 set(UMF_SOURCES
-    ${BA_SOURCES}
+    ctl/ctl.c
     libumf.c
     ipc.c
+    ipc_cache.c
     memory_pool.c
     memory_provider.c
     memory_provider_get_last_failed.c
-    memory_target.c
+    memtarget.c
     mempolicy.c
     memspace.c
+    memspaces/memspace_host_all.c
+    memspaces/memspace_highest_capacity.c
+    memspaces/memspace_highest_bandwidth.c
+    memspaces/memspace_lowest_latency.c
+    memspaces/memspace_numa.c
+    provider/provider_cuda.c
+    provider/provider_devdax_memory.c
+    provider/provider_file_memory.c
+    provider/provider_fixed_memory.c
+    provider/provider_level_zero.c
+    provider/provider_os_memory.c
     provider/provider_tracking.c
     critnib/critnib.c
+    ravl/ravl.c
+    pool/pool_disjoint.c
+    pool/pool_jemalloc.c
     pool/pool_proxy.c
     pool/pool_scalable.c)
 
+if(UMF_POOL_JEMALLOC_ENABLED)
+    set(UMF_LIBS ${UMF_LIBS} ${JEMALLOC_LIBRARIES})
+    set(UMF_PRIVATE_LIBRARY_DIRS ${UMF_PRIVATE_LIBRARY_DIRS}
+                                 ${JEMALLOC_LIBRARY_DIRS})
+    set(UMF_PRIVATE_INCLUDE_DIRS ${UMF_PRIVATE_INCLUDE_DIRS}
+                                 ${JEMALLOC_INCLUDE_DIRS})
+    set(UMF_COMMON_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS}
+                                       "UMF_POOL_JEMALLOC_ENABLED=1")
+endif()
+
 if(NOT UMF_DISABLE_HWLOC)
-    set(UMF_SOURCES ${UMF_SOURCES} ${HWLOC_DEPENDENT_SOURCES})
+    set(UMF_SOURCES ${UMF_SOURCES} ${HWLOC_DEPENDENT_SOURCES}
+                    memtargets/memtarget_numa.c)
+    set(UMF_LIBS ${UMF_LIBS} $<BUILD_INTERFACE:${UMF_HWLOC_NAME}>)
+    set(UMF_PRIVATE_LIBRARY_DIRS ${UMF_PRIVATE_LIBRARY_DIRS}
+                                 ${LIBHWLOC_LIBRARY_DIRS})
+else()
+    set(UMF_COMMON_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS}
+                                       "UMF_NO_HWLOC=1")
 endif()
 
 set(UMF_SOURCES_LINUX libumf_linux.c)
-
 set(UMF_SOURCES_MACOSX libumf_linux.c)
-
 set(UMF_SOURCES_WINDOWS libumf_windows.c)
 
-set(UMF_SOURCES_COMMON_LINUX_MACOSX
-    provider/provider_os_memory.c
-    provider/provider_os_memory_posix.c
-    memory_targets/memory_target_numa.c
-    memspaces/memspace_numa.c
-    memspaces/memspace_host_all.c
-    memspaces/memspace_highest_capacity.c
-    memspaces/memspace_highest_bandwidth.c
-    memspaces/memspace_lowest_latency.c)
-
-if(NOT UMF_DISABLE_HWLOC)
-    set(UMF_SOURCES_LINUX
-        ${UMF_SOURCES_LINUX} ${UMF_SOURCES_COMMON_LINUX_MACOSX}
-        provider/provider_os_memory_linux.c)
-
-    set(UMF_SOURCES_MACOSX
-        ${UMF_SOURCES_MACOSX} ${UMF_SOURCES_COMMON_LINUX_MACOSX}
-        provider/provider_os_memory_macosx.c)
-
-    set(UMF_SOURCES_WINDOWS
-        ${UMF_SOURCES_WINDOWS} provider/provider_os_memory.c
-        provider/provider_os_memory_windows.c)
-
-    set(UMF_LIBS ${UMF_LIBS} ${LIBHWLOC_LIBRARIES})
-
-    if(NOT WINDOWS)
-        add_optional_symbol(umfMemspaceCreateFromNumaArray)
-        add_optional_symbol(umfMemspaceHighestBandwidthGet)
-        add_optional_symbol(umfMemspaceHighestCapacityGet)
-        add_optional_symbol(umfMemspaceHostAllGet)
-        add_optional_symbol(umfMemspaceLowestLatencyGet)
+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()
-endif()
 
-if(WINDOWS)
-    message(STATUS "UMF_OPTIONAL_SYMBOLS: ${UMF_OPTIONAL_SYMBOLS_WINDOWS}")
-else()
-    message(STATUS "UMF_OPTIONAL_SYMBOLS: ${UMF_OPTIONAL_SYMBOLS_LINUX}")
+    set(UMF_COMMON_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS}
+                                       "UMF_BUILD_LEVEL_ZERO_PROVIDER=1")
 endif()
 
-# Configure the DEF file based on whether Level Zero provider is built
-configure_file("${CMAKE_CURRENT_SOURCE_DIR}/libumf.def.in"
-               "${CMAKE_CURRENT_BINARY_DIR}/libumf.def" @ONLY)
-
-configure_file("${CMAKE_CURRENT_SOURCE_DIR}/libumf.map.in"
-               "${CMAKE_CURRENT_BINARY_DIR}/libumf.map" @ONLY)
-
-set(UMF_PRIVATE_LIBRARY_DIRS ${UMF_PRIVATE_LIBRARY_DIRS}
-                             ${LIBHWLOC_LIBRARY_DIRS})
+if(UMF_BUILD_CUDA_PROVIDER)
+    set(UMF_COMMON_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS}
+                                       "UMF_BUILD_CUDA_PROVIDER=1")
+endif()
 
 if(LINUX)
     set(UMF_SOURCES ${UMF_SOURCES} ${UMF_SOURCES_LINUX})
-    set(UMF_LIBS ${UMF_LIBS} dl rt) # librt for shm_open()
+    set(UMF_LIBS ${UMF_LIBS} dl)
 elseif(WINDOWS)
     set(UMF_SOURCES ${UMF_SOURCES} ${UMF_SOURCES_WINDOWS})
 
@@ -153,19 +126,17 @@ elseif(MACOSX)
 endif()
 
 if(UMF_BUILD_SHARED_LIBRARY)
-    # Set the runtime search path to the directory containing hwloc library
-    set(CMAKE_INSTALL_RPATH "\$ORIGIN")
-
-    if(NOT UMF_DISABLE_HWLOC)
-        set(HWLOC_LIB ${UMF_HWLOC_NAME})
+    if(UMF_INSTALL_RPATH)
+        set(CMAKE_INSTALL_RPATH "${UMF_INSTALL_RPATH}")
     endif()
+
     add_umf_library(
         NAME umf
         TYPE SHARED
         SRCS ${UMF_SOURCES}
-        LIBS ${UMF_LIBS} ${HWLOC_LIB}
-        LINUX_MAP_FILE ${CMAKE_CURRENT_BINARY_DIR}/libumf.map
-        WINDOWS_DEF_FILE ${CMAKE_CURRENT_BINARY_DIR}/libumf.def)
+        LIBS ${UMF_LIBS}
+        LINUX_MAP_FILE ${CMAKE_CURRENT_SOURCE_DIR}/libumf.map
+        WINDOWS_DEF_FILE ${CMAKE_CURRENT_SOURCE_DIR}/libumf.def)
     set(UMF_COMMON_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS}
                                        "UMF_SHARED_LIBRARY")
     set_target_properties(
@@ -181,32 +152,30 @@ else()
         LIBS ${UMF_LIBS})
 endif()
 
-if(UMF_DISABLE_HWLOC)
-    set(UMF_COMMON_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS}
-                                       UMF_NO_HWLOC=1)
-endif()
-
-if(UMF_LINK_HWLOC_STATICALLY)
-    add_dependencies(umf ${UMF_HWLOC_NAME})
-endif()
-
+target_include_directories(umf PRIVATE ${UMF_PRIVATE_INCLUDE_DIRS})
 target_link_directories(umf PRIVATE ${UMF_PRIVATE_LIBRARY_DIRS})
-
 target_compile_definitions(umf PRIVATE ${UMF_COMMON_COMPILE_DEFINITIONS})
 
-if(UMF_BUILD_LEVEL_ZERO_PROVIDER)
-    target_sources(umf PRIVATE provider/provider_level_zero.c)
+add_dependencies(umf umf_ba umf_coarse umf_utils)
 
-    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")
+if(UMF_LINK_HWLOC_STATICALLY)
+    add_dependencies(umf ${UMF_HWLOC_NAME})
+    # On Darwin, link with the IOKit and Foundation frameworks, if they are
+    # available in the system. This is to comply with hwloc which links these,
+    # if available. There is no option to disable these frameworks on Darwin
+    # hwloc builds.
+    if(MACOSX)
+        find_library(IOKIT_LIBRARY IOKit)
+        find_library(FOUNDATION_LIBRARY Foundation)
+        if(IOKIT_LIBRARY OR FOUNDATION_LIBRARY)
+            target_link_libraries(umf PRIVATE ${IOKIT_LIBRARY}
+                                              ${FOUNDATION_LIBRARY})
+        endif()
     endif()
+endif()
 
-    set(UMF_COMPILE_DEFINITIONS ${UMF_COMPILE_DEFINITIONS}
-                                "UMF_BUILD_LEVEL_ZERO_PROVIDER=1")
+if(NOT WINDOWS AND UMF_POOL_JEMALLOC_ENABLED)
+    add_dependencies(umf jemalloc)
 endif()
 
 add_library(${PROJECT_NAME}::umf ALIAS umf)
@@ -219,22 +188,24 @@ if(LEVEL_ZERO_INCLUDE_DIRS)
     target_include_directories(umf PRIVATE ${LEVEL_ZERO_INCLUDE_DIRS})
 endif()
 
+if(CUDA_INCLUDE_DIRS)
+    target_include_directories(umf PRIVATE ${CUDA_INCLUDE_DIRS})
+endif()
+
 target_include_directories(
     umf
     PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/ravl>
            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/critnib>
            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/provider>
            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/memspaces>
-           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/memory_targets>
+           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/memtargets>
+           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/uthash>
            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
 
 install(TARGETS umf EXPORT ${PROJECT_NAME}-targets)
 
-add_subdirectory(pool)
-
-if(UMF_PROXY_LIB_ENABLED
-   AND NOT UMF_LINK_HWLOC_STATICALLY
-   AND NOT UMF_DISABLE_HWLOC)
+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 144f5423b..60126c9f0 100644
--- a/src/base_alloc/base_alloc.c
+++ b/src/base_alloc/base_alloc.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -36,7 +36,7 @@ struct umf_ba_chunk_t {
 struct umf_ba_main_pool_meta_t {
     size_t pool_size; // size of each pool (argument of each ba_os_alloc() call)
     size_t chunk_size;         // size of all memory chunks in this pool
-    os_mutex_t free_lock;      // lock of free_list
+    utils_mutex_t free_lock;   // lock of free_list
     umf_ba_chunk_t *free_list; // list of free chunks
     size_t n_allocs;           // number of allocated chunks
 #ifndef NDEBUG
@@ -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
@@ -134,8 +141,11 @@ static void *ba_os_alloc_annotated(size_t pool_size) {
 }
 
 umf_ba_pool_t *umf_ba_create(size_t size) {
-    size_t chunk_size = ALIGN_UP(size, MEMORY_ALIGNMENT);
-    size_t mutex_size = ALIGN_UP(util_mutex_get_size(), MEMORY_ALIGNMENT);
+    size_t chunk_size = ALIGN_UP_SAFE(size, MEMORY_ALIGNMENT);
+    if (chunk_size == 0) {
+        return NULL;
+    }
+    size_t mutex_size = ALIGN_UP(utils_mutex_get_size(), MEMORY_ALIGNMENT);
 
     size_t metadata_size = sizeof(struct umf_ba_main_pool_meta_t);
     size_t pool_size = sizeof(void *) + metadata_size + mutex_size +
@@ -144,7 +154,10 @@ umf_ba_pool_t *umf_ba_create(size_t size) {
         pool_size = MINIMUM_POOL_SIZE;
     }
 
-    pool_size = ALIGN_UP(pool_size, ba_os_get_page_size());
+    pool_size = ALIGN_UP_SAFE(pool_size, ba_os_get_page_size());
+    if (pool_size == 0) {
+        return NULL;
+    }
 
     umf_ba_pool_t *pool = (umf_ba_pool_t *)ba_os_alloc_annotated(pool_size);
     if (!pool) {
@@ -168,10 +181,11 @@ umf_ba_pool_t *umf_ba_create(size_t size) {
     char *data_ptr = (char *)&pool->data;
     size_t size_left = pool_size - offsetof(umf_ba_pool_t, data);
 
-    util_align_ptr_size((void **)&data_ptr, &size_left, MEMORY_ALIGNMENT);
+    utils_align_ptr_up_size_down((void **)&data_ptr, &size_left,
+                                 MEMORY_ALIGNMENT);
 
     // init free_lock
-    os_mutex_t *mutex = util_mutex_init(&pool->metadata.free_lock);
+    utils_mutex_t *mutex = utils_mutex_init(&pool->metadata.free_lock);
     if (!mutex) {
         ba_os_free(pool, pool_size);
         return NULL;
@@ -184,13 +198,13 @@ umf_ba_pool_t *umf_ba_create(size_t size) {
 }
 
 void *umf_ba_alloc(umf_ba_pool_t *pool) {
-    util_mutex_lock(&pool->metadata.free_lock);
+    utils_mutex_lock(&pool->metadata.free_lock);
     if (pool->metadata.free_list == NULL) {
         umf_ba_next_pool_t *new_pool =
             (umf_ba_next_pool_t *)ba_os_alloc_annotated(
                 pool->metadata.pool_size);
         if (!new_pool) {
-            util_mutex_unlock(&pool->metadata.free_lock);
+            utils_mutex_unlock(&pool->metadata.free_lock);
             return NULL;
         }
 
@@ -209,7 +223,8 @@ void *umf_ba_alloc(umf_ba_pool_t *pool) {
         size_t size_left =
             pool->metadata.pool_size - offsetof(umf_ba_next_pool_t, data);
 
-        util_align_ptr_size((void **)&data_ptr, &size_left, MEMORY_ALIGNMENT);
+        utils_align_ptr_up_size_down((void **)&data_ptr, &size_left,
+                                     MEMORY_ALIGNMENT);
         ba_divide_memory_into_chunks(pool, data_ptr, size_left);
     }
 
@@ -222,6 +237,7 @@ void *umf_ba_alloc(umf_ba_pool_t *pool) {
     // check if the free list is not empty
     if (pool->metadata.free_list == NULL) {
         LOG_ERR("base_alloc: Free list should not be empty before new alloc");
+        utils_mutex_unlock(&pool->metadata.free_lock);
         return NULL;
     }
 
@@ -234,7 +250,7 @@ void *umf_ba_alloc(umf_ba_pool_t *pool) {
     VALGRIND_DO_MALLOCLIKE_BLOCK(chunk, pool->metadata.chunk_size, 0, 0);
     utils_annotate_memory_undefined(chunk, pool->metadata.chunk_size);
 
-    util_mutex_unlock(&pool->metadata.free_lock);
+    utils_mutex_unlock(&pool->metadata.free_lock);
 
     return chunk;
 }
@@ -269,7 +285,7 @@ void umf_ba_free(umf_ba_pool_t *pool, void *ptr) {
 
     umf_ba_chunk_t *chunk = (umf_ba_chunk_t *)ptr;
 
-    util_mutex_lock(&pool->metadata.free_lock);
+    utils_mutex_lock(&pool->metadata.free_lock);
     assert(pool_contains_pointer(pool, ptr));
     chunk->next = pool->metadata.free_list;
     pool->metadata.free_list = chunk;
@@ -281,21 +297,29 @@ void umf_ba_free(umf_ba_pool_t *pool, void *ptr) {
     VALGRIND_DO_FREELIKE_BLOCK(chunk, 0);
     utils_annotate_memory_inaccessible(chunk, pool->metadata.chunk_size);
 
-    util_mutex_unlock(&pool->metadata.free_lock);
+    utils_mutex_unlock(&pool->metadata.free_lock);
 }
 
 void umf_ba_destroy(umf_ba_pool_t *pool) {
     // Do not destroy if we are running in the proxy library,
     // because it may need those resources till
     // the very end of exiting the application.
-    if (pool->metadata.n_allocs && util_is_running_in_proxy_lib()) {
+    if (pool->metadata.n_allocs && utils_is_running_in_proxy_lib()) {
         return;
     }
 
 #ifndef NDEBUG
     ba_debug_checks(pool);
     if (pool->metadata.n_allocs) {
-        LOG_ERR("pool->metadata.n_allocs = %zu", pool->metadata.n_allocs);
+#ifdef UMF_DEVELOPER_MODE
+        LOG_FATAL("number of base allocator memory leaks: %zu",
+                  pool->metadata.n_allocs);
+        assert(pool->metadata.n_allocs == 0 &&
+               "memory leaks in base allocator occurred");
+#else
+        LOG_ERR("number of base allocator memory leaks: %zu",
+                pool->metadata.n_allocs);
+#endif
     }
 #endif /* NDEBUG */
 
@@ -308,6 +332,6 @@ void umf_ba_destroy(umf_ba_pool_t *pool) {
         ba_os_free(current_pool, size);
     }
 
-    util_mutex_destroy_not_free(&pool->metadata.free_lock);
+    utils_mutex_destroy_not_free(&pool->metadata.free_lock);
     ba_os_free(pool, size);
 }
diff --git a/src/base_alloc/base_alloc_global.c b/src/base_alloc/base_alloc_global.c
index b5660d440..7cc8ae494 100644
--- a/src/base_alloc/base_alloc_global.c
+++ b/src/base_alloc/base_alloc_global.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -23,6 +23,7 @@
 
 // global base allocator used by all providers and pools
 static UTIL_ONCE_FLAG ba_is_initialized = UTIL_ONCE_FLAG_INIT;
+static bool ba_is_destroyed = false;
 
 #define ALLOC_METADATA_SIZE (sizeof(size_t))
 
@@ -40,6 +41,9 @@ struct base_alloc_t {
 static struct base_alloc_t BASE_ALLOC = {.ac_sizes = ALLOCATION_CLASSES};
 
 void umf_ba_destroy_global(void) {
+    LOG_DEBUG("destroying global base allocator");
+    ba_is_destroyed = true;
+
     for (int i = 0; i < NUM_ALLOCATION_CLASSES; i++) {
         if (BASE_ALLOC.ac[i]) {
             umf_ba_destroy(BASE_ALLOC.ac[i]);
@@ -48,10 +52,12 @@ void umf_ba_destroy_global(void) {
     }
 
     // portable version of "ba_is_initialized = UTIL_ONCE_FLAG_INIT;"
-    static UTIL_ONCE_FLAG is_initialized = UTIL_ONCE_FLAG_INIT;
-    memcpy(&ba_is_initialized, &is_initialized, sizeof(ba_is_initialized));
+    static UTIL_ONCE_FLAG set_once = UTIL_ONCE_FLAG_INIT;
+    memcpy(&ba_is_initialized, &set_once, sizeof(ba_is_initialized));
 }
 
+bool umf_ba_global_is_destroyed(void) { return ba_is_destroyed; }
+
 static void umf_ba_create_global(void) {
     for (int i = 0; i < NUM_ALLOCATION_CLASSES; i++) {
         // allocation classes need to be powers of 2
@@ -66,7 +72,10 @@ static void umf_ba_create_global(void) {
     }
 
     size_t smallestSize = BASE_ALLOC.ac_sizes[0];
-    BASE_ALLOC.smallest_ac_size_log2 = log2Utils(smallestSize);
+    BASE_ALLOC.smallest_ac_size_log2 = utils_msb64(smallestSize);
+
+    LOG_DEBUG("global base allocator created");
+    ba_is_destroyed = false;
 }
 
 // returns index of the allocation class for a given size
@@ -76,8 +85,8 @@ static int size_to_idx(size_t size) {
     }
 
     int isPowerOf2 = (0 == (size & (size - 1)));
-    int index =
-        (int)(log2Utils(size) + !isPowerOf2 - BASE_ALLOC.smallest_ac_size_log2);
+    int index = (int)(utils_msb64(size) + !isPowerOf2 -
+                      BASE_ALLOC.smallest_ac_size_log2);
 
     assert(index >= 0);
     return index;
@@ -96,8 +105,12 @@ static void *add_metadata_and_align(void *ptr, size_t size, size_t alignment) {
     if (alignment <= ALLOC_METADATA_SIZE) {
         user_ptr = (void *)((uintptr_t)ptr + ALLOC_METADATA_SIZE);
     } else {
-        user_ptr =
-            (void *)ALIGN_UP((uintptr_t)ptr + ALLOC_METADATA_SIZE, alignment);
+        user_ptr = (void *)ALIGN_UP_SAFE((uintptr_t)ptr + ALLOC_METADATA_SIZE,
+                                         alignment);
+        if (!user_ptr) {
+            LOG_ERR("base_alloc: pointer alignment overflow");
+            return NULL;
+        }
     }
 
     size_t ptr_offset_from_original = (uintptr_t)user_ptr - (uintptr_t)ptr;
@@ -119,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);
 
@@ -149,24 +162,30 @@ static void *get_original_alloc(void *user_ptr, size_t *total_size,
 }
 
 void *umf_ba_global_aligned_alloc(size_t size, size_t alignment) {
-    util_init_once(&ba_is_initialized, umf_ba_create_global);
+    utils_init_once(&ba_is_initialized, umf_ba_create_global);
 
     if (size == 0) {
         return NULL;
     }
 
+    if (size > SIZE_MAX - ALLOC_METADATA_SIZE) {
+        LOG_ERR("base_alloc: allocation size (%zu) too large.", size);
+        return NULL;
+    }
+
     // for metadata
     size += ALLOC_METADATA_SIZE;
 
     if (alignment > ALLOC_METADATA_SIZE) {
+        if (size > SIZE_MAX - alignment) {
+            LOG_ERR("base_alloc: allocation size (%zu) too large.", size);
+            return NULL;
+        }
         size += alignment;
     }
 
     int ac_index = size_to_idx(size);
     if (ac_index >= NUM_ALLOCATION_CLASSES) {
-        LOG_WARN("base_alloc: allocation size (%zu) larger than the biggest "
-                 "allocation class. Falling back to OS memory allocation.",
-                 size);
         return add_metadata_and_align(ba_os_alloc(size), size, alignment);
     }
 
@@ -190,6 +209,12 @@ void umf_ba_global_free(void *ptr) {
         return;
     }
 
+    if (ba_is_destroyed) {
+        LOG_WARN(
+            "base_alloc: calling free() after the base allocator is destroyed");
+        return;
+    }
+
     size_t total_size;
     ptr = get_original_alloc(ptr, &total_size, NULL);
 
@@ -210,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 ad7f12ce5..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
@@ -8,6 +8,8 @@
 #ifndef UMF_BASE_ALLOC_GLOBAL_H
 #define UMF_BASE_ALLOC_GLOBAL_H 1
 
+#include <stdbool.h>
+
 #include "base_alloc.h"
 
 #ifdef __cplusplus
@@ -17,7 +19,8 @@ extern "C" {
 void *umf_ba_global_alloc(size_t size);
 void umf_ba_global_free(void *ptr);
 void umf_ba_destroy_global(void);
-size_t umf_ba_global_malloc_usable_size(void *ptr);
+bool umf_ba_global_is_destroyed(void);
+size_t umf_ba_global_malloc_usable_size(const void *ptr);
 void *umf_ba_global_aligned_alloc(size_t size, size_t alignment);
 
 #ifdef __cplusplus
diff --git a/src/base_alloc/base_alloc_linear.c b/src/base_alloc/base_alloc_linear.c
index be7b0943c..a35a6c243 100644
--- a/src/base_alloc/base_alloc_linear.c
+++ b/src/base_alloc/base_alloc_linear.c
@@ -31,7 +31,7 @@ typedef struct umf_ba_next_linear_pool_t umf_ba_next_linear_pool_t;
 // metadata is set and used only in the main (the first) pool
 typedef struct umf_ba_main_linear_pool_meta_t {
     size_t pool_size; // size of this pool (argument of ba_os_alloc() call)
-    os_mutex_t lock;
+    utils_mutex_t lock;
     char *data_ptr;
     size_t size_left;
     size_t pool_n_allocs; // number of allocations in this pool
@@ -88,7 +88,11 @@ umf_ba_linear_pool_t *umf_ba_linear_create(size_t pool_size) {
         pool_size = MINIMUM_LINEAR_POOL_SIZE;
     }
 
-    pool_size = ALIGN_UP(pool_size, ba_os_get_page_size());
+    pool_size = ALIGN_UP_SAFE(pool_size, ba_os_get_page_size());
+    if (pool_size == 0) {
+        LOG_ERR("pool_size page alignment overflow");
+        return NULL;
+    }
 
     umf_ba_linear_pool_t *pool = (umf_ba_linear_pool_t *)ba_os_alloc(pool_size);
     if (!pool) {
@@ -98,7 +102,7 @@ umf_ba_linear_pool_t *umf_ba_linear_create(size_t pool_size) {
     void *data_ptr = &pool->data;
     size_t size_left = pool_size - offsetof(umf_ba_linear_pool_t, data);
 
-    util_align_ptr_size(&data_ptr, &size_left, MEMORY_ALIGNMENT);
+    utils_align_ptr_up_size_down(&data_ptr, &size_left, MEMORY_ALIGNMENT);
 
     pool->metadata.pool_size = pool_size;
     pool->metadata.data_ptr = data_ptr;
@@ -109,7 +113,7 @@ umf_ba_linear_pool_t *umf_ba_linear_create(size_t pool_size) {
     _DEBUG_EXECUTE(pool->metadata.global_n_allocs = 0);
 
     // init lock
-    os_mutex_t *lock = util_mutex_init(&pool->metadata.lock);
+    utils_mutex_t *lock = utils_mutex_init(&pool->metadata.lock);
     if (!lock) {
         ba_os_free(pool, pool_size);
         return NULL;
@@ -122,15 +126,24 @@ void *umf_ba_linear_alloc(umf_ba_linear_pool_t *pool, size_t size) {
     if (size == 0) {
         return NULL;
     }
-    size_t aligned_size = ALIGN_UP(size, MEMORY_ALIGNMENT);
-    util_mutex_lock(&pool->metadata.lock);
+    size_t aligned_size = ALIGN_UP_SAFE(size, MEMORY_ALIGNMENT);
+    if (aligned_size == 0) {
+        LOG_ERR("size alignment overflow");
+        return NULL;
+    }
+    utils_mutex_lock(&pool->metadata.lock);
     if (pool->metadata.size_left < aligned_size) {
         size_t pool_size = MINIMUM_LINEAR_POOL_SIZE;
         size_t usable_size =
             pool_size - offsetof(umf_ba_next_linear_pool_t, data);
         if (usable_size < aligned_size) {
             pool_size += aligned_size - usable_size;
-            pool_size = ALIGN_UP(pool_size, ba_os_get_page_size());
+            pool_size = ALIGN_UP_SAFE(pool_size, ba_os_get_page_size());
+            if (pool_size == 0) {
+                utils_mutex_unlock(&pool->metadata.lock);
+                LOG_ERR("pool_size page alignment overflow");
+                return NULL;
+            }
         }
 
         assert(pool_size - offsetof(umf_ba_next_linear_pool_t, data) >=
@@ -139,7 +152,7 @@ void *umf_ba_linear_alloc(umf_ba_linear_pool_t *pool, size_t size) {
         umf_ba_next_linear_pool_t *new_pool =
             (umf_ba_next_linear_pool_t *)ba_os_alloc(pool_size);
         if (!new_pool) {
-            util_mutex_unlock(&pool->metadata.lock);
+            utils_mutex_unlock(&pool->metadata.lock);
             return NULL;
         }
 
@@ -149,7 +162,7 @@ void *umf_ba_linear_alloc(umf_ba_linear_pool_t *pool, size_t size) {
         void *data_ptr = &new_pool->data;
         size_t size_left =
             new_pool->pool_size - offsetof(umf_ba_next_linear_pool_t, data);
-        util_align_ptr_size(&data_ptr, &size_left, MEMORY_ALIGNMENT);
+        utils_align_ptr_up_size_down(&data_ptr, &size_left, MEMORY_ALIGNMENT);
 
         pool->metadata.data_ptr = data_ptr;
         pool->metadata.size_left = size_left;
@@ -171,7 +184,7 @@ void *umf_ba_linear_alloc(umf_ba_linear_pool_t *pool, size_t size) {
     }
     _DEBUG_EXECUTE(pool->metadata.global_n_allocs++);
     _DEBUG_EXECUTE(ba_debug_checks(pool));
-    util_mutex_unlock(&pool->metadata.lock);
+    utils_mutex_unlock(&pool->metadata.lock);
 
     return ptr;
 }
@@ -188,7 +201,7 @@ static inline int pool_contains_ptr(void *pool, size_t pool_size,
 // 0  - ptr belonged to the pool and was freed
 // -1 - ptr doesn't belong to the pool and wasn't freed
 int umf_ba_linear_free(umf_ba_linear_pool_t *pool, void *ptr) {
-    util_mutex_lock(&pool->metadata.lock);
+    utils_mutex_lock(&pool->metadata.lock);
     _DEBUG_EXECUTE(ba_debug_checks(pool));
     if (pool_contains_ptr(pool, pool->metadata.pool_size, pool->data, ptr)) {
         pool->metadata.pool_n_allocs--;
@@ -204,7 +217,7 @@ int umf_ba_linear_free(umf_ba_linear_pool_t *pool, void *ptr) {
             pool->metadata.pool_size = page_size;
         }
         _DEBUG_EXECUTE(ba_debug_checks(pool));
-        util_mutex_unlock(&pool->metadata.lock);
+        utils_mutex_unlock(&pool->metadata.lock);
         return 0;
     }
 
@@ -227,14 +240,14 @@ int umf_ba_linear_free(umf_ba_linear_pool_t *pool, void *ptr) {
                 ba_os_free(next_pool_ptr, size);
             }
             _DEBUG_EXECUTE(ba_debug_checks(pool));
-            util_mutex_unlock(&pool->metadata.lock);
+            utils_mutex_unlock(&pool->metadata.lock);
             return 0;
         }
         prev_pool = next_pool;
         next_pool = next_pool->next_pool;
     }
 
-    util_mutex_unlock(&pool->metadata.lock);
+    utils_mutex_unlock(&pool->metadata.lock);
     // ptr doesn't belong to the pool and wasn't freed
     return -1;
 }
@@ -243,7 +256,7 @@ void umf_ba_linear_destroy(umf_ba_linear_pool_t *pool) {
     // Do not destroy if we are running in the proxy library,
     // because it may need those resources till
     // the very end of exiting the application.
-    if (util_is_running_in_proxy_lib()) {
+    if (utils_is_running_in_proxy_lib()) {
         return;
     }
 
@@ -262,7 +275,7 @@ void umf_ba_linear_destroy(umf_ba_linear_pool_t *pool) {
         ba_os_free(current_pool, current_pool->pool_size);
     }
 
-    util_mutex_destroy_not_free(&pool->metadata.lock);
+    utils_mutex_destroy_not_free(&pool->metadata.lock);
     ba_os_free(pool, pool->metadata.pool_size);
 }
 
@@ -272,12 +285,12 @@ void umf_ba_linear_destroy(umf_ba_linear_pool_t *pool) {
 //   to the end of the pool if ptr belongs to the pool
 size_t umf_ba_linear_pool_contains_pointer(umf_ba_linear_pool_t *pool,
                                            void *ptr) {
-    util_mutex_lock(&pool->metadata.lock);
+    utils_mutex_lock(&pool->metadata.lock);
     char *cptr = (char *)ptr;
     if (cptr >= pool->data &&
         cptr < ((char *)(pool)) + pool->metadata.pool_size) {
         size_t size = ((char *)(pool)) + pool->metadata.pool_size - cptr;
-        util_mutex_unlock(&pool->metadata.lock);
+        utils_mutex_unlock(&pool->metadata.lock);
         return size;
     }
 
@@ -286,12 +299,12 @@ size_t umf_ba_linear_pool_contains_pointer(umf_ba_linear_pool_t *pool,
         if (cptr >= next_pool->data &&
             cptr < ((char *)(next_pool)) + next_pool->pool_size) {
             size_t size = ((char *)(next_pool)) + next_pool->pool_size - cptr;
-            util_mutex_unlock(&pool->metadata.lock);
+            utils_mutex_unlock(&pool->metadata.lock);
             return size;
         }
         next_pool = next_pool->next_pool;
     }
 
-    util_mutex_unlock(&pool->metadata.lock);
+    utils_mutex_unlock(&pool->metadata.lock);
     return 0;
 }
diff --git a/src/base_alloc/base_alloc_linux.c b/src/base_alloc/base_alloc_linux.c
index 3e5456b2c..9b1dc63fe 100644
--- a/src/base_alloc/base_alloc_linux.c
+++ b/src/base_alloc/base_alloc_linux.c
@@ -1,26 +1,22 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 */
 
 #include <assert.h>
-#include <stdio.h>
 #include <sys/mman.h>
-#include <sys/syscall.h>
 #include <unistd.h>
 
-#include "base_alloc.h"
-#include "base_alloc_global.h"
 #include "utils_concurrency.h"
 
 static UTIL_ONCE_FLAG Page_size_is_initialized = UTIL_ONCE_FLAG_INIT;
 static size_t Page_size;
 
 void *ba_os_alloc(size_t size) {
-    void *ptr = mmap(NULL, size, PROT_READ | PROT_WRITE,
-                     MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    void *ptr = utils_mmap(NULL, size, PROT_READ | PROT_WRITE,
+                           MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
     // this should be unnecessary but pairs of mmap/munmap do not reset
     // asan's user-poisoning flags, leading to invalid error reports
     // Bug 81619: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81619
@@ -29,7 +25,7 @@ void *ba_os_alloc(size_t size) {
 }
 
 void ba_os_free(void *ptr, size_t size) {
-    int ret = munmap(ptr, size);
+    int ret = utils_munmap(ptr, size);
     assert(ret == 0);
     (void)ret; // unused
 }
@@ -37,6 +33,6 @@ void ba_os_free(void *ptr, size_t size) {
 static void _ba_os_init_page_size(void) { Page_size = sysconf(_SC_PAGE_SIZE); }
 
 size_t ba_os_get_page_size(void) {
-    util_init_once(&Page_size_is_initialized, _ba_os_init_page_size);
+    utils_init_once(&Page_size_is_initialized, _ba_os_init_page_size);
     return Page_size;
 }
diff --git a/src/base_alloc/base_alloc_windows.c b/src/base_alloc/base_alloc_windows.c
index 6f6c58fbc..2e9da23d9 100644
--- a/src/base_alloc/base_alloc_windows.c
+++ b/src/base_alloc/base_alloc_windows.c
@@ -28,6 +28,6 @@ static void _ba_os_init_page_size(void) {
 }
 
 size_t ba_os_get_page_size(void) {
-    util_init_once(&Page_size_is_initialized, _ba_os_init_page_size);
+    utils_init_once(&Page_size_is_initialized, _ba_os_init_page_size);
     return Page_size;
 }
diff --git a/src/coarse/CMakeLists.txt b/src/coarse/CMakeLists.txt
new file mode 100644
index 000000000..32465b4e4
--- /dev/null
+++ b/src/coarse/CMakeLists.txt
@@ -0,0 +1,24 @@
+# Copyright (C) 2024-2025 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+include(${UMF_CMAKE_SOURCE_DIR}/cmake/helpers.cmake)
+
+set(UMF_COARSE_SOURCES coarse.c ${UMF_CMAKE_SOURCE_DIR}/src/ravl/ravl.c)
+set(UMF_COARSE_LIBS umf_utils umf_ba)
+
+add_umf_library(
+    NAME umf_coarse
+    TYPE STATIC
+    SRCS ${UMF_COARSE_SOURCES}
+    LIBS ${UMF_COARSE_LIBS})
+
+target_include_directories(
+    umf_coarse
+    PRIVATE ${UMF_CMAKE_SOURCE_DIR}/src/coarse
+            ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc
+            ${UMF_CMAKE_SOURCE_DIR}/src/ravl)
+
+if(NOT UMF_BUILD_SHARED_LIBRARY)
+    install(TARGETS umf_coarse EXPORT ${PROJECT_NAME}-targets)
+endif()
diff --git a/src/coarse/coarse.c b/src/coarse/coarse.c
new file mode 100644
index 000000000..a161ea575
--- /dev/null
+++ b/src/coarse/coarse.c
@@ -0,0 +1,1415 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <umf.h>
+
+#include "base_alloc_global.h"
+#include "coarse.h"
+#include "libumf.h"
+#include "ravl.h"
+#include "utils_common.h"
+#include "utils_concurrency.h"
+#include "utils_log.h"
+
+#ifdef _WIN32
+UTIL_ONCE_FLAG Log_initialized = UTIL_ONCE_FLAG_INIT;
+#else
+void __attribute__((constructor)) coarse_init(void) { utils_log_init(); }
+void __attribute__((destructor)) coarse_destroy(void) {}
+#endif /* _WIN32 */
+
+typedef struct coarse_t {
+    // handle of the memory provider
+    void *provider;
+
+    // coarse callbacks
+    coarse_callbacks_t cb;
+
+    // memory allocation strategy
+    coarse_strategy_t allocation_strategy;
+
+    // page size of the memory provider
+    size_t page_size;
+
+    // all_blocks - tree of all blocks - sorted by an address of data
+    struct ravl *all_blocks;
+
+    // free_blocks - tree of free blocks - sorted by a size of data,
+    // each node contains a pointer (ravl_free_blocks_head_t)
+    // to the head of the list of free blocks of the same size
+    struct ravl *free_blocks;
+
+    struct utils_mutex_t lock;
+
+    // statistics
+    size_t used_size;
+    size_t alloc_size;
+} coarse_t;
+
+typedef struct ravl_node ravl_node_t;
+
+typedef enum check_free_blocks_t {
+    CHECK_ONLY_THE_FIRST_BLOCK = 0,
+    CHECK_ALL_BLOCKS_OF_SIZE,
+} check_free_blocks_t;
+
+typedef struct block_t {
+    size_t size;
+    unsigned char *data;
+    bool used;
+
+    // Node in the list of free blocks of the same size pointing to this block.
+    // The list is located in the (coarse->free_blocks) RAVL tree.
+    struct ravl_free_blocks_elem_t *free_list_ptr;
+} block_t;
+
+// A general node in a RAVL tree.
+// 1) coarse->all_blocks RAVL tree (tree of all blocks - sorted by an address of data):
+//    key   - pointer (block_t->data) to the beginning of the block data
+//    value - pointer (block_t) to the block of the allocation
+// 2) coarse->free_blocks RAVL tree (tree of free blocks - sorted by a size of data):
+//    key   - size of the allocation (block_t->size)
+//    value - pointer (ravl_free_blocks_head_t) to the head of the list of free blocks of the same size
+typedef struct ravl_data_t {
+    uintptr_t key;
+    void *value;
+} ravl_data_t;
+
+// The head of the list of free blocks of the same size.
+typedef struct ravl_free_blocks_head_t {
+    struct ravl_free_blocks_elem_t *head;
+} ravl_free_blocks_head_t;
+
+// The node of the list of free blocks of the same size
+typedef struct ravl_free_blocks_elem_t {
+    struct block_t *block;
+    struct ravl_free_blocks_elem_t *next;
+    struct ravl_free_blocks_elem_t *prev;
+} ravl_free_blocks_elem_t;
+
+// The compare function of a RAVL tree
+static int coarse_ravl_comp(const void *lhs, const void *rhs) {
+    const ravl_data_t *lhs_ravl = (const ravl_data_t *)lhs;
+    const ravl_data_t *rhs_ravl = (const ravl_data_t *)rhs;
+
+    if (lhs_ravl->key < rhs_ravl->key) {
+        return -1;
+    }
+
+    if (lhs_ravl->key > rhs_ravl->key) {
+        return 1;
+    }
+
+    // lhs_ravl->key == rhs_ravl->key
+    return 0;
+}
+
+static inline block_t *get_node_block(ravl_node_t *node) {
+    ravl_data_t *node_data = ravl_data(node);
+    assert(node_data);
+    assert(node_data->value);
+    return node_data->value;
+}
+
+static inline ravl_node_t *get_node_prev(ravl_node_t *node) {
+    return ravl_node_predecessor(node);
+}
+
+static inline ravl_node_t *get_node_next(ravl_node_t *node) {
+    return ravl_node_successor(node);
+}
+
+#if !defined(NDEBUG) && defined(UMF_DEVELOPER_MODE)
+static block_t *get_block_prev(ravl_node_t *node) {
+    ravl_node_t *ravl_prev = ravl_node_predecessor(node);
+    if (!ravl_prev) {
+        return NULL;
+    }
+
+    return get_node_block(ravl_prev);
+}
+
+static block_t *get_block_next(ravl_node_t *node) {
+    ravl_node_t *ravl_next = ravl_node_successor(node);
+    if (!ravl_next) {
+        return NULL;
+    }
+
+    return get_node_block(ravl_next);
+}
+#endif /* !defined(NDEBUG) && defined(UMF_DEVELOPER_MODE) */
+
+// The functions "coarse_ravl_*" handles the coarse->all_blocks list of blocks
+// sorted by a pointer (block_t->data) to the beginning of the block data.
+//
+// coarse_ravl_add_new - allocate and add a new block to the tree
+// and link this block to the next and the previous one.
+static block_t *coarse_ravl_add_new(struct ravl *rtree, unsigned char *data,
+                                    size_t size, ravl_node_t **node) {
+    assert(rtree);
+    assert(data);
+    assert(size);
+
+    // TODO add valgrind annotations
+    block_t *block = umf_ba_global_alloc(sizeof(*block));
+    if (block == NULL) {
+        return NULL;
+    }
+
+    block->data = data;
+    block->size = size;
+    block->free_list_ptr = NULL;
+
+    ravl_data_t rdata = {(uintptr_t)block->data, block};
+    assert(NULL == ravl_find(rtree, &data, RAVL_PREDICATE_EQUAL));
+    int ret = ravl_emplace_copy(rtree, &rdata);
+    if (ret) {
+        umf_ba_global_free(block);
+        return NULL;
+    }
+
+    ravl_node_t *new_node = ravl_find(rtree, &rdata, RAVL_PREDICATE_EQUAL);
+    assert(NULL != new_node);
+
+    if (node) {
+        *node = new_node;
+    }
+
+    return block;
+}
+
+// coarse_ravl_find_node - find the node in the tree
+static ravl_node_t *coarse_ravl_find_node(struct ravl *rtree, void *ptr) {
+    ravl_data_t data = {(uintptr_t)ptr, NULL};
+    return ravl_find(rtree, &data, RAVL_PREDICATE_EQUAL);
+}
+
+// coarse_ravl_rm - remove the block from the tree
+static block_t *coarse_ravl_rm(struct ravl *rtree, void *ptr) {
+    ravl_data_t data = {(uintptr_t)ptr, NULL};
+    ravl_node_t *node;
+    node = ravl_find(rtree, &data, RAVL_PREDICATE_EQUAL);
+    if (node) {
+        ravl_data_t *node_data = ravl_data(node);
+        assert(node_data);
+        block_t *block = node_data->value;
+        assert(block);
+        ravl_remove(rtree, node);
+        assert(NULL == ravl_find(rtree, &data, RAVL_PREDICATE_EQUAL));
+        return block;
+    }
+    return NULL;
+}
+
+// The functions "node_list_*" handle lists of free blocks of the same size.
+// The heads (ravl_free_blocks_head_t) of those lists are stored in nodes of
+// the coarse->free_blocks RAVL tree.
+//
+// node_list_add - add a free block to the list of free blocks of the same size
+static ravl_free_blocks_elem_t *
+node_list_add(ravl_free_blocks_head_t *head_node, struct block_t *block) {
+    assert(head_node);
+    assert(block);
+
+    ravl_free_blocks_elem_t *node = umf_ba_global_alloc(sizeof(*node));
+    if (node == NULL) {
+        return NULL;
+    }
+
+    if (head_node->head) {
+        head_node->head->prev = node;
+    }
+
+    node->block = block;
+    node->next = head_node->head;
+    node->prev = NULL;
+    head_node->head = node;
+
+    return node;
+}
+
+// node_list_rm - remove the given free block from the list of free blocks of the same size
+static block_t *node_list_rm(ravl_free_blocks_head_t *head_node,
+                             ravl_free_blocks_elem_t *node) {
+    assert(head_node);
+    assert(node);
+    assert(head_node->head);
+
+    if (node == head_node->head) {
+        assert(node->prev == NULL);
+        head_node->head = node->next;
+    }
+
+    ravl_free_blocks_elem_t *node_next = node->next;
+    ravl_free_blocks_elem_t *node_prev = node->prev;
+    if (node_next) {
+        node_next->prev = node_prev;
+    }
+
+    if (node_prev) {
+        node_prev->next = node_next;
+    }
+
+    struct block_t *block = node->block;
+    block->free_list_ptr = NULL;
+    umf_ba_global_free(node);
+
+    return block;
+}
+
+// node_list_rm_first - remove the first free block from the list of free blocks of the same size only if it can be properly aligned
+static block_t *node_list_rm_first(ravl_free_blocks_head_t *head_node,
+                                   size_t alignment) {
+    assert(head_node);
+    assert(head_node->head);
+
+    ravl_free_blocks_elem_t *node = head_node->head;
+    assert(node->prev == NULL);
+    struct block_t *block = node->block;
+
+    if (IS_NOT_ALIGNED(((uintptr_t)block->data), alignment)) {
+        return NULL;
+    }
+
+    if (node->next) {
+        node->next->prev = NULL;
+    }
+
+    head_node->head = node->next;
+    block->free_list_ptr = NULL;
+    umf_ba_global_free(node);
+
+    return block;
+}
+
+// node_list_rm_with_alignment - remove the first free block with the correct alignment from the list of free blocks of the same size
+static block_t *node_list_rm_with_alignment(ravl_free_blocks_head_t *head_node,
+                                            size_t alignment) {
+    assert(head_node);
+    assert(head_node->head);
+
+    assert(((ravl_free_blocks_elem_t *)head_node->head)->prev == NULL);
+
+    ravl_free_blocks_elem_t *node;
+    for (node = head_node->head; node != NULL; node = node->next) {
+        if (IS_ALIGNED(((uintptr_t)node->block->data), alignment)) {
+            return node_list_rm(head_node, node);
+        }
+    }
+
+    return NULL;
+}
+
+// The functions "free_blocks_*" handle the coarse->free_blocks RAVL tree
+// sorted by a size of the allocation (block_t->size).
+// This is a tree of heads (ravl_free_blocks_head_t) of lists of free blocks of the same size.
+//
+// free_blocks_add - add a free block to the list of free blocks of the same size
+static int free_blocks_add(struct ravl *free_blocks, block_t *block) {
+    ravl_free_blocks_head_t *head_node = NULL;
+    int rv;
+
+    ravl_data_t head_node_data = {(uintptr_t)block->size, NULL};
+    ravl_node_t *node;
+    node = ravl_find(free_blocks, &head_node_data, RAVL_PREDICATE_EQUAL);
+    if (node) {
+        ravl_data_t *node_data = ravl_data(node);
+        assert(node_data);
+        head_node = node_data->value;
+        assert(head_node);
+    } else { // no head_node
+        head_node = umf_ba_global_alloc(sizeof(*head_node));
+        if (!head_node) {
+            return -1;
+        }
+
+        head_node->head = NULL;
+
+        ravl_data_t data = {(uintptr_t)block->size, head_node};
+        rv = ravl_emplace_copy(free_blocks, &data);
+        if (rv) {
+            umf_ba_global_free(head_node);
+            return -1;
+        }
+    }
+
+    block->free_list_ptr = node_list_add(head_node, block);
+    if (!block->free_list_ptr) {
+        return -1; // out of memory
+    }
+
+    assert(block->free_list_ptr->block->size == block->size);
+
+    return 0;
+}
+
+// free_blocks_rm_ge - remove the first free block of a size greater or equal to the given size only if it can be properly aligned
+// If it was the last block, the head node is freed and removed from the tree.
+// It is used during memory allocation (looking for a free block).
+static block_t *free_blocks_rm_ge(struct ravl *free_blocks, size_t size,
+                                  size_t alignment,
+                                  check_free_blocks_t check_blocks) {
+    ravl_data_t data = {(uintptr_t)size, NULL};
+    ravl_node_t *node;
+    node = ravl_find(free_blocks, &data, RAVL_PREDICATE_GREATER_EQUAL);
+    if (!node) {
+        return NULL;
+    }
+
+    ravl_data_t *node_data = ravl_data(node);
+    assert(node_data);
+    assert(node_data->key >= size);
+
+    ravl_free_blocks_head_t *head_node = node_data->value;
+    assert(head_node);
+
+    block_t *block = NULL;
+    switch (check_blocks) {
+    case CHECK_ONLY_THE_FIRST_BLOCK:
+        block = node_list_rm_first(head_node, alignment);
+        break;
+    case CHECK_ALL_BLOCKS_OF_SIZE:
+        block = node_list_rm_with_alignment(head_node, alignment);
+        break;
+    }
+
+    if (head_node->head == NULL) {
+        umf_ba_global_free(head_node);
+        ravl_remove(free_blocks, node);
+    }
+
+    return block;
+}
+
+// free_blocks_rm_node - remove the free block pointed by the given node.
+// If it was the last block, the head node is freed and removed from the tree.
+// It is used during merging free blocks and destroying the coarse->free_blocks tree.
+static block_t *free_blocks_rm_node(struct ravl *free_blocks,
+                                    ravl_free_blocks_elem_t *node) {
+    assert(free_blocks);
+    assert(node);
+    size_t size = node->block->size;
+    ravl_data_t data = {(uintptr_t)size, NULL};
+    ravl_node_t *ravl_node;
+    ravl_node = ravl_find(free_blocks, &data, RAVL_PREDICATE_EQUAL);
+    assert(ravl_node);
+
+    ravl_data_t *node_data = ravl_data(ravl_node);
+    assert(node_data);
+    assert(node_data->key == size);
+
+    ravl_free_blocks_head_t *head_node = node_data->value;
+    assert(head_node);
+
+    block_t *block = node_list_rm(head_node, node);
+
+    if (head_node->head == NULL) {
+        umf_ba_global_free(head_node);
+        ravl_remove(free_blocks, ravl_node);
+    }
+
+    return block;
+}
+
+// user_block_merge - merge two blocks from one of two lists of user blocks: all_blocks or free_blocks
+static umf_result_t user_block_merge(coarse_t *coarse, ravl_node_t *node1,
+                                     ravl_node_t *node2, bool used,
+                                     ravl_node_t **merged_node) {
+    assert(node1);
+    assert(node2);
+    assert(node1 == get_node_prev(node2));
+    assert(node2 == get_node_next(node1));
+    assert(merged_node);
+
+    *merged_node = NULL;
+
+    struct ravl *all_blocks = coarse->all_blocks;
+    struct ravl *free_blocks = coarse->free_blocks;
+
+    block_t *block1 = get_node_block(node1);
+    block_t *block2 = get_node_block(node2);
+    assert(block1->data < block2->data);
+
+    bool same_used = ((block1->used == used) && (block2->used == used));
+    bool contiguous_data = (block1->data + block1->size == block2->data);
+
+    // check if blocks can be merged
+    if (!same_used || !contiguous_data) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    // check if blocks can be merged
+    umf_result_t umf_result =
+        coarse->cb.merge(coarse->provider, block1->data, block2->data,
+                         block1->size + block2->size);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("coarse_merge_cb(lowPtr=%p, highPtr=%p, totalSize=%zu) failed",
+                (void *)block1->data, (void *)block2->data,
+                block1->size + block2->size);
+        return umf_result;
+    }
+
+    if (block1->free_list_ptr) {
+        free_blocks_rm_node(free_blocks, block1->free_list_ptr);
+        block1->free_list_ptr = NULL;
+    }
+
+    if (block2->free_list_ptr) {
+        free_blocks_rm_node(free_blocks, block2->free_list_ptr);
+        block2->free_list_ptr = NULL;
+    }
+
+    // update the size
+    block1->size += block2->size;
+
+    block_t *block_rm = coarse_ravl_rm(all_blocks, block2->data);
+    assert(block_rm == block2);
+    (void)block_rm; // WA for unused variable error
+    umf_ba_global_free(block2);
+
+    *merged_node = node1;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+// free_block_merge_with_prev - merge the given free block
+// with the previous one if both are unused and have continuous data.
+// Remove the merged block from the tree of free blocks.
+static ravl_node_t *free_block_merge_with_prev(coarse_t *coarse,
+                                               ravl_node_t *node) {
+    ravl_node_t *node_prev = get_node_prev(node);
+    if (!node_prev) {
+        return node;
+    }
+
+    ravl_node_t *merged_node = NULL;
+    umf_result_t umf_result =
+        user_block_merge(coarse, node_prev, node, false, &merged_node);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        return node;
+    }
+
+    assert(merged_node != NULL);
+
+    return merged_node;
+}
+
+// free_block_merge_with_next - merge the given free block
+// with the next one if both are unused and have continuous data.
+// Remove the merged block from the tree of free blocks.
+static ravl_node_t *free_block_merge_with_next(coarse_t *coarse,
+                                               ravl_node_t *node) {
+    ravl_node_t *node_next = get_node_next(node);
+    if (!node_next) {
+        return node;
+    }
+
+    ravl_node_t *merged_node = NULL;
+    umf_result_t umf_result =
+        user_block_merge(coarse, node, node_next, false, &merged_node);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        return node;
+    }
+
+    assert(merged_node != NULL);
+
+    return merged_node;
+}
+
+#ifndef NDEBUG // begin of DEBUG code
+#ifdef UMF_DEVELOPER_MODE
+
+typedef struct debug_cb_args_t {
+    coarse_t *provider;
+    size_t sum_used;
+    size_t sum_blocks_size;
+    size_t num_all_blocks;
+    size_t num_free_blocks;
+} debug_cb_args_t;
+
+static void debug_verify_all_blocks_cb(void *data, void *arg) {
+    assert(data);
+    assert(arg);
+
+    ravl_data_t *node_data = data;
+    block_t *block = node_data->value;
+    assert(block);
+
+    debug_cb_args_t *cb_args = (debug_cb_args_t *)arg;
+    coarse_t *provider = cb_args->provider;
+
+    ravl_node_t *node =
+        ravl_find(provider->all_blocks, data, RAVL_PREDICATE_EQUAL);
+    assert(node);
+
+    block_t *block_next = get_block_next(node);
+    block_t *block_prev = get_block_prev(node);
+
+    cb_args->num_all_blocks++;
+    if (!block->used) {
+        cb_args->num_free_blocks++;
+    }
+
+    assert(block->data);
+    assert(block->size > 0);
+
+    // data addresses in the list are in ascending order
+    if (block_prev) {
+        assert(block_prev->data < block->data);
+    }
+
+    if (block_next) {
+        assert(block->data < block_next->data);
+    }
+
+    // two block's data should not overlap
+    if (block_next) {
+        assert((block->data + block->size) <= block_next->data);
+    }
+
+    cb_args->sum_blocks_size += block->size;
+    if (block->used) {
+        cb_args->sum_used += block->size;
+    }
+}
+
+static umf_result_t coarse_get_stats_no_lock(coarse_t *coarse,
+                                             coarse_stats_t *stats);
+
+static bool debug_check(coarse_t *provider) {
+    assert(provider);
+
+    coarse_stats_t stats = {0};
+    coarse_get_stats_no_lock(provider, &stats);
+
+    debug_cb_args_t cb_args = {0};
+    cb_args.provider = provider;
+
+    // verify the all_blocks list
+    ravl_foreach(provider->all_blocks, debug_verify_all_blocks_cb, &cb_args);
+
+    assert(cb_args.num_all_blocks == stats.num_all_blocks);
+    assert(cb_args.num_free_blocks == stats.num_free_blocks);
+    assert(cb_args.sum_used == provider->used_size);
+    assert(cb_args.sum_blocks_size == provider->alloc_size);
+    assert(provider->alloc_size >= provider->used_size);
+
+    return true;
+}
+#else               /* !UMF_DEVELOPER_MODE */
+static inline bool debug_check(coarse_t *provider) {
+    (void)provider; // suppress unused variable warning
+    return true;
+}
+#endif              /* !UMF_DEVELOPER_MODE */
+#endif /* NDEBUG */ // end of DEBUG code
+
+static umf_result_t coarse_add_used_block(coarse_t *coarse, void *addr,
+                                          size_t size) {
+    block_t *new_block =
+        coarse_ravl_add_new(coarse->all_blocks, addr, size, NULL);
+    if (new_block == NULL) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    new_block->used = true;
+    coarse->alloc_size += size;
+    coarse->used_size += size;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t coarse_add_free_block(coarse_t *coarse, void *addr,
+                                          size_t size, block_t **free_block) {
+    *free_block = NULL;
+
+    block_t *new_block =
+        coarse_ravl_add_new(coarse->all_blocks, addr, size, NULL);
+    if (new_block == NULL) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    new_block->used = false;
+    coarse->alloc_size += size;
+
+    *free_block = new_block;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static void coarse_ravl_cb_rm_all_blocks_node(void *data, void *arg) {
+    assert(data);
+    assert(arg);
+
+    coarse_t *coarse = (struct coarse_t *)arg;
+    ravl_data_t *node_data = data;
+    block_t *block = node_data->value;
+    assert(block);
+
+    if (block->used) {
+#ifndef NDEBUG
+        LOG_WARN("not freed block (addr: %p, size: %zu)", (void *)block->data,
+                 block->size);
+#endif
+        assert(coarse->used_size >= block->size);
+        coarse->used_size -= block->size;
+    }
+
+    if (block->free_list_ptr) {
+        free_blocks_rm_node(coarse->free_blocks, block->free_list_ptr);
+    }
+
+    if (coarse->cb.free) {
+        coarse->cb.free(coarse->provider, block->data, block->size);
+    }
+
+    assert(coarse->alloc_size >= block->size);
+    coarse->alloc_size -= block->size;
+
+    umf_ba_global_free(block);
+}
+
+static umf_result_t can_provider_split(coarse_t *coarse, void *ptr,
+                                       size_t totalSize, size_t firstSize) {
+    // check if the block can be split
+    umf_result_t umf_result =
+        coarse->cb.split(coarse->provider, ptr, totalSize, firstSize);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_ERR(
+            "coarse_split_cb->(ptr=%p, totalSize = %zu = (%zu + %zu)) failed",
+            ptr, totalSize, firstSize, totalSize - firstSize);
+    }
+
+    return umf_result;
+}
+
+static umf_result_t create_aligned_block(coarse_t *coarse, size_t orig_size,
+                                         size_t alignment, block_t **current) {
+    (void)orig_size; // unused in the Release version
+    int rv;
+
+    block_t *curr = *current;
+
+    // In case of non-zero alignment create an aligned block what would be further used.
+    uintptr_t orig_data = (uintptr_t)curr->data;
+    uintptr_t aligned_data = ALIGN_UP(orig_data, alignment);
+    size_t padding = aligned_data - orig_data;
+    if (alignment > 0 && padding > 0) {
+        // check if block can be split by the upstream provider
+        umf_result_t umf_result =
+            can_provider_split(coarse, curr->data, curr->size, padding);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            return umf_result;
+        }
+
+        block_t *aligned_block =
+            coarse_ravl_add_new(coarse->all_blocks, curr->data + padding,
+                                curr->size - padding, NULL);
+        if (aligned_block == NULL) {
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        }
+
+        curr->used = false;
+        curr->size = padding;
+
+        rv = free_blocks_add(coarse->free_blocks, curr);
+        if (rv) {
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        }
+
+        // use aligned block
+        *current = aligned_block;
+        assert((*current)->size >= orig_size);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+// Split the current block and put the new block after the one that we use.
+static umf_result_t split_current_block(coarse_t *coarse, block_t *curr,
+                                        size_t size) {
+
+    // check if block can be split by the upstream provider
+    umf_result_t umf_result =
+        can_provider_split(coarse, curr->data, curr->size, size);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        return umf_result;
+    }
+
+    ravl_node_t *new_node = NULL;
+
+    block_t *new_block = coarse_ravl_add_new(
+        coarse->all_blocks, curr->data + size, curr->size - size, &new_node);
+    if (new_block == NULL) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    new_block->used = false;
+
+    int rv = free_blocks_add(coarse->free_blocks, get_node_block(new_node));
+    if (rv) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static block_t *find_free_block(struct ravl *free_blocks, size_t size,
+                                size_t alignment,
+                                coarse_strategy_t allocation_strategy) {
+    block_t *block;
+    size_t new_size = size + alignment;
+
+    switch (allocation_strategy) {
+    case UMF_COARSE_MEMORY_STRATEGY_FASTEST:
+        // Always allocate a free block of the (size + alignment) size
+        // and later cut out the properly aligned part leaving two remaining parts.
+        if (new_size < size) {
+            LOG_ERR("arithmetic overflow (size + alignment)");
+            return NULL;
+        }
+
+        return free_blocks_rm_ge(free_blocks, new_size, 0,
+                                 CHECK_ONLY_THE_FIRST_BLOCK);
+
+    case UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE:
+        // First check if the first free block of the 'size' size has the correct alignment.
+        block = free_blocks_rm_ge(free_blocks, size, alignment,
+                                  CHECK_ONLY_THE_FIRST_BLOCK);
+        if (block) {
+            return block;
+        }
+
+        if (new_size < size) {
+            LOG_ERR("arithmetic overflow (size + alignment)");
+            return NULL;
+        }
+
+        // If not, use the `UMF_COARSE_MEMORY_STRATEGY_FASTEST` strategy.
+        return free_blocks_rm_ge(free_blocks, new_size, 0,
+                                 CHECK_ONLY_THE_FIRST_BLOCK);
+
+    case UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE:
+        // First look through all free blocks of the 'size' size
+        // and choose the first one with the correct alignment.
+        block = free_blocks_rm_ge(free_blocks, size, alignment,
+                                  CHECK_ALL_BLOCKS_OF_SIZE);
+        if (block) {
+            return block;
+        }
+
+        if (new_size < size) {
+            LOG_ERR("arithmetic overflow (size + alignment)");
+            return NULL;
+        }
+
+        // If none of them had the correct alignment,
+        // use the `UMF_COARSE_MEMORY_STRATEGY_FASTEST` strategy.
+        return free_blocks_rm_ge(free_blocks, new_size, 0,
+                                 CHECK_ONLY_THE_FIRST_BLOCK);
+    }
+
+    return NULL;
+}
+
+static int free_blocks_re_add(coarse_t *coarse, block_t *block) {
+    assert(coarse);
+
+    ravl_node_t *node = coarse_ravl_find_node(coarse->all_blocks, block->data);
+    assert(node);
+
+    // merge with prev and/or next block if they are unused and have continuous data
+    node = free_block_merge_with_prev(coarse, node);
+    node = free_block_merge_with_next(coarse, node);
+
+    return free_blocks_add(coarse->free_blocks, get_node_block(node));
+}
+
+static void ravl_cb_count(void *data, void *arg) {
+    assert(arg);
+    (void)data; // unused
+
+    size_t *num_all_blocks = arg;
+    (*num_all_blocks)++;
+}
+
+static void ravl_cb_count_free(void *data, void *arg) {
+    assert(data);
+    assert(arg);
+
+    ravl_data_t *node_data = data;
+    assert(node_data);
+    ravl_free_blocks_head_t *head_node = node_data->value;
+    assert(head_node);
+    struct ravl_free_blocks_elem_t *free_block = head_node->head;
+    assert(free_block);
+
+    size_t *num_all_blocks = arg;
+    while (free_block) {
+        (*num_all_blocks)++;
+        free_block = free_block->next;
+    }
+}
+
+static umf_result_t coarse_get_stats_no_lock(coarse_t *coarse,
+                                             coarse_stats_t *stats) {
+    assert(coarse);
+
+    size_t num_all_blocks = 0;
+    ravl_foreach(coarse->all_blocks, ravl_cb_count, &num_all_blocks);
+
+    size_t num_free_blocks = 0;
+    ravl_foreach(coarse->free_blocks, ravl_cb_count_free, &num_free_blocks);
+
+    stats->alloc_size = coarse->alloc_size;
+    stats->used_size = coarse->used_size;
+    stats->num_all_blocks = num_all_blocks;
+    stats->num_free_blocks = num_free_blocks;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+// PUBLIC API
+
+umf_result_t coarse_new(coarse_params_t *coarse_params, coarse_t **pcoarse) {
+#ifdef _WIN32
+    utils_init_once(&Log_initialized, utils_log_init);
+#endif /* _WIN32 */
+
+    if (coarse_params == NULL || pcoarse == NULL) {
+        LOG_ERR("coarse parameters or handle is missing");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (!coarse_params->provider) {
+        LOG_ERR("memory provider is not set");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (!coarse_params->page_size) {
+        LOG_ERR("page size of the memory provider is not set");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (!coarse_params->cb.split) {
+        LOG_ERR("coarse split callback is not set");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (!coarse_params->cb.merge) {
+        LOG_ERR("coarse merge callback is not set");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    // alloc() and free() callbacks are optional
+
+    coarse_t *coarse = umf_ba_global_alloc(sizeof(*coarse));
+    if (!coarse) {
+        LOG_ERR("out of the host memory");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    memset(coarse, 0, sizeof(*coarse));
+
+    coarse->provider = coarse_params->provider;
+    coarse->page_size = coarse_params->page_size;
+    coarse->cb = coarse_params->cb;
+    coarse->allocation_strategy = coarse_params->allocation_strategy;
+
+    umf_result_t umf_result = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+
+    coarse->free_blocks = ravl_new_sized(coarse_ravl_comp, sizeof(ravl_data_t));
+    if (coarse->free_blocks == NULL) {
+        LOG_ERR("out of the host memory");
+        goto err_free_coarse;
+    }
+
+    coarse->all_blocks = ravl_new_sized(coarse_ravl_comp, sizeof(ravl_data_t));
+    if (coarse->all_blocks == NULL) {
+        LOG_ERR("out of the host memory");
+        goto err_delete_ravl_free_blocks;
+    }
+
+    coarse->alloc_size = 0;
+    coarse->used_size = 0;
+
+    umf_result = UMF_RESULT_ERROR_UNKNOWN;
+
+    if (utils_mutex_init(&coarse->lock) == NULL) {
+        LOG_ERR("lock initialization failed");
+        goto err_delete_ravl_all_blocks;
+    }
+
+    assert(coarse->used_size == 0);
+    assert(coarse->alloc_size == 0);
+    assert(debug_check(coarse));
+
+    *pcoarse = coarse;
+
+    return UMF_RESULT_SUCCESS;
+
+err_delete_ravl_all_blocks:
+    ravl_delete(coarse->all_blocks);
+err_delete_ravl_free_blocks:
+    ravl_delete(coarse->free_blocks);
+err_free_coarse:
+    umf_ba_global_free(coarse);
+    return umf_result;
+}
+
+void coarse_delete(coarse_t *coarse) {
+    if (coarse == NULL) {
+        LOG_ERR("coarse handle is missing");
+        return;
+    }
+
+    utils_mutex_destroy_not_free(&coarse->lock);
+
+    ravl_foreach(coarse->all_blocks, coarse_ravl_cb_rm_all_blocks_node, coarse);
+    assert(coarse->used_size == 0);
+    assert(coarse->alloc_size == 0);
+
+    ravl_delete(coarse->all_blocks);
+    ravl_delete(coarse->free_blocks);
+
+    umf_ba_global_free(coarse);
+}
+
+umf_result_t coarse_add_memory_from_provider(coarse_t *coarse, size_t size) {
+    umf_result_t umf_result;
+    void *ptr = NULL;
+
+    if (coarse == NULL || size == 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (!coarse->cb.alloc) {
+        LOG_ERR("error: alloc callback is not set");
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+
+    umf_result = coarse_alloc(coarse, size, coarse->page_size, &ptr);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        return umf_result;
+    }
+
+    assert(ptr);
+
+    return coarse_free(coarse, ptr, size);
+}
+
+umf_result_t coarse_add_memory_fixed(coarse_t *coarse, void *addr,
+                                     size_t size) {
+    umf_result_t umf_result;
+
+    if (coarse == NULL || addr == NULL || size == 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (coarse->cb.alloc || coarse->cb.free) {
+        LOG_ERR("error: alloc or free callback is set");
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+
+    if (utils_mutex_lock(&coarse->lock) != 0) {
+        LOG_ERR("locking the lock failed");
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    assert(debug_check(coarse));
+
+    umf_result = coarse_add_used_block(coarse, addr, size);
+
+    assert(debug_check(coarse));
+    utils_mutex_unlock(&coarse->lock);
+
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        return umf_result;
+    }
+
+    umf_result = coarse_free(coarse, addr, size);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        return umf_result;
+    }
+
+    LOG_DEBUG("coarse_ALLOC (add_memory_block) %zu used %zu alloc %zu", size,
+              coarse->used_size, coarse->alloc_size);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t coarse_alloc(coarse_t *coarse, size_t size, size_t alignment,
+                          void **resultPtr) {
+    umf_result_t umf_result = UMF_RESULT_ERROR_UNKNOWN;
+
+    if (coarse == NULL || resultPtr == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    // alignment must be a power of two and a multiple or a divider of the page size
+    if (alignment == 0) {
+        alignment = coarse->page_size;
+    } else if ((alignment & (alignment - 1)) ||
+               ((alignment % coarse->page_size) &&
+                (coarse->page_size % alignment))) {
+        LOG_ERR("wrong alignment: %zu (not a power of 2 or a multiple or a "
+                "divider of the page size (%zu))",
+                alignment, coarse->page_size);
+        return UMF_RESULT_ERROR_INVALID_ALIGNMENT;
+    } else if (IS_NOT_ALIGNED(alignment, coarse->page_size)) {
+        alignment = ALIGN_UP_SAFE(alignment, coarse->page_size);
+    }
+
+    if (utils_mutex_lock(&coarse->lock) != 0) {
+        LOG_ERR("locking the lock failed");
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    assert(debug_check(coarse));
+
+    *resultPtr = NULL;
+
+    // Find a block with greater or equal size using the given memory allocation strategy
+    block_t *curr = find_free_block(coarse->free_blocks, size, alignment,
+                                    coarse->allocation_strategy);
+    if (curr == NULL) {
+        // no suitable block found - try to get more memory from the upstream provider
+        umf_result = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+
+        if (!coarse->cb.alloc) {
+            LOG_ERR("out of memory (the memory provider does not support "
+                    "allocating more memory)");
+            goto err_unlock;
+        }
+
+        size_t size_aligned = ALIGN_UP_SAFE(size, alignment);
+        if (size_aligned == 0) {
+            // cannot align up (arithmetic overflow)
+            umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
+            LOG_ERR("size too huge (arithmetic overflow)");
+            goto err_unlock;
+        }
+
+        umf_result = coarse->cb.alloc(coarse->provider, size_aligned, alignment,
+                                      resultPtr);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            LOG_ERR("alloc() of memory provider failed: out of memory");
+            goto err_unlock;
+        }
+
+        ASSERT_IS_ALIGNED(((uintptr_t)(*resultPtr)), alignment);
+
+        block_t *new_free_block = NULL;
+        umf_result = coarse_add_free_block(coarse, *resultPtr, size_aligned,
+                                           &new_free_block);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            LOG_ERR("failed to add a newly allocated block from the memory "
+                    "provider");
+            if (coarse->cb.free) {
+                coarse->cb.free(coarse->provider, *resultPtr, size_aligned);
+            } else {
+                LOG_WARN("the memory provider does not support the free() "
+                         "operation, so the following memory block was leaked: "
+                         "address %p, size %zu",
+                         *resultPtr, size_aligned);
+            }
+            goto err_unlock;
+        }
+
+        LOG_DEBUG("coarse_ALLOC (memory_provider) %zu used %zu alloc %zu",
+                  size_aligned, coarse->used_size, coarse->alloc_size);
+
+        curr = new_free_block;
+    }
+
+    // If the block that we want to reuse has a greater size, split it.
+    // Try to merge the split part with the successor if it is not used.
+    enum { ACTION_NONE = 0, ACTION_USE, ACTION_SPLIT } action = ACTION_NONE;
+
+    if (curr && curr->size > size) {
+        action = ACTION_SPLIT;
+    } else if (curr && curr->size == size) {
+        action = ACTION_USE;
+    } else {
+        umf_result = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        LOG_ERR("out of memory");
+        goto err_unlock;
+    }
+
+    // ACTION_SPLIT or ACTION_USE
+    assert(curr->used == false);
+
+    // In case of non-zero alignment create an aligned block what would be further used.
+    if (alignment > 0) {
+        umf_result = create_aligned_block(coarse, size, alignment, &curr);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            (void)free_blocks_re_add(coarse, curr);
+            goto err_unlock;
+        }
+    }
+
+    if (action == ACTION_SPLIT) {
+        // Split the current block and put the new block after the one that we use.
+        umf_result = split_current_block(coarse, curr, size);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            (void)free_blocks_re_add(coarse, curr);
+            goto err_unlock;
+        }
+
+        curr->size = size;
+
+        LOG_DEBUG("coarse_ALLOC (split_block) %zu used %zu alloc %zu", size,
+                  coarse->used_size, coarse->alloc_size);
+
+    } else { // action == ACTION_USE
+        LOG_DEBUG("coarse_ALLOC (same_block) %zu used %zu alloc %zu", size,
+                  coarse->used_size, coarse->alloc_size);
+    }
+
+    curr->used = true;
+    *resultPtr = curr->data;
+    coarse->used_size += size;
+
+    umf_result = UMF_RESULT_SUCCESS;
+
+err_unlock:
+    assert(debug_check(coarse));
+    utils_mutex_unlock(&coarse->lock);
+
+    return umf_result;
+}
+
+umf_result_t coarse_free(coarse_t *coarse, void *ptr, size_t bytes) {
+    if (coarse == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (ptr == NULL) {
+        return UMF_RESULT_SUCCESS;
+    }
+
+    if (utils_mutex_lock(&coarse->lock) != 0) {
+        LOG_ERR("locking the lock failed");
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    assert(debug_check(coarse));
+
+    ravl_node_t *node = coarse_ravl_find_node(coarse->all_blocks, ptr);
+    if (node == NULL) {
+        // the block was not found
+        LOG_ERR("memory block not found (ptr = %p, size = %zu)", ptr, bytes);
+        utils_mutex_unlock(&coarse->lock);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    block_t *block = get_node_block(node);
+    if (!block->used) {
+        LOG_ERR("double free");
+        utils_mutex_unlock(&coarse->lock);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (bytes > 0 && bytes != block->size) {
+        LOG_ERR("wrong size of allocation");
+        utils_mutex_unlock(&coarse->lock);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    LOG_DEBUG("coarse_FREE (return_block_to_pool) %zu used %zu alloc %zu",
+              block->size, coarse->used_size - block->size, coarse->alloc_size);
+
+    assert(coarse->used_size >= block->size);
+    coarse->used_size -= block->size;
+
+    block->used = false;
+
+    // Merge with prev and/or next block if they are unused and have continuous data.
+    node = free_block_merge_with_prev(coarse, node);
+    node = free_block_merge_with_next(coarse, node);
+
+    int rv = free_blocks_add(coarse->free_blocks, get_node_block(node));
+    if (rv) {
+        utils_mutex_unlock(&coarse->lock);
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    assert(debug_check(coarse));
+    utils_mutex_unlock(&coarse->lock);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t coarse_merge(coarse_t *coarse, void *lowPtr, void *highPtr,
+                          size_t totalSize) {
+    umf_result_t umf_result;
+
+    if (coarse == NULL || lowPtr == NULL || highPtr == NULL || totalSize == 0 ||
+        ((uintptr_t)highPtr <= (uintptr_t)lowPtr) ||
+        ((uintptr_t)highPtr - (uintptr_t)lowPtr >= totalSize)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (utils_mutex_lock(&coarse->lock) != 0) {
+        LOG_ERR("locking the lock failed");
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    assert(debug_check(coarse));
+
+    umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
+
+    ravl_node_t *low_node = coarse_ravl_find_node(coarse->all_blocks, lowPtr);
+    if (low_node == NULL) {
+        LOG_ERR("the lowPtr memory block not found");
+        goto err_mutex_unlock;
+    }
+
+    block_t *low_block = get_node_block(low_node);
+    if (!low_block->used) {
+        LOG_ERR("the lowPtr block is not allocated");
+        goto err_mutex_unlock;
+    }
+
+    ravl_node_t *high_node = coarse_ravl_find_node(coarse->all_blocks, highPtr);
+    if (high_node == NULL) {
+        LOG_ERR("the highPtr memory block not found");
+        goto err_mutex_unlock;
+    }
+
+    block_t *high_block = get_node_block(high_node);
+    if (!high_block->used) {
+        LOG_ERR("the highPtr block is not allocated");
+        goto err_mutex_unlock;
+    }
+
+    if (get_node_next(low_node) != high_node ||
+        ((uintptr_t)highPtr != ((uintptr_t)lowPtr + low_block->size))) {
+        LOG_ERR("given allocations are not adjacent");
+        goto err_mutex_unlock;
+    }
+
+    assert(get_node_prev(high_node) == low_node);
+
+    if (low_block->size + high_block->size != totalSize) {
+        LOG_ERR("wrong totalSize: %zu != %zu", totalSize,
+                low_block->size + high_block->size);
+        goto err_mutex_unlock;
+    }
+
+    ravl_node_t *merged_node = NULL;
+
+    umf_result =
+        user_block_merge(coarse, low_node, high_node, true, &merged_node);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("merging a block failed");
+        goto err_mutex_unlock;
+    }
+
+    assert(merged_node == low_node);
+    assert(low_block->size == totalSize);
+
+    umf_result = UMF_RESULT_SUCCESS;
+
+err_mutex_unlock:
+    assert(debug_check(coarse));
+    utils_mutex_unlock(&coarse->lock);
+
+    return umf_result;
+}
+
+umf_result_t coarse_split(coarse_t *coarse, void *ptr, size_t totalSize,
+                          size_t firstSize) {
+    umf_result_t umf_result;
+
+    if (coarse == NULL || ptr == NULL || (firstSize >= totalSize) ||
+        firstSize == 0 || totalSize == 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (utils_mutex_lock(&coarse->lock) != 0) {
+        LOG_ERR("locking the lock failed");
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    assert(debug_check(coarse));
+
+    umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
+
+    ravl_node_t *node = coarse_ravl_find_node(coarse->all_blocks, ptr);
+    if (node == NULL) {
+        LOG_ERR("memory block not found");
+        goto err_mutex_unlock;
+    }
+
+    block_t *block = get_node_block(node);
+
+    if (block->size != totalSize) {
+        LOG_ERR("wrong totalSize: %zu != %zu", totalSize, block->size);
+        goto err_mutex_unlock;
+    }
+
+    if (!block->used) {
+        LOG_ERR("block is not allocated");
+        goto err_mutex_unlock;
+    }
+
+    // check if block can be split by the memory provider
+    umf_result = can_provider_split(coarse, ptr, totalSize, firstSize);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("memory provider cannot split a memory block");
+        goto err_mutex_unlock;
+    }
+
+    umf_result = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+
+    block_t *new_block =
+        coarse_ravl_add_new(coarse->all_blocks, block->data + firstSize,
+                            block->size - firstSize, NULL);
+    if (new_block == NULL) {
+        goto err_mutex_unlock;
+    }
+
+    block->size = firstSize;
+    new_block->used = true;
+
+    assert(new_block->size == (totalSize - firstSize));
+
+    umf_result = UMF_RESULT_SUCCESS;
+
+err_mutex_unlock:
+    assert(debug_check(coarse));
+    utils_mutex_unlock(&coarse->lock);
+
+    return umf_result;
+}
+
+coarse_stats_t coarse_get_stats(coarse_t *coarse) {
+    coarse_stats_t stats = {0};
+
+    if (coarse == NULL) {
+        return stats;
+    }
+
+    if (utils_mutex_lock(&coarse->lock) != 0) {
+        LOG_ERR("locking the lock failed");
+        return stats;
+    }
+
+    coarse_get_stats_no_lock(coarse, &stats);
+
+    utils_mutex_unlock(&coarse->lock);
+
+    return stats;
+}
diff --git a/src/coarse/coarse.h b/src/coarse/coarse.h
new file mode 100644
index 000000000..93ec99002
--- /dev/null
+++ b/src/coarse/coarse.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#ifndef UMF_COARSE_H
+#define UMF_COARSE_H
+
+#include <stdbool.h>
+#include <string.h>
+
+#include <umf/base.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct coarse_t coarse_t;
+
+// coarse callbacks implement provider-specific actions
+typedef struct coarse_callbacks_t {
+    // alloc() is optional (can be NULL for the fixed-size memory provider)
+    umf_result_t (*alloc)(void *provider, size_t size, size_t alignment,
+                          void **ptr);
+    // free() is optional (can be NULL if the provider does not support the free() op)
+    umf_result_t (*free)(void *provider, void *ptr, size_t size);
+    umf_result_t (*split)(void *provider, void *ptr, size_t totalSize,
+                          size_t firstSize);
+    umf_result_t (*merge)(void *provider, void *lowPtr, void *highPtr,
+                          size_t totalSize);
+} coarse_callbacks_t;
+
+// coarse library allocation strategy
+typedef enum coarse_strategy_t {
+    // Check if the first free block of the 'size' size has the correct alignment.
+    // If not, use the `UMF_COARSE_MEMORY_STRATEGY_FASTEST` strategy.
+    UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE = 0,
+
+    // Always allocate a free block of the (size + alignment) size
+    // and cut out the properly aligned part leaving two remaining parts.
+    // It is the fastest strategy but causes memory fragmentation
+    // when alignment is greater than 0.
+    // It is the best strategy when alignment always equals 0.
+    UMF_COARSE_MEMORY_STRATEGY_FASTEST,
+
+    // Look through all free blocks of the 'size' size
+    // and choose the first one with the correct alignment.
+    // If none of them had the correct alignment,
+    // use the `UMF_COARSE_MEMORY_STRATEGY_FASTEST` strategy.
+    UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE,
+} coarse_strategy_t;
+
+// coarse library settings structure
+typedef struct coarse_params_t {
+    // handle of the memory provider
+    void *provider;
+
+    // coarse callbacks
+    coarse_callbacks_t cb;
+
+    // memory allocation strategy,
+    // see coarse_strategy_t for details
+    coarse_strategy_t allocation_strategy;
+
+    // page size of the memory provider
+    size_t page_size;
+} coarse_params_t;
+
+// coarse library statistics
+typedef struct coarse_stats_t {
+    // total allocation size
+    size_t alloc_size;
+
+    // size of used memory
+    size_t used_size;
+
+    // total number of allocated memory blocks
+    size_t num_all_blocks;
+
+    // number of free memory blocks
+    size_t num_free_blocks;
+} coarse_stats_t;
+
+umf_result_t coarse_new(coarse_params_t *coarse_params, coarse_t **pcoarse);
+void coarse_delete(coarse_t *coarse);
+
+umf_result_t coarse_alloc(coarse_t *coarse, size_t size, size_t alignment,
+                          void **resultPtr);
+umf_result_t coarse_free(coarse_t *coarse, void *ptr, size_t bytes);
+
+umf_result_t coarse_merge(coarse_t *coarse, void *lowPtr, void *highPtr,
+                          size_t totalSize);
+umf_result_t coarse_split(coarse_t *coarse, void *ptr, size_t totalSize,
+                          size_t firstSize);
+
+// supported only if the alloc callback is set,
+// returns UMF_RESULT_ERROR_NOT_SUPPORTED otherwise
+umf_result_t coarse_add_memory_from_provider(coarse_t *coarse, size_t size);
+
+// supported only if the alloc and the free callbacks are NOT set
+// returns UMF_RESULT_ERROR_NOT_SUPPORTED otherwise
+umf_result_t coarse_add_memory_fixed(coarse_t *coarse, void *addr, size_t size);
+
+coarse_stats_t coarse_get_stats(coarse_t *coarse);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // UMF_COARSE_H
diff --git a/src/critnib/critnib.c b/src/critnib/critnib.c
index c8ee202e8..47a6568c5 100644
--- a/src/critnib/critnib.c
+++ b/src/critnib/critnib.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -64,6 +64,7 @@
 #include "utils_assert.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
+#include "utils_math.h"
 
 /*
  * A node that has been deleted is left untouched for this many delete
@@ -89,7 +90,7 @@
 #define SLNODES (1 << SLICE)
 
 typedef uintptr_t word;
-typedef unsigned char sh_t;
+typedef uint8_t sh_t;
 
 struct critnib_node {
     /*
@@ -115,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;
@@ -130,27 +148,9 @@ struct critnib {
 
     uint64_t remove_count;
 
-    struct os_mutex_t mutex; /* writes/removes */
+    struct utils_mutex_t mutex; /* writes/removes */
 };
 
-/*
- * atomic load
- */
-static void load(void *src, void *dst) {
-    util_atomic_load_acquire((word *)src, (word *)dst);
-}
-
-static void load64(uint64_t *src, uint64_t *dst) {
-    util_atomic_load_acquire(src, dst);
-}
-
-/*
- * atomic store
- */
-static void store(void *dst, void *src) {
-    util_atomic_store_release((word *)dst, (word)src);
-}
-
 /*
  * internal: is_leaf -- check tagged pointer for leafness
  */
@@ -178,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;
@@ -187,13 +191,15 @@ struct critnib *critnib_new(void) {
 
     memset(c, 0, sizeof(struct critnib));
 
-    void *mutex_ptr = util_mutex_init(&c->mutex);
+    void *mutex_ptr = utils_mutex_init(&c->mutex);
     if (!mutex_ptr) {
         goto err_free_critnib;
     }
 
-    VALGRIND_HG_DRD_DISABLE_CHECKING(&c->root, sizeof(c->root));
-    VALGRIND_HG_DRD_DISABLE_CHECKING(&c->remove_count, sizeof(c->remove_count));
+    c->leaf_allocator = leaf_allocator;
+    c->cb_free_leaf = cb_free_leaf;
+    utils_annotate_memory_no_check(&c->root, sizeof(c->root));
+    utils_annotate_memory_no_check(&c->remove_count, sizeof(c->remove_count));
 
     return c;
 err_free_critnib:
@@ -206,6 +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++) {
@@ -226,7 +241,7 @@ void critnib_delete(struct critnib *c) {
         delete_node(c, c->root);
     }
 
-    util_mutex_destroy_not_free(&c->mutex);
+    utils_mutex_destroy_not_free(&c->mutex);
 
     for (struct critnib_node *m = c->deleted_node; m;) {
         struct critnib_node *mm = m->child[0];
@@ -242,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]);
     }
 
@@ -263,8 +287,8 @@ static void free_node(struct critnib *__restrict c,
     }
 
     ASSERT(!is_leaf(n));
-    n->child[0] = c->deleted_node;
-    c->deleted_node = n;
+    utils_atomic_store_release_ptr((void **)&n->child[0], c->deleted_node);
+    utils_atomic_store_release_ptr((void **)&c->deleted_node, n);
 }
 
 /*
@@ -278,11 +302,24 @@ static struct critnib_node *alloc_node(struct critnib *__restrict c) {
     struct critnib_node *n = c->deleted_node;
 
     c->deleted_node = n->child[0];
-    VALGRIND_ANNOTATE_NEW_MEMORY(n, sizeof(*n));
+    utils_annotate_memory_new(n, sizeof(*n));
 
     return n;
 }
 
+static void add_to_deleted_leaf_list(struct critnib *__restrict c,
+                                     struct critnib_leaf *__restrict k) {
+    assert(k);
+    struct critnib_leaf *deleted_leaf;
+
+    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.
  *
@@ -294,28 +331,41 @@ static void free_leaf(struct critnib *__restrict c,
         return;
     }
 
-    k->value = c->deleted_leaf;
-    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_alloc(sizeof(struct critnib_leaf));
-    }
+    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;
-    VALGRIND_ANNOTATE_NEW_MEMORY(k, sizeof(*k));
+    utils_annotate_memory_new(k, sizeof(*k));
 
     return k;
 }
 
 /*
- * crinib_insert -- write a key:value pair to the critnib structure
+ * critnib_insert -- write a key:value pair to the critnib structure
  *
  * Returns:
  *  • 0 on success
@@ -325,28 +375,36 @@ static struct critnib_leaf *alloc_leaf(struct critnib *__restrict c) {
  * Takes a global write lock but doesn't stall any readers.
  */
 int critnib_insert(struct critnib *c, word key, void *value, int update) {
-    util_mutex_lock(&c->mutex);
+    utils_mutex_lock(&c->mutex);
 
     struct critnib_leaf *k = alloc_leaf(c);
     if (!k) {
-        util_mutex_unlock(&c->mutex);
+        utils_mutex_unlock(&c->mutex);
 
         return ENOMEM;
     }
 
-    VALGRIND_HG_DRD_DISABLE_CHECKING(k, sizeof(struct critnib_leaf));
+    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(&k->value, value);
+    utils_atomic_store_release_u8(&k->pending_deleted_leaf, 0);
 
-    k->key = key;
-    k->value = value;
+    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);
 
     struct critnib_node *n = c->root;
     if (!n) {
-        store(&c->root, kn);
-
-        util_mutex_unlock(&c->mutex);
-
+        utils_atomic_store_release_ptr((void **)&c->root, kn);
+        utils_mutex_unlock(&c->mutex);
         return 0;
     }
 
@@ -361,73 +419,104 @@ int critnib_insert(struct critnib *c, word key, void *value, int update) {
 
     if (!n) {
         n = prev;
-        store(&n->child[slice_index(key, n->shift)], kn);
+        utils_atomic_store_release_ptr(
+            (void **)&n->child[slice_index(key, n->shift)], kn);
 
-        util_mutex_unlock(&c->mutex);
+        utils_mutex_unlock(&c->mutex);
 
         return 0;
     }
 
-    word path = is_leaf(n) ? to_leaf(n)->key : n->path;
+    word path;
+    if (is_leaf(n)) {
+        utils_atomic_load_acquire_u64((uint64_t *)&to_leaf(n)->key,
+                                      (uint64_t *)&path);
+    } else {
+        path = n->path;
+    }
+
     /* Find where the path differs from our key. */
     word at = path ^ key;
     if (!at) {
         ASSERT(is_leaf(n));
+        if (c->cb_free_leaf) {
+            // mark the leaf as not used (ref_count == 0)
+            utils_atomic_store_release_u64(&(to_leaf(kn))->ref_count, 0ULL);
+        }
         free_leaf(c, to_leaf(kn));
 
         if (update) {
-            to_leaf(n)->value = value;
-            util_mutex_unlock(&c->mutex);
+            utils_atomic_store_release_ptr(&to_leaf(n)->value, value);
+            utils_mutex_unlock(&c->mutex);
             return 0;
         } else {
-            util_mutex_unlock(&c->mutex);
+            utils_mutex_unlock(&c->mutex);
             return EEXIST;
         }
     }
 
     /* and convert that to an index. */
-    sh_t sh = util_mssb_index(at) & (sh_t) ~(SLICE - 1);
+    sh_t sh = utils_msb64(at) & (sh_t) ~(SLICE - 1);
 
     struct critnib_node *m = alloc_node(c);
     if (!m) {
+        if (c->cb_free_leaf) {
+            // mark the leaf as not used (ref_count == 0)
+            utils_atomic_store_release_u64(&(to_leaf(kn))->ref_count, 0ULL);
+        }
         free_leaf(c, to_leaf(kn));
-
-        util_mutex_unlock(&c->mutex);
-
+        utils_mutex_unlock(&c->mutex);
         return ENOMEM;
     }
-    VALGRIND_HG_DRD_DISABLE_CHECKING(m, sizeof(struct critnib_node));
+
+    utils_annotate_memory_no_check(m, sizeof(struct critnib_node));
 
     for (int i = 0; i < SLNODES; i++) {
-        m->child[i] = NULL;
+        utils_atomic_store_release_ptr((void *)&m->child[i], NULL);
     }
 
-    m->child[slice_index(key, sh)] = kn;
-    m->child[slice_index(path, sh)] = n;
-    m->shift = sh;
-    m->path = key & path_mask(sh);
-    store(parent, m);
+    utils_atomic_store_release_ptr((void *)&m->child[slice_index(key, sh)], kn);
+    utils_atomic_store_release_ptr((void *)&m->child[slice_index(path, sh)], n);
+    utils_atomic_store_release_u8(&m->shift, sh);
+    utils_atomic_store_release_u64((uint64_t *)&m->path, key & path_mask(sh));
+
+    utils_atomic_store_release_ptr((void **)parent, m);
 
-    util_mutex_unlock(&c->mutex);
+    utils_mutex_unlock(&c->mutex);
 
     return 0;
 }
 
 /*
  * 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;
 
-    util_mutex_lock(&c->mutex);
+    if (!c || (c->cb_free_leaf && !ref)) {
+        return NULL;
+    }
+
+    if (ref) {
+        *ref = NULL;
+    }
+
+    utils_mutex_lock(&c->mutex);
 
     struct critnib_node *n = c->root;
     if (!n) {
         goto not_found;
     }
 
-    word del = (util_atomic_increment(&c->remove_count) - 1) % DELETED_LIFE;
+    word del =
+        (utils_atomic_increment_u64(&c->remove_count) - 1) % DELETED_LIFE;
+
     free_node(c, c->pending_del_nodes[del]);
     free_leaf(c, c->pending_del_leaves[del]);
     c->pending_del_nodes[del] = NULL;
@@ -435,8 +524,9 @@ void *critnib_remove(struct critnib *c, word key) {
 
     if (is_leaf(n)) {
         k = to_leaf(n);
-        if (k->key == key) {
-            store(&c->root, NULL);
+        utils_atomic_load_acquire_u64((uint64_t *)&k->key, (uint64_t *)&kkey);
+        if (kkey == key) {
+            utils_atomic_store_release_ptr((void **)&c->root, NULL);
             goto del_leaf;
         }
 
@@ -462,11 +552,13 @@ void *critnib_remove(struct critnib *c, word key) {
     }
 
     k = to_leaf(kn);
-    if (k->key != key) {
+    utils_atomic_load_acquire_u64((uint64_t *)&k->key, (uint64_t *)&kkey);
+    if (kkey != key) {
         goto not_found;
     }
 
-    store(&n->child[slice_index(key, n->shift)], NULL);
+    utils_atomic_store_release_ptr(
+        (void **)&n->child[slice_index(key, n->shift)], NULL);
 
     /* Remove the node if there's only one remaining child. */
     int ochild = -1;
@@ -482,18 +574,102 @@ void *critnib_remove(struct critnib *c, word key) {
 
     ASSERTne(ochild, -1);
 
-    store(n_parent, n->child[ochild]);
+    utils_atomic_store_release_ptr((void **)n_parent, n->child[ochild]);
     c->pending_del_nodes[del] = n;
 
 del_leaf:
     value = k->value;
+    if (c->cb_free_leaf) {
+        utils_atomic_store_release_ptr(&k->to_be_freed, value);
+        utils_atomic_store_release_ptr(&k->value, NULL);
+        *ref = k;
+    }
     c->pending_del_leaves[del] = k;
 
 not_found:
-    util_mutex_unlock(&c->mutex);
+    utils_mutex_unlock(&c->mutex);
     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
  *
@@ -503,16 +679,30 @@ void *critnib_remove(struct critnib *c, word key) {
  *
  * Counterintuitively, it's pointless to return the most current answer,
  * we need only one that was valid at any point after the call started.
+ *
+ * ref - returns a reference to the returned value that must be released
+ *       with critnib_release() when it is no longer needed,
+ *       critnib_get() returns NULL if ref is NULL
  */
-void *critnib_get(struct critnib *c, word key) {
+void *critnib_get(struct critnib *c, word key, void **ref) {
+    struct critnib_leaf *k;
+    struct critnib_node *n;
     uint64_t wrs1, wrs2;
-    void *res;
+    void *res = NULL;
+    sh_t shift;
+    word kkey;
 
-    do {
-        struct critnib_node *n;
+    if (!c || (c->cb_free_leaf && !ref)) {
+        return NULL;
+    }
 
-        load64(&c->remove_count, &wrs1);
-        load(&c->root, &n);
+    if (ref) {
+        *ref = NULL;
+    }
+
+    do {
+        utils_atomic_load_acquire_u64(&c->remove_count, &wrs1);
+        utils_atomic_load_acquire_ptr((void **)&c->root, (void **)&n);
 
         /*
 		 * critbit algorithm: dive into the tree, looking at nothing but
@@ -520,15 +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)) {
-            load(&n->child[slice_index(key, n->shift)], &n);
+            utils_atomic_load_acquire_u8(&n->shift, &shift);
+            utils_atomic_load_acquire_ptr(
+                (void **)&n->child[slice_index(key, shift)], (void **)&n);
         }
 
         /* ... as we check it at the end. */
-        struct critnib_leaf *k = to_leaf(n);
-        res = (n && k->key == key) ? k->value : NULL;
-        load64(&c->remove_count, &wrs2);
+        res = NULL;
+        k = to_leaf(n);
+        if (n) {
+            utils_atomic_load_acquire_u64((uint64_t *)&k->key,
+                                          (uint64_t *)&kkey);
+            if (kkey == key) {
+                utils_atomic_load_acquire_ptr(&k->value, &res);
+            }
+        }
+        utils_atomic_load_acquire_u64(&c->remove_count, &wrs2);
     } while (wrs1 + DELETED_LIFE <= wrs2);
 
+    if (c->cb_free_leaf && res) {
+        if (increment_ref_count(k)) {
+            return NULL;
+        }
+
+        *ref = k;
+    }
+
     return res;
 }
 
@@ -540,7 +747,9 @@ find_predecessor(struct critnib_node *__restrict n) {
     while (1) {
         int nib;
         for (nib = NIB; nib >= 0; nib--) {
-            if (n->child[nib]) {
+            struct critnib_node *m;
+            utils_atomic_load_acquire_ptr((void **)&n->child[nib], (void **)&m);
+            if (m) {
                 break;
             }
         }
@@ -549,7 +758,12 @@ find_predecessor(struct critnib_node *__restrict n) {
             return NULL;
         }
 
-        n = n->child[nib];
+        utils_atomic_load_acquire_ptr((void **)&n->child[nib], (void **)&n);
+
+        if (!n) {
+            return NULL;
+        }
+
         if (is_leaf(n)) {
             return to_leaf(n);
         }
@@ -561,13 +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;
     }
 
     /*
@@ -577,12 +794,16 @@ static struct critnib_leaf *find_le(struct critnib_node *__restrict n,
 	 * that shift points at the nib's lower rather than upper edge, so it
 	 * needs to be masked away as well.
 	 */
-    if ((key ^ n->path) >> (n->shift) & ~NIB) {
+    word path;
+    sh_t shift;
+    utils_atomic_load_acquire_u8(&n->shift, &shift);
+    utils_atomic_load_acquire_u64((uint64_t *)&n->path, (uint64_t *)&path);
+    if ((key ^ path) >> (shift) & ~NIB) {
         /*
 		 * subtree is too far to the left?
 		 * -> its rightmost value is good
 		 */
-        if (n->path < key) {
+        if (path < key) {
             return find_predecessor(n);
         }
 
@@ -593,11 +814,11 @@ static struct critnib_leaf *find_le(struct critnib_node *__restrict n,
         return NULL;
     }
 
-    unsigned nib = slice_index(key, n->shift);
+    unsigned nib = slice_index(key, shift);
     /* recursive call: follow the path */
     {
         struct critnib_node *m;
-        load(&n->child[nib], &m);
+        utils_atomic_load_acquire_ptr((void **)&n->child[nib], (void **)&m);
         struct critnib_leaf *k = find_le(m, key);
         if (k) {
             return k;
@@ -611,7 +832,7 @@ static struct critnib_leaf *find_le(struct critnib_node *__restrict n,
 	 */
     for (; nib > 0; nib--) {
         struct critnib_node *m;
-        load(&n->child[nib - 1], &m);
+        utils_atomic_load_acquire_ptr((void **)&n->child[nib - 1], (void **)&m);
         if (m) {
             n = m;
             if (is_leaf(n)) {
@@ -629,20 +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 {
-        load64(&c->remove_count, &wrs1);
+        utils_atomic_load_acquire_u64(&c->remove_count, &wrs1);
         struct critnib_node *n; /* avoid a subtle TOCTOU */
-        load(&c->root, &n);
-        struct critnib_leaf *k = n ? find_le(n, key) : NULL;
-        res = k ? k->value : NULL;
-        load64(&c->remove_count, &wrs2);
+        utils_atomic_load_acquire_ptr((void **)&c->root, (void **)&n);
+        k = n ? find_le(n, key) : NULL;
+        if (k) {
+            utils_atomic_load_acquire_ptr(&k->value, &res);
+        } else {
+            res = NULL;
+        }
+        utils_atomic_load_acquire_u64(&c->remove_count, &wrs2);
     } while (wrs1 + DELETED_LIFE <= wrs2);
 
+    if (c->cb_free_leaf && res) {
+        if (increment_ref_count(k)) {
+            return NULL;
+        }
+
+        *ref = k;
+    }
+
     return res;
 }
 
@@ -653,7 +899,9 @@ static struct critnib_leaf *find_successor(struct critnib_node *__restrict n) {
     while (1) {
         unsigned nib;
         for (nib = 0; nib <= NIB; nib++) {
-            if (n->child[nib]) {
+            struct critnib_node *m;
+            utils_atomic_load_acquire_ptr((void **)&n->child[nib], (void **)&m);
+            if (m) {
                 break;
             }
         }
@@ -662,7 +910,12 @@ static struct critnib_leaf *find_successor(struct critnib_node *__restrict n) {
             return NULL;
         }
 
-        n = n->child[nib];
+        utils_atomic_load_acquire_ptr((void **)&n->child[nib], (void **)&n);
+
+        if (!n) {
+            return NULL;
+        }
+
         if (is_leaf(n)) {
             return to_leaf(n);
         }
@@ -674,13 +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) {
@@ -694,7 +950,7 @@ static struct critnib_leaf *find_ge(struct critnib_node *__restrict n,
     unsigned nib = slice_index(key, n->shift);
     {
         struct critnib_node *m;
-        load(&n->child[nib], &m);
+        utils_atomic_load_acquire_ptr((void **)&n->child[nib], (void **)&m);
         struct critnib_leaf *k = find_ge(m, key);
         if (k) {
             return k;
@@ -703,7 +959,7 @@ static struct critnib_leaf *find_ge(struct critnib_node *__restrict n,
 
     for (; nib < NIB; nib++) {
         struct critnib_node *m;
-        load(&n->child[nib + 1], &m);
+        utils_atomic_load_acquire_ptr((void **)&n->child[nib + 1], (void **)&m);
         if (m) {
             n = m;
             if (is_leaf(n)) {
@@ -719,14 +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) {
@@ -741,9 +1009,9 @@ int critnib_find(struct critnib *c, uintptr_t key, enum find_dir_t dir,
     }
 
     do {
-        load64(&c->remove_count, &wrs1);
+        utils_atomic_load_acquire_u64(&c->remove_count, &wrs1);
         struct critnib_node *n;
-        load(&c->root, &n);
+        utils_atomic_load_acquire_ptr((void **)&c->root, (void **)&n);
 
         if (dir < 0) {
             k = find_le(n, key);
@@ -751,20 +1019,34 @@ int critnib_find(struct critnib *c, uintptr_t key, enum find_dir_t dir,
             k = find_ge(n, key);
         } else {
             while (n && !is_leaf(n)) {
-                load(&n->child[slice_index(key, n->shift)], &n);
+                utils_atomic_load_acquire_ptr(
+                    (void **)&n->child[slice_index(key, n->shift)],
+                    (void **)&n);
             }
 
+            word kkey;
             struct critnib_leaf *kk = to_leaf(n);
-            k = (n && kk->key == key) ? kk : NULL;
+            utils_atomic_load_acquire_u64((uint64_t *)&kk->key,
+                                          (uint64_t *)&kkey);
+            k = (n && kkey == key) ? kk : NULL;
         }
         if (k) {
-            _rkey = k->key;
-            _rvalue = k->value;
+            utils_atomic_load_acquire_u64((uint64_t *)&k->key,
+                                          (uint64_t *)&_rkey);
+            utils_atomic_load_acquire_ptr(&k->value, (void **)&_rvalue);
         }
-        load64(&c->remove_count, &wrs2);
+        utils_atomic_load_acquire_u64(&c->remove_count, &wrs2);
     } while (wrs1 + DELETED_LIFE <= wrs2);
 
     if (k) {
+        if (c->cb_free_leaf) {
+            if (increment_ref_count(k)) {
+                return 0;
+            }
+
+            *ref = k;
+        }
+
         if (rkey) {
             *rkey = _rkey;
         }
@@ -786,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;
     }
@@ -813,9 +1099,9 @@ static int iter(struct critnib_node *__restrict n, word min, word max,
 void critnib_iter(critnib *c, uintptr_t min, uintptr_t max,
                   int (*func)(uintptr_t key, void *value, void *privdata),
                   void *privdata) {
-    util_mutex_lock(&c->mutex);
+    utils_mutex_lock(&c->mutex);
     if (c->root) {
         iter(c->root, min, max, func, privdata);
     }
-    util_mutex_unlock(&c->mutex);
+    utils_mutex_unlock(&c->mutex);
 }
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
new file mode 100644
index 000000000..e66df9937
--- /dev/null
+++ b/src/ctl/ctl.c
@@ -0,0 +1,631 @@
+/*
+ *
+ * Copyright (C) 2016-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+// This file was originally under following license:
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2024, Intel Corporation */
+
+/*
+ * ctl.c -- implementation of the interface for examination and modification of
+ *    the library's internal state
+ */
+
+#include "ctl.h"
+
+#include <ctype.h>
+#include <limits.h>
+#include <stdint.h>
+#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"
+
+#ifdef _WIN32
+#define strtok_r strtok_s
+#else
+#include <stdio.h>
+#endif
+
+#define MAX_CONFIG_FILE_LEN (1 << 20) /* 1 megabyte */
+
+#define CTL_STRING_QUERY_SEPARATOR ";"
+#define CTL_NAME_VALUE_SEPARATOR "="
+#define CTL_QUERY_NODE_SEPARATOR "."
+#define CTL_VALUE_ARG_SEPARATOR ","
+
+/* GLOBAL TREE */
+static int ctl_global_first_free = 0;
+static umf_ctl_node_t CTL_NODE(global)[CTL_MAX_ENTRIES];
+
+void *Zalloc(size_t sz) {
+    void *ptr = umf_ba_global_alloc(sz);
+    if (ptr) {
+        memset(ptr, 0, sz);
+    }
+    return ptr;
+}
+
+char *Strdup(const char *s) {
+    size_t len = strlen(s) + 1;
+    char *p = umf_ba_global_alloc(len);
+    if (p) {
+        memcpy(p, s, len);
+    }
+    return p;
+}
+
+/*
+ * 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 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) {
+        return NULL;
+    }
+
+    char *node_name = strtok_r(parse_str, CTL_QUERY_NODE_SEPARATOR, &sptr);
+
+    /*
+     * Go through the string and separate tokens that correspond to nodes
+     * in the main ctl tree.
+     */
+    while (node_name != NULL) {
+        char *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
+         * conversion is performed. Linux does not, but endptr
+         * check is valid in both cases.
+         */
+        int tmp_errno = errno;
+        long index_value = strtol(node_name, &endptr, 0);
+        errno = tmp_errno;
+        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) {
+                goto error;
+            }
+            index_entry->value = index_value;
+            LL_PREPEND(indexes, index_entry);
+        }
+
+        for (n = &nodes[0]; n->name != NULL; ++n) {
+            if (index_entry && n->type == CTL_NODE_INDEXED) {
+                break;
+            } else if (strcmp(n->name, node_name) == 0) {
+                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;
+        }
+
+        if (index_entry) {
+            index_entry->name = n->name;
+        }
+
+        nodes = n->children;
+        node_name = next_node;
+    }
+
+    umf_ba_global_free(parse_str);
+    return n;
+
+error:
+    umf_ba_global_free(parse_str);
+    return NULL;
+}
+
+/*
+ * ctl_delete_indexes --
+ *    (internal) removes and frees all entries on the index list
+ */
+static void ctl_delete_indexes(umf_ctl_index_utlist_t *indexes) {
+    if (!indexes) {
+        return;
+    }
+    umf_ctl_index_utlist_t *elem, *tmp;
+    LL_FOREACH_SAFE(indexes, elem, tmp) {
+        LL_DELETE(indexes, elem);
+        if (elem) {
+            umf_ba_global_free(elem);
+        }
+    }
+}
+
+/*
+ * ctl_parse_args -- (internal) parses a string argument based on the node
+ *    structure
+ */
+static void *ctl_parse_args(const struct ctl_argument *arg_proto, char *arg) {
+    char *dest_arg = umf_ba_global_alloc(arg_proto->dest_size);
+    if (dest_arg == NULL) {
+        return NULL;
+    }
+
+    char *sptr = NULL;
+    char *arg_sep = strtok_r(arg, CTL_VALUE_ARG_SEPARATOR, &sptr);
+    for (const struct ctl_argument_parser *p = arg_proto->parsers;
+         p->parser != NULL; ++p) {
+        if (arg_sep == NULL) {
+            goto error_parsing;
+        }
+
+        if (p->parser(arg_sep, dest_arg + p->dest_offset, p->dest_size) != 0) {
+            goto error_parsing;
+        }
+
+        arg_sep = strtok_r(NULL, CTL_VALUE_ARG_SEPARATOR, &sptr);
+    }
+
+    return dest_arg;
+
+error_parsing:
+    umf_ba_global_free(dest_arg);
+    return NULL;
+}
+
+/*
+ * ctl_query_get_real_args -- (internal) returns a pointer with actual argument
+ *    structure as required by the node callback
+ */
+static void *ctl_query_get_real_args(const umf_ctl_node_t *n, void *write_arg,
+                                     umf_ctl_query_source_t source) {
+    void *real_arg = NULL;
+    switch (source) {
+    case CTL_QUERY_CONFIG_INPUT:
+        real_arg = ctl_parse_args(n->arg, write_arg);
+        break;
+    case CTL_QUERY_PROGRAMMATIC:
+        real_arg = write_arg;
+        break;
+    default:
+        break;
+    }
+
+    return real_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 umf_ctl_node_t *n, void *real_arg,
+                                        umf_ctl_query_source_t source) {
+    /* suppress unused-parameter errors */
+    (void)n;
+
+    switch (source) {
+    case CTL_QUERY_CONFIG_INPUT:
+        umf_ba_global_free(real_arg);
+        break;
+    case CTL_QUERY_PROGRAMMATIC:
+        break;
+    default:
+        break;
+    }
+}
+
+/*
+ * ctl_exec_query_read -- (internal) calls the read callback of a node
+ */
+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, 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 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;
+    }
+
+    void *real_arg = ctl_query_get_real_args(n, arg, source);
+    if (real_arg == NULL) {
+        return -1;
+    }
+
+    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;
+}
+
+/*
+ * ctl_exec_query_runnable -- (internal) calls the run callback of a node
+ */
+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);
+}
+
+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, 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;
+    }
+
+    /*
+     * All of the indexes are put on this list so that the handlers can
+     * easily retrieve the index values. The list is cleared once the ctl
+     * query has been handled.
+     */
+    umf_ctl_index_utlist_t *indexes = NULL;
+    indexes = Zalloc(sizeof(*indexes));
+    if (!indexes) {
+        return -1;
+    }
+
+    int ret = -1;
+    size_t name_offset = 0;
+
+    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, &name_offset);
+    }
+
+    // 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[n->type == CTL_NODE_SUBTREE ? CTL_QUERY_SUBTREE : type](
+            ctx, n, source, arg, size, indexes, name + name_offset, type);
+out:
+    ctl_delete_indexes(indexes);
+
+    return ret;
+}
+
+/*
+ * ctl_register_module_node -- adds a new node to the CTL tree root.
+ */
+void ctl_register_module_node(struct ctl *c, const char *name,
+                              umf_ctl_node_t *n) {
+    umf_ctl_node_t *nnode = c == NULL
+                                ? &CTL_NODE(global)[ctl_global_first_free++]
+                                : &c->root[c->first_free++];
+
+    nnode->children = n;
+    nnode->type = CTL_NODE_NAMED;
+    nnode->name = name;
+}
+
+/*
+ * ctl_parse_query -- (internal) splits an entire query string
+ *    into name and value
+ */
+static int ctl_parse_query(char *qbuf, char **name, char **value) {
+    if (qbuf == NULL) {
+        return -1;
+    }
+
+    char *sptr = NULL;
+    *name = strtok_r(qbuf, CTL_NAME_VALUE_SEPARATOR, &sptr);
+    if (*name == NULL) {
+        return -1;
+    }
+
+    *value = strtok_r(NULL, CTL_NAME_VALUE_SEPARATOR, &sptr);
+    if (*value == NULL) {
+        return -1;
+    }
+
+    /* the value itself mustn't include CTL_NAME_VALUE_SEPARATOR */
+    char *extra = strtok_r(NULL, CTL_NAME_VALUE_SEPARATOR, &sptr);
+    if (extra != NULL) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * ctl_load_config -- executes the entire query collection from a provider
+ */
+static int ctl_load_config(struct ctl *ctl, void *ctx, char *buf) {
+    int r = 0;
+    char *sptr = NULL; /* for internal use of strtok */
+    char *name;
+    char *value;
+    char *qbuf = strtok_r(buf, CTL_STRING_QUERY_SEPARATOR, &sptr);
+
+    while (qbuf != NULL) {
+        r = ctl_parse_query(qbuf, &name, &value);
+        if (r != 0) {
+            return -1;
+        }
+
+        r = ctl_query(ctl, ctx, CTL_QUERY_CONFIG_INPUT, name, CTL_QUERY_WRITE,
+                      value, 0);
+
+        if (r < 0 && ctx != NULL) {
+            return -1;
+        }
+
+        qbuf = strtok_r(NULL, CTL_STRING_QUERY_SEPARATOR, &sptr);
+    }
+
+    return 0;
+}
+
+/*
+ * ctl_load_config_from_string -- loads obj configuration from string
+ */
+int ctl_load_config_from_string(struct ctl *ctl, void *ctx,
+                                const char *cfg_string) {
+    char *buf = Strdup(cfg_string);
+    if (buf == NULL) {
+        return -1;
+    }
+
+    int ret = ctl_load_config(ctl, ctx, buf);
+
+    umf_ba_global_free(buf);
+    return ret;
+}
+
+/*
+ * ctl_load_config_from_file -- loads obj configuration from file
+ *
+ * This function opens up the config file, allocates a buffer of size equal to
+ * the size of the file, reads its content and sanitizes it for ctl_load_config.
+ */
+#ifndef _WIN32 // TODO: implement for Windows
+int ctl_load_config_from_file(struct ctl *ctl, void *ctx,
+                              const char *cfg_file) {
+    int ret = -1;
+    long fsize = 0;
+    char *buf = NULL;
+
+    FILE *fp = fopen(cfg_file, "r");
+    if (fp == NULL) {
+        return ret;
+    }
+
+    int err;
+    if ((err = fseek(fp, 0, SEEK_END)) != 0) {
+        goto error_file_parse;
+    }
+
+    fsize = ftell(fp);
+    if (fsize == -1) {
+        goto error_file_parse;
+    }
+
+    if (fsize > MAX_CONFIG_FILE_LEN) {
+        goto error_file_parse;
+    }
+
+    if ((err = fseek(fp, 0, SEEK_SET)) != 0) {
+        goto error_file_parse;
+    }
+
+    buf = Zalloc((size_t)fsize + 1); /* +1 for NULL-termination */
+    if (buf == NULL) {
+        goto error_file_parse;
+    }
+
+    {
+        size_t bufpos = 0;
+        int c;
+        int is_comment_section = 0;
+        while ((c = fgetc(fp)) != EOF) {
+            if (c == '#') {
+                is_comment_section = 1;
+            } else if (c == '\n') {
+                is_comment_section = 0;
+            } else if (!is_comment_section && !isspace(c)) {
+                buf[bufpos++] = (char)c;
+            }
+        }
+    }
+
+    ret = ctl_load_config(ctl, ctx, buf);
+
+    umf_ba_global_free(buf);
+
+error_file_parse:
+    (void)fclose(fp);
+    return ret;
+}
+#endif
+
+/*
+ * ctl_parse_ll -- (internal) parses and returns a long long signed integer
+ */
+static long long ctl_parse_ll(const char *str) {
+    char *endptr;
+    int olderrno = errno;
+    errno = 0;
+    long long val = strtoll(str, &endptr, 0);
+    if (endptr == str || errno != 0) {
+        return LLONG_MIN;
+    }
+    errno = olderrno;
+
+    return val;
+}
+
+/*
+ * ctl_arg_boolean -- checks whether the provided argument contains
+ *    either a 1 or y or Y.
+ */
+int ctl_arg_boolean(const void *arg, void *dest, size_t dest_size) {
+    /* suppress unused-parameter errors */
+    (void)dest_size;
+
+    int *intp = dest;
+    char in = ((const char *)arg)[0];
+
+    if (tolower(in) == 'y' || in == '1') {
+        *intp = 1;
+        return 0;
+    } else if (tolower(in) == 'n' || in == '0') {
+        *intp = 0;
+        return 0;
+    }
+
+    return -1;
+}
+
+/*
+ * ctl_arg_integer -- parses signed integer argument
+ */
+int ctl_arg_integer(const void *arg, void *dest, size_t dest_size) {
+    long long val = ctl_parse_ll(arg);
+    if (val == LLONG_MIN) {
+        return -1;
+    }
+
+    switch (dest_size) {
+    case sizeof(int):
+        if (val > INT_MAX || val < INT_MIN) {
+            return -1;
+        }
+        *(int *)dest = (int)val;
+        break;
+    case sizeof(long long):
+        *(long long *)dest = val;
+        break;
+    case sizeof(uint8_t):
+        if (val > UINT8_MAX || val < 0) {
+            return -1;
+        }
+        *(uint8_t *)dest = (uint8_t)val;
+        break;
+    default:
+        errno = EINVAL;
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * ctl_arg_string -- verifies length and copies a string argument into a zeroed
+ *    buffer
+ */
+int ctl_arg_string(const void *arg, void *dest, size_t dest_size) {
+    /* check if the incoming string is longer or equal to dest_size */
+    if (strnlen(arg, dest_size) == dest_size) {
+        return -1;
+    }
+
+    strncpy(dest, arg, dest_size);
+
+    return 0;
+}
diff --git a/src/ctl/ctl.h b/src/ctl/ctl.h
new file mode 100644
index 000000000..59aa3c799
--- /dev/null
+++ b/src/ctl/ctl.h
@@ -0,0 +1,246 @@
+/*
+ *
+ * Copyright (C) 2016-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+// This file was originally under following license:
+/* SPDX-License-Identifier: BSD-3-Clause */
+/* Copyright 2016-2020, Intel Corporation */
+
+/*
+ * ctl.h -- internal declaration of statistics and control related structures
+ */
+
+#ifndef UMF_CTL_H
+#define UMF_CTL_H 1
+
+#include <errno.h>
+#include <stddef.h>
+
+#include <umf/memory_pool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CTL_MAX_ENTRIES 100
+
+typedef struct ctl_index_utlist {
+    const char *name;
+    long value;
+    struct ctl_index_utlist *next;
+} umf_ctl_index_utlist_t;
+
+typedef enum ctl_query_source {
+    CTL_UNKNOWN_QUERY_SOURCE,
+    /* query executed directly from the program */
+    CTL_QUERY_PROGRAMMATIC,
+    /* query executed from the config file */
+    CTL_QUERY_CONFIG_INPUT,
+
+    MAX_CTL_QUERY_SOURCE
+} umf_ctl_query_source_t;
+
+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
+};
+
+typedef int (*ctl_arg_parser)(const void *arg, void *dest, size_t dest_size);
+
+struct ctl_argument_parser {
+    size_t dest_offset; /* offset of the field inside of the argument */
+    size_t dest_size;   /* size of the field inside of the argument */
+    ctl_arg_parser parser;
+};
+
+struct ctl_argument {
+    size_t dest_size;                     /* size of the entire argument */
+    struct ctl_argument_parser parsers[]; /* array of 'fields' in arg */
+};
+
+#define sizeof_member(t, m) sizeof(((t *)0)->m)
+
+#define CTL_ARG_PARSER(t, p)                                                   \
+    { 0, sizeof(t), p }
+
+#define CTL_ARG_PARSER_STRUCT(t, m, p)                                         \
+    { offsetof(t, m), sizeof_member(t, m), p }
+
+#define CTL_ARG_PARSER_END                                                     \
+    { 0, 0, NULL }
+
+/*
+ * CTL Tree node structure, do not use directly. All the necessary functionality
+ * is provided by the included macros.
+ */
+typedef struct ctl_node {
+    const char *name;
+    enum ctl_node_type type;
+
+    node_callback cb[MAX_CTL_QUERY_TYPE];
+    const struct ctl_argument *arg;
+
+    const struct ctl_node *children;
+} umf_ctl_node_t;
+
+/*
+ * This is the top level node of the ctl tree structure. Each node can contain
+ * children and leaf nodes.
+ *
+ * Internal nodes simply create a new path in the tree whereas child nodes are
+ * the ones providing the read/write functionality by the means of callbacks.
+ *
+ * Each tree node must be NULL-terminated, CTL_NODE_END macro is provided for
+ * convenience.
+ */
+struct ctl {
+    umf_ctl_node_t root[CTL_MAX_ENTRIES];
+    int first_free;
+};
+
+void initialize_global_ctl(void);
+
+int ctl_load_config_from_string(struct ctl *ctl, void *ctx,
+                                const char *cfg_string);
+int ctl_load_config_from_file(struct ctl *ctl, void *ctx, const char *cfg_file);
+
+/* Use through CTL_REGISTER_MODULE, never directly */
+void ctl_register_module_node(struct ctl *c, const char *name,
+                              struct ctl_node *n);
+
+int ctl_arg_boolean(const void *arg, void *dest, size_t dest_size);
+#define CTL_ARG_BOOLEAN                                                        \
+    {sizeof(int), {{0, sizeof(int), ctl_arg_boolean}, CTL_ARG_PARSER_END}};
+
+int ctl_arg_integer(const void *arg, void *dest, size_t dest_size);
+#define CTL_ARG_INT                                                            \
+    {sizeof(int), {{0, sizeof(int), ctl_arg_integer}, CTL_ARG_PARSER_END}};
+
+#define CTL_ARG_LONG_LONG                                                      \
+    {                                                                          \
+        sizeof(long long), {                                                   \
+            {0, sizeof(long long), ctl_arg_integer}, CTL_ARG_PARSER_END        \
+        }                                                                      \
+    }
+
+int ctl_arg_string(const void *arg, void *dest, size_t dest_size);
+#define CTL_ARG_STRING(len)                                                    \
+    {len, {{0, len, ctl_arg_string}, CTL_ARG_PARSER_END}};
+
+#define CTL_STR(name) #name
+
+#define CTL_NODE_END                                                           \
+    { NULL, CTL_NODE_UNKNOWN, {NULL, NULL, NULL}, NULL, NULL }
+
+#define CTL_NODE(name, ...) ctl_node_##__VA_ARGS__##_##name
+
+int ctl_query(struct ctl *ctl, void *ctx, 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, ...)                                                   \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_NAMED, {NULL, NULL, NULL}, NULL,               \
+            (struct ctl_node *)CTL_NODE(name, __VA_ARGS__)                     \
+    }
+
+/* Declaration of a new indexed node */
+#define CTL_INDEXED(name, ...)                                                 \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_INDEXED, {NULL, NULL, NULL}, NULL,             \
+            (struct ctl_node *)CTL_NODE(name, __VA_ARGS__)                     \
+    }
+
+#define CTL_READ_HANDLER(name, ...) ctl_##__VA_ARGS__##_##name##_read
+
+#define CTL_WRITE_HANDLER(name, ...) ctl_##__VA_ARGS__##_##name##_write
+
+#define CTL_RUNNABLE_HANDLER(name, ...) ctl_##__VA_ARGS__##_##name##_runnable
+
+#define CTL_SUBTREE_HANDLER(name, ...) ctl_##__VA_ARGS__##_##name##_subtree
+
+#define CTL_ARG(name) ctl_arg_##name
+
+/*
+ * Declaration of a new read-only leaf. If used the corresponding read function
+ * must be declared by CTL_READ_HANDLER macro.
+ */
+#define CTL_LEAF_RO(name, ...)                                                 \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_LEAF,                                          \
+            {CTL_READ_HANDLER(name, __VA_ARGS__), NULL, NULL, NULL}, NULL,     \
+            NULL                                                               \
+    }
+
+/*
+ * Declaration of a new write-only leaf. If used the corresponding write
+ * function must be declared by CTL_WRITE_HANDLER macro.
+ */
+#define CTL_LEAF_WO(name, ...)                                                 \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_LEAF,                                          \
+            {NULL, CTL_WRITE_HANDLER(name, __VA_ARGS__), NULL, NULL},          \
+            &CTL_ARG(name), NULL                                               \
+    }
+
+/*
+ * Declaration of a new runnable leaf. If used the corresponding run
+ * function must be declared by CTL_RUNNABLE_HANDLER macro.
+ */
+#define CTL_LEAF_RUNNABLE(name, ...)                                           \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_LEAF,                                          \
+            {NULL, NULL, CTL_RUNNABLE_HANDLER(name, __VA_ARGS__), NULL}, NULL, \
+            NULL                                                               \
+    }
+
+#define CTL_LEAF_SUBTREE(name, ...)                                            \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_SUBTREE,                                       \
+            {NULL, NULL, NULL, CTL_SUBTREE_HANDLER(name, __VA_ARGS__)}, NULL,  \
+            NULL                                                               \
+    }
+
+#define CTL_LEAF_SUBTREE2(name, fun, ...)                                      \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_SUBTREE,                                       \
+            {NULL, NULL, NULL, CTL_SUBTREE_HANDLER(fun, __VA_ARGS__)}, NULL,   \
+            NULL                                                               \
+    }
+
+/*
+ * Declaration of a new read-write leaf. If used both read and write function
+ * must be declared by CTL_READ_HANDLER and CTL_WRITE_HANDLER macros.
+ */
+#define CTL_LEAF_RW(name)                                                      \
+    {                                                                          \
+        CTL_STR(name), CTL_NODE_LEAF,                                          \
+            {CTL_READ_HANDLER(name), CTL_WRITE_HANDLER(name), NULL, NULL},     \
+            &CTL_ARG(name), NULL                                               \
+    }
+
+#define CTL_REGISTER_MODULE(_ctl, name)                                        \
+    ctl_register_module_node((_ctl), CTL_STR(name),                            \
+                             (struct ctl_node *)CTL_NODE(name))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/ipc.c b/src/ipc.c
index b266004f3..d4e5cc806 100644
--- a/src/ipc.c
+++ b/src/ipc.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -15,6 +15,7 @@
 #include "base_alloc_global.h"
 #include "ipc_internal.h"
 #include "memory_pool_internal.h"
+#include "memory_provider_internal.h"
 #include "provider/provider_tracking.h"
 #include "utils_common.h"
 #include "utils_log.h"
@@ -51,6 +52,11 @@ umf_result_t umfPoolGetIPCHandleSize(umf_memory_pool_handle_t hPool,
 
 umf_result_t umfGetIPCHandle(const void *ptr, umf_ipc_handle_t *umfIPCHandle,
                              size_t *size) {
+    if (ptr == NULL || umfIPCHandle == NULL || size == NULL) {
+        LOG_ERR("invalid argument.");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
     size_t ipcHandleSize = 0;
     umf_alloc_info_t allocInfo;
     umf_result_t ret = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
@@ -85,6 +91,8 @@ umf_result_t umfGetIPCHandle(const void *ptr, umf_ipc_handle_t *umfIPCHandle,
         return ret;
     }
 
+    // ipcData->handle_id is filled by tracking provider
+    ipcData->base = allocInfo.base;
     ipcData->pid = utils_getpid();
     ipcData->baseSize = allocInfo.baseSize;
     ipcData->offset = (uintptr_t)ptr - (uintptr_t)allocInfo.base;
@@ -102,7 +110,7 @@ umf_result_t umfPutIPCHandle(umf_ipc_handle_t umfIPCHandle) {
     //       implementation does nothing in Put function. Tracking memory
     //       provider relies on IPC cache and actually Put IPC handle back
     //       to upstream memory provider when umfMemoryProviderFree is called.
-    //       To support incapsulation we should not take into account
+    //       To support encapsulation we should not take into account
     //       implementation details of tracking memory provider and find the
     //       appropriate pool, get memory provider of that pool and call
     //       umfMemoryProviderPutIPCHandle(hProvider,
@@ -112,12 +120,18 @@ umf_result_t umfPutIPCHandle(umf_ipc_handle_t umfIPCHandle) {
     return ret;
 }
 
-umf_result_t umfOpenIPCHandle(umf_memory_pool_handle_t hPool,
+umf_result_t umfOpenIPCHandle(umf_ipc_handler_handle_t hIPCHandler,
                               umf_ipc_handle_t umfIPCHandle, void **ptr) {
 
-    // We cannot use umfPoolGetMemoryProvider function because it returns
-    // upstream provider but we need tracking one
-    umf_memory_provider_handle_t hProvider = hPool->provider;
+    // IPC handler is an instance of tracking memory provider
+    umf_memory_provider_handle_t hProvider = hIPCHandler;
+    if (hProvider->ops.version != UMF_PROVIDER_OPS_VERSION_CURRENT) {
+        // It is a temporary hack to verify that user passes correct IPC handler,
+        // not a pool handle, as it was required in previous version.
+        LOG_ERR("Invalid IPC handler.");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
     void *base = NULL;
 
     umf_result_t ret = umfMemoryProviderOpenIPCHandle(
@@ -132,17 +146,36 @@ umf_result_t umfOpenIPCHandle(umf_memory_pool_handle_t hPool,
 }
 
 umf_result_t umfCloseIPCHandle(void *ptr) {
-    umf_alloc_info_t allocInfo;
-    umf_result_t ret = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
+    umf_ipc_info_t ipcInfo;
+    umf_result_t ret = umfMemoryTrackerGetIpcInfo(ptr, &ipcInfo);
     if (ret != UMF_RESULT_SUCCESS) {
-        LOG_ERR("cannot get alloc info for ptr = %p.", ptr);
+        LOG_ERR("cannot get IPC info for ptr = %p.", ptr);
         return ret;
     }
 
+    return umfMemoryProviderCloseIPCHandle(ipcInfo.provider, ipcInfo.base,
+                                           ipcInfo.baseSize);
+}
+
+umf_result_t umfPoolGetIPCHandler(umf_memory_pool_handle_t hPool,
+                                  umf_ipc_handler_handle_t *hIPCHandler) {
+    if (hPool == NULL) {
+        LOG_ERR("Pool handle is NULL.");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (hIPCHandler == NULL) {
+        LOG_ERR("hIPCHandler is NULL.");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
     // We cannot use umfPoolGetMemoryProvider function because it returns
     // upstream provider but we need tracking one
-    umf_memory_provider_handle_t hProvider = allocInfo.pool->provider;
+    umf_memory_provider_handle_t hProvider = hPool->provider;
+
+    // We are using tracking provider as an IPC handler because
+    // it is doing IPC caching.
+    *hIPCHandler = (umf_ipc_handler_handle_t)hProvider;
 
-    return umfMemoryProviderCloseIPCHandle(hProvider, allocInfo.base,
-                                           allocInfo.baseSize);
+    return UMF_RESULT_SUCCESS;
 }
diff --git a/src/ipc_cache.c b/src/ipc_cache.c
new file mode 100644
index 000000000..bf17a66a4
--- /dev/null
+++ b/src/ipc_cache.c
@@ -0,0 +1,290 @@
+/*
+ *
+ * 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 <stdbool.h>
+
+#include "base_alloc_global.h"
+#include "ipc_cache.h"
+#include "uthash.h"
+#include "utils_common.h"
+#include "utils_concurrency.h"
+#include "utils_log.h"
+#include "utlist.h"
+
+// HASH_ADD macro produces `warning C4702: unreachable code` on MSVC
+#ifdef _MSC_VER
+#pragma warning(disable : 4702)
+#endif
+
+struct ipc_opened_cache_entry_t;
+
+typedef struct ipc_opened_cache_entry_t *hash_map_t;
+typedef struct ipc_opened_cache_entry_t *lru_list_t;
+
+typedef struct ipc_opened_cache_entry_t {
+    UT_hash_handle hh;
+    struct ipc_opened_cache_entry_t *next, *prev;
+    ipc_opened_cache_key_t key;
+    uint64_t ref_count;
+    uint64_t handle_id;
+    hash_map_t
+        *hash_table; // pointer to the hash table to which the entry belongs
+    ipc_opened_cache_value_t value;
+} ipc_opened_cache_entry_t;
+
+typedef struct ipc_opened_cache_global_t {
+    utils_mutex_t cache_lock;
+    umf_ba_pool_t *cache_allocator;
+    size_t max_size;
+    size_t cur_size;
+    lru_list_t lru_list;
+} ipc_opened_cache_global_t;
+
+typedef struct ipc_opened_cache_t {
+    ipc_opened_cache_global_t *global;
+    hash_map_t hash_table;
+    ipc_opened_cache_eviction_cb_t eviction_cb;
+} ipc_opened_cache_t;
+
+ipc_opened_cache_global_t *IPC_OPENED_CACHE_GLOBAL = NULL;
+
+// Returns value of the UMF_MAX_OPENED_IPC_HANDLES environment variable
+// or 0 if it is not set.
+static size_t umfIpcCacheGlobalInitMaxOpenedHandles(void) {
+    const char *max_size_str = getenv("UMF_MAX_OPENED_IPC_HANDLES");
+    if (max_size_str) {
+        char *endptr;
+        size_t max_size = strtoul(max_size_str, &endptr, 10);
+        if (*endptr == '\0') {
+            return max_size;
+        }
+        LOG_ERR("Invalid value of UMF_MAX_OPENED_IPC_HANDLES: %s",
+                max_size_str);
+    }
+    return 0;
+}
+
+umf_result_t umfIpcCacheGlobalInit(void) {
+    umf_result_t ret = UMF_RESULT_SUCCESS;
+    ipc_opened_cache_global_t *cache_global =
+        umf_ba_global_alloc(sizeof(*cache_global));
+    if (!cache_global) {
+        LOG_ERR("Failed to allocate memory for the IPC cache global data");
+        ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        goto err_exit;
+    }
+
+    if (NULL == utils_mutex_init(&(cache_global->cache_lock))) {
+        LOG_ERR("Failed to initialize mutex for the IPC global cache");
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+        goto err_cache_global_free;
+    }
+
+    cache_global->cache_allocator =
+        umf_ba_create(sizeof(ipc_opened_cache_entry_t));
+    if (!cache_global->cache_allocator) {
+        LOG_ERR("Failed to create IPC cache allocator");
+        ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        goto err_mutex_destroy;
+    }
+
+    cache_global->max_size = umfIpcCacheGlobalInitMaxOpenedHandles();
+    cache_global->cur_size = 0;
+    cache_global->lru_list = NULL;
+
+    IPC_OPENED_CACHE_GLOBAL = cache_global;
+    goto err_exit;
+
+err_mutex_destroy:
+    utils_mutex_destroy_not_free(&(cache_global->cache_lock));
+err_cache_global_free:
+    umf_ba_global_free(cache_global);
+err_exit:
+    return ret;
+}
+
+#ifndef NDEBUG
+static size_t getGlobalLruListSize(lru_list_t lru_list) {
+    size_t size = 0;
+    ipc_opened_cache_entry_t *tmp;
+    DL_COUNT(lru_list, tmp, size);
+    return size;
+}
+#endif /* NDEBUG */
+
+void umfIpcCacheGlobalTearDown(void) {
+    ipc_opened_cache_global_t *cache_global = IPC_OPENED_CACHE_GLOBAL;
+    IPC_OPENED_CACHE_GLOBAL = NULL;
+
+    if (!cache_global) {
+        return;
+    }
+
+    assert(cache_global->cur_size == 0);
+    assert(getGlobalLruListSize(cache_global->lru_list) == 0);
+
+    umf_ba_destroy(cache_global->cache_allocator);
+    utils_mutex_destroy_not_free(&(cache_global->cache_lock));
+    umf_ba_global_free(cache_global);
+}
+
+ipc_opened_cache_handle_t
+umfIpcOpenedCacheCreate(ipc_opened_cache_eviction_cb_t eviction_cb) {
+    if (eviction_cb == NULL) {
+        LOG_ERR("Eviction callback is NULL");
+        return NULL;
+    }
+
+    ipc_opened_cache_t *cache = umf_ba_global_alloc(sizeof(*cache));
+
+    if (!cache) {
+        LOG_ERR("Failed to allocate memory for the IPC cache");
+        return NULL;
+    }
+
+    assert(IPC_OPENED_CACHE_GLOBAL != NULL);
+
+    cache->global = IPC_OPENED_CACHE_GLOBAL;
+    cache->hash_table = NULL;
+    cache->eviction_cb = eviction_cb;
+
+    return cache;
+}
+
+void umfIpcOpenedCacheDestroy(ipc_opened_cache_handle_t cache) {
+    ipc_opened_cache_entry_t *entry, *tmp;
+
+    utils_mutex_lock(&(cache->global->cache_lock));
+    HASH_ITER(hh, cache->hash_table, entry, tmp) {
+        DL_DELETE(cache->global->lru_list, entry);
+        HASH_DEL(cache->hash_table, entry);
+        cache->global->cur_size -= 1;
+        cache->eviction_cb(&entry->key, &entry->value);
+        utils_mutex_destroy_not_free(&(entry->value.mmap_lock));
+        umf_ba_free(cache->global->cache_allocator, entry);
+    }
+    HASH_CLEAR(hh, cache->hash_table);
+    utils_mutex_unlock(&(cache->global->cache_lock));
+
+    umf_ba_global_free(cache);
+}
+
+umf_result_t umfIpcOpenedCacheGet(ipc_opened_cache_handle_t cache,
+                                  const ipc_opened_cache_key_t *key,
+                                  uint64_t handle_id,
+                                  ipc_opened_cache_value_t **retEntry) {
+    ipc_opened_cache_entry_t *entry = NULL;
+    umf_result_t ret = UMF_RESULT_SUCCESS;
+    bool evicted = false;
+    ipc_opened_cache_value_t evicted_value;
+
+    if (!cache || !key || !retEntry) {
+        LOG_ERR("Some arguments are NULL, cache=%p, key=%p, retEntry=%p",
+                (void *)cache, (const void *)key, (void *)retEntry);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    assert(cache->global != NULL);
+
+    utils_mutex_lock(&(cache->global->cache_lock));
+
+    HASH_FIND(hh, cache->hash_table, key, sizeof(*key), entry);
+    if (entry && entry->handle_id == handle_id) { // cache hit
+        // update frequency list
+        // remove the entry from the current position
+        DL_DELETE(cache->global->lru_list, entry);
+        // add the entry to the head of the list
+        DL_PREPEND(cache->global->lru_list, entry);
+    } else { //cache miss
+        // Look for eviction candidate
+        if (entry == NULL && cache->global->max_size != 0 &&
+            cache->global->cur_size >= cache->global->max_size) {
+            // If max_size is set and the cache is full, evict the least recently used entry.
+            // we need to search for the least recently used entry with ref_count == 0
+            // The utlist implementation of the doubly-linked list keeps a tail pointer in head->prev
+            ipc_opened_cache_entry_t *candidate = cache->global->lru_list->prev;
+            do {
+                uint64_t ref_count = 0;
+                utils_atomic_load_acquire_u64(&candidate->ref_count,
+                                              &ref_count);
+                if (ref_count == 0) {
+                    entry = candidate;
+                    break;
+                }
+                candidate = candidate->prev;
+            } while (candidate != cache->global->lru_list->prev);
+        }
+
+        if (entry) { // we have eviction candidate
+            // remove the entry from the frequency list
+            DL_DELETE(cache->global->lru_list, entry);
+            // remove the entry from the hash table it belongs to
+            HASH_DEL(*(entry->hash_table), entry);
+            cache->global->cur_size -= 1;
+            evicted_value.mapped_base_ptr = entry->value.mapped_base_ptr;
+            evicted_value.mapped_size = entry->value.mapped_size;
+            evicted = true;
+        } else { // allocate the new entry
+            entry = umf_ba_alloc(cache->global->cache_allocator);
+            if (!entry) {
+                ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+                LOG_ERR("Failed to allocate memory for a new IPC cache entry");
+                goto exit;
+            }
+            if (NULL == utils_mutex_init(&(entry->value.mmap_lock))) {
+                LOG_ERR("Failed to initialize mutex for the IPC cache entry");
+                umf_ba_global_free(entry);
+                ret = UMF_RESULT_ERROR_UNKNOWN;
+                goto exit;
+            }
+        }
+
+        entry->key = *key;
+        entry->ref_count = 0;
+        entry->handle_id = handle_id;
+        entry->hash_table = &cache->hash_table;
+        entry->value.mapped_size = 0;
+        entry->value.mapped_base_ptr = NULL;
+
+        HASH_ADD(hh, cache->hash_table, key, sizeof(entry->key), entry);
+        DL_PREPEND(cache->global->lru_list, entry);
+        cache->global->cur_size += 1;
+    }
+
+exit:
+    if (ret == UMF_RESULT_SUCCESS) {
+        utils_atomic_increment_u64(&entry->ref_count);
+        *retEntry = &entry->value;
+    }
+
+    utils_mutex_unlock(&(cache->global->cache_lock));
+
+    if (evicted) {
+        cache->eviction_cb(key, &evicted_value);
+    }
+
+    return ret;
+}
+
+umf_result_t
+umfIpcHandleMappedCacheRelease(ipc_opened_cache_value_t *cacheValue) {
+    if (!cacheValue) {
+        LOG_ERR("cacheValue is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    // get pointer to the entry
+    ipc_opened_cache_entry_t *entry =
+        (ipc_opened_cache_entry_t *)((char *)cacheValue -
+                                     offsetof(ipc_opened_cache_entry_t, value));
+    // decrement the ref count
+    utils_atomic_decrement_u64(&entry->ref_count);
+
+    return UMF_RESULT_SUCCESS;
+}
diff --git a/src/ipc_cache.h b/src/ipc_cache.h
new file mode 100644
index 000000000..545c6e1e7
--- /dev/null
+++ b/src/ipc_cache.h
@@ -0,0 +1,52 @@
+/*
+ *
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+#ifndef UMF_IPC_CACHE_H
+#define UMF_IPC_CACHE_H 1
+
+#include <umf/memory_provider.h>
+
+#include "utils_concurrency.h"
+
+typedef struct ipc_opened_cache_key_t {
+    void *remote_base_ptr;
+    umf_memory_provider_handle_t local_provider;
+    int remote_pid;
+} ipc_opened_cache_key_t;
+
+typedef struct ipc_opened_cache_value_t {
+    void *mapped_base_ptr;
+    size_t mapped_size;
+    utils_mutex_t mmap_lock;
+} ipc_opened_cache_value_t;
+
+struct ipc_opened_cache_t;
+
+typedef struct ipc_opened_cache_t *ipc_opened_cache_handle_t;
+
+umf_result_t umfIpcCacheGlobalInit(void);
+void umfIpcCacheGlobalTearDown(void);
+
+// define pointer to the eviction callback function
+typedef void (*ipc_opened_cache_eviction_cb_t)(
+    const ipc_opened_cache_key_t *key, const ipc_opened_cache_value_t *value);
+
+ipc_opened_cache_handle_t
+umfIpcOpenedCacheCreate(ipc_opened_cache_eviction_cb_t eviction_cb);
+
+void umfIpcOpenedCacheDestroy(ipc_opened_cache_handle_t cache);
+
+umf_result_t umfIpcOpenedCacheGet(ipc_opened_cache_handle_t cache,
+                                  const ipc_opened_cache_key_t *key,
+                                  uint64_t handle_id,
+                                  ipc_opened_cache_value_t **retEntry);
+
+umf_result_t
+umfIpcHandleMappedCacheRelease(ipc_opened_cache_value_t *cacheValue);
+#endif /* UMF_IPC_CACHE_H */
diff --git a/src/ipc_internal.h b/src/ipc_internal.h
index 0f45b24e2..103214407 100644
--- a/src/ipc_internal.h
+++ b/src/ipc_internal.h
@@ -21,8 +21,10 @@ extern "C" {
 // providerIpcData is a Flexible Array Member because its size varies
 // depending on the provider.
 typedef struct umf_ipc_data_t {
-    int pid;         // process ID of the process that allocated the memory
-    size_t baseSize; // size of base (coarse-grain) allocation
+    uint64_t handle_id; // unique ID of this handle
+    void *base;         // base address of the memory
+    int pid;            // process ID of the process that allocated the memory
+    size_t baseSize;    // size of base (coarse-grain) allocation
     uint64_t offset;
     char providerIpcData[];
 } umf_ipc_data_t;
diff --git a/src/libumf.c b/src/libumf.c
index 1d99ab26a..46c264016 100644
--- a/src/libumf.c
+++ b/src/libumf.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -8,10 +8,17 @@
  */
 
 #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"
+#include "provider_level_zero_internal.h"
 #include "provider_tracking.h"
+#include "utils_common.h"
 #include "utils_log.h"
 #if !defined(UMF_NO_HWLOC)
 #include "topology.h"
@@ -19,19 +26,43 @@
 
 umf_memory_tracker_handle_t TRACKER = NULL;
 
-static unsigned long long umfRefCount = 0;
+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 (util_fetch_and_add64(&umfRefCount, 1) == 0) {
-        util_log_init();
+    if (utils_fetch_and_add_u64(&umfRefCount, 1) == 0) {
+        utils_log_init();
         TRACKER = umfMemoryTrackerCreate();
+        if (!TRACKER) {
+            LOG_ERR("Failed to create memory tracker");
+            return -1;
+        }
+
+        LOG_DEBUG("UMF tracker created");
+
+        umf_result_t umf_result = umfIpcCacheGlobalInit();
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            LOG_ERR("Failed to initialize IPC cache");
+            return -1;
+        }
+
+        LOG_DEBUG("UMF IPC cache initialized");
+        initialize_global_ctl();
+    }
+
+    if (TRACKER) {
+        LOG_DEBUG("UMF library initialized");
     }
 
-    return (TRACKER) ? 0 : -1;
+    return 0;
 }
 
 void umfTearDown(void) {
-    if (util_fetch_and_add64(&umfRefCount, -1) == 1) {
+    if (utils_fetch_and_sub_u64(&umfRefCount, 1) == 1) {
 #if !defined(_WIN32) && !defined(UMF_NO_HWLOC)
         umfMemspaceHostAllDestroy();
         umfMemspaceHighestCapacityDestroy();
@@ -39,13 +70,70 @@ void umfTearDown(void) {
         umfMemspaceLowestLatencyDestroy();
         umfDestroyTopology();
 #endif
+        umfIpcCacheGlobalTearDown();
+
+        if (utils_is_running_in_proxy_lib_with_size_threshold()) {
+            // We cannot destroy the TRACKER nor the base allocator
+            // when we are running in the proxy library with a size threshold,
+            // because it could result in calling the system free()
+            // with an invalid pointer and a segfault.
+            goto fini_umfTearDown;
+        }
+
         // make sure TRACKER is not used after being destroyed
         umf_memory_tracker_handle_t t = TRACKER;
         TRACKER = NULL;
         umfMemoryTrackerDestroy(t);
+        LOG_DEBUG("UMF tracker destroyed");
 
         umf_ba_destroy_global();
+        LOG_DEBUG("UMF base allocator destroyed");
+
+    fini_umfTearDown:
+        fini_ze_global_state();
+        fini_cu_global_state();
+        fini_tbb_global_state();
+        LOG_DEBUG("UMF library finalized");
     }
 }
 
 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
new file mode 100644
index 000000000..10b0326b8
--- /dev/null
+++ b/src/libumf.def
@@ -0,0 +1,146 @@
+;;;; Begin Copyright Notice
+; Copyright (C) 2023-2025 Intel Corporation
+; Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+;;;;  End Copyright Notice
+
+LIBRARY UMF
+
+VERSION 0.12
+
+EXPORTS
+    DllMain
+    umfInit
+    umfTearDown
+    umfGetCurrentVersion
+    umfCloseIPCHandle
+    umfCUDAMemoryProviderOps
+    umfCUDAMemoryProviderParamsCreate
+    umfCUDAMemoryProviderParamsDestroy
+    umfCUDAMemoryProviderParamsSetContext
+    umfCUDAMemoryProviderParamsSetDevice
+    umfCUDAMemoryProviderParamsSetMemoryType
+    umfDevDaxMemoryProviderOps
+    umfDevDaxMemoryProviderParamsCreate
+    umfDevDaxMemoryProviderParamsDestroy
+    umfDevDaxMemoryProviderParamsSetDeviceDax
+    umfDevDaxMemoryProviderParamsSetProtection
+    umfFileMemoryProviderOps
+    umfFileMemoryProviderParamsCreate
+    umfFileMemoryProviderParamsDestroy
+    umfFileMemoryProviderParamsSetPath
+    umfFileMemoryProviderParamsSetProtection
+    umfFileMemoryProviderParamsSetVisibility
+    umfFree
+    umfGetIPCHandle
+    umfGetLastFailedMemoryProvider
+    umfJemallocPoolOps
+    umfLevelZeroMemoryProviderOps
+    umfLevelZeroMemoryProviderParamsCreate
+    umfLevelZeroMemoryProviderParamsDestroy
+    umfLevelZeroMemoryProviderParamsSetContext
+    umfLevelZeroMemoryProviderParamsSetDevice
+    umfLevelZeroMemoryProviderParamsSetMemoryType
+    umfLevelZeroMemoryProviderParamsSetResidentDevices
+    umfMemoryProviderAlloc
+    umfMemoryProviderAllocationMerge
+    umfMemoryProviderAllocationSplit
+    umfMemoryProviderCloseIPCHandle
+    umfMemoryProviderCreate
+    umfMemoryProviderCreateFromMemspace
+    umfMemoryProviderDestroy
+    umfMemoryProviderFree
+    umfMemoryProviderGetIPCHandle
+    umfMemoryProviderGetIPCHandleSize
+    umfMemoryProviderGetLastNativeError
+    umfMemoryProviderGetMinPageSize
+    umfMemoryProviderGetName
+    umfMemoryProviderGetRecommendedPageSize
+    umfMemoryProviderOpenIPCHandle
+    umfMemoryProviderPurgeForce
+    umfMemoryProviderPurgeLazy
+    umfMemoryProviderPutIPCHandle
+    umfMempolicyCreate
+    umfMempolicyDestroy
+    umfMempolicySetCustomSplitPartitions
+    umfMempolicySetInterleavePartSize
+    umfMemspaceClone
+    umfMemspaceCreateFromNumaArray
+    umfMemspaceDestroy
+    umfMemspaceFilterByCapacity
+    umfMemspaceFilterById
+    umfMemspaceHighestBandwidthGet
+    umfMemspaceHighestCapacityGet
+    umfMemspaceHostAllGet
+    umfMemspaceLowestLatencyGet
+    umfMemspaceMemtargetAdd
+    umfMemspaceMemtargetGet
+    umfMemspaceMemtargetNum
+    umfMemspaceMemtargetRemove
+    umfMemspaceNew
+    umfMemspaceUserFilter
+    umfMemtargetGetCapacity
+    umfMemtargetGetId
+    umfMemtargetGetType
+    umfOpenIPCHandle
+    umfOsMemoryProviderOps
+    umfOsMemoryProviderParamsCreate
+    umfOsMemoryProviderParamsDestroy
+    umfOsMemoryProviderParamsSetProtection
+    umfOsMemoryProviderParamsSetVisibility
+    umfOsMemoryProviderParamsSetShmName
+    umfOsMemoryProviderParamsSetNumaList
+    umfOsMemoryProviderParamsSetNumaMode
+    umfOsMemoryProviderParamsSetPartSize
+    umfOsMemoryProviderParamsSetPartitions
+    umfPoolAlignedMalloc
+    umfPoolByPtr
+    umfPoolCalloc
+    umfPoolCreate
+    umfPoolCreateFromMemspace
+    umfPoolDestroy
+    umfPoolFree
+    umfPoolGetIPCHandler
+    umfPoolGetIPCHandleSize
+    umfPoolGetLastAllocationError
+    umfPoolGetTag
+    umfPoolGetMemoryProvider
+    umfPoolMalloc
+    umfPoolMallocUsableSize
+    umfPoolRealloc
+    umfPoolSetTag
+    umfProxyPoolOps
+    umfPutIPCHandle
+    umfScalablePoolOps
+    umfScalablePoolParamsCreate
+    umfScalablePoolParamsDestroy
+    umfScalablePoolParamsSetGranularity
+    umfScalablePoolParamsSetKeepAllMemory
+; Added in UMF_0.11
+    umfCUDAMemoryProviderParamsSetAllocFlags
+    umfDisjointPoolOps
+    umfDisjointPoolParamsCreate
+    umfDisjointPoolParamsDestroy
+    umfDisjointPoolParamsSetCapacity
+    umfDisjointPoolParamsSetMaxPoolableSize
+    umfDisjointPoolParamsSetMinBucketSize
+    umfDisjointPoolParamsSetName
+    umfDisjointPoolParamsSetSharedLimits
+    umfDisjointPoolParamsSetSlabMinSize
+    umfDisjointPoolParamsSetTrace
+    umfDisjointPoolSharedLimitsCreate
+    umfDisjointPoolSharedLimitsDestroy
+    umfFixedMemoryProviderOps
+    umfFixedMemoryProviderParamsCreate
+    umfFixedMemoryProviderParamsDestroy
+    umfFixedMemoryProviderParamsSetMemory
+    umfLevelZeroMemoryProviderParamsSetFreePolicy
+    umfLevelZeroMemoryProviderParamsSetDeviceOrdinal
+; Added in UMF_0.12
+    umfCtlExec
+    umfCtlGet
+    umfCtlSet
+    umfJemallocPoolParamsCreate
+    umfJemallocPoolParamsDestroy
+    umfJemallocPoolParamsSetNumArenas
+    umfPoolGetName
diff --git a/src/libumf.def.in b/src/libumf.def.in
deleted file mode 100644
index aa78d0953..000000000
--- a/src/libumf.def.in
+++ /dev/null
@@ -1,61 +0,0 @@
-;;;; Begin Copyright Notice
-; Copyright (C) 2024 Intel Corporation
-; Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
-; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-;;;;  End Copyright Notice
-
-LIBRARY umf
-
-VERSION 1.0
-
-EXPORTS
-    DllMain
-    umfInit
-    umfTearDown
-    umfGetCurrentVersion
-    umfCloseIPCHandle
-    umfFree
-    umfGetIPCHandle
-    umfGetLastFailedMemoryProvider
-    umfMemoryTrackerGetAllocInfo
-    umfMemoryProviderAlloc
-    umfMemoryProviderAllocationMerge
-    umfMemoryProviderAllocationSplit
-    umfMemoryProviderCloseIPCHandle
-    umfMemoryProviderCreate
-    umfMemoryProviderCreateFromMemspace
-    umfMemoryProviderDestroy
-    umfMemoryProviderFree
-    umfMemoryProviderGetIPCHandle
-    umfMemoryProviderGetIPCHandleSize
-    umfMemoryProviderGetLastNativeError
-    umfMemoryProviderGetMinPageSize
-    umfMemoryProviderGetName
-    umfMemoryProviderGetRecommendedPageSize
-    umfMemoryProviderOpenIPCHandle
-    umfMemoryProviderPurgeForce
-    umfMemoryProviderPurgeLazy
-    umfMemoryProviderPutIPCHandle
-    umfMempolicyCreate
-    umfMempolicyDestroy
-    umfMempolicySetCustomSplitPartitions
-    umfMempolicySetInterleavePartSize
-    umfMemspaceDestroy
-    umfOpenIPCHandle    
-    umfPoolAlignedMalloc
-    umfPoolByPtr
-    umfPoolCalloc
-    umfPoolCreate
-    umfPoolCreateFromMemspace
-    umfPoolDestroy
-    umfPoolFree
-    umfPoolGetIPCHandleSize
-    umfPoolGetLastAllocationError
-    umfPoolGetMemoryProvider
-    umfPoolMalloc
-    umfPoolMallocUsableSize
-    umfPoolRealloc
-    umfProxyPoolOps
-    umfPutIPCHandle
-    umfScalablePoolOps
-    @UMF_OPTIONAL_SYMBOLS_WINDOWS@
diff --git a/src/libumf.map b/src/libumf.map
new file mode 100644
index 000000000..e283c3853
--- /dev/null
+++ b/src/libumf.map
@@ -0,0 +1,147 @@
+# Copyright (C) 2023-2025 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+UMF_0.10 {
+    global:
+        umfInit;
+        umfTearDown;
+        umfGetCurrentVersion;
+        umfCloseIPCHandle;
+        umfCUDAMemoryProviderOps;
+        umfCUDAMemoryProviderParamsCreate;
+        umfCUDAMemoryProviderParamsDestroy;
+        umfCUDAMemoryProviderParamsSetContext;
+        umfCUDAMemoryProviderParamsSetDevice;
+        umfCUDAMemoryProviderParamsSetMemoryType;
+        umfDevDaxMemoryProviderOps;
+        umfDevDaxMemoryProviderParamsCreate;
+        umfDevDaxMemoryProviderParamsDestroy;
+        umfDevDaxMemoryProviderParamsSetDeviceDax;
+        umfDevDaxMemoryProviderParamsSetProtection;
+        umfFileMemoryProviderOps;
+        umfFileMemoryProviderParamsCreate;
+        umfFileMemoryProviderParamsDestroy;
+        umfFileMemoryProviderParamsSetPath;
+        umfFileMemoryProviderParamsSetProtection;
+        umfFileMemoryProviderParamsSetVisibility;
+        umfFree;
+        umfGetIPCHandle;
+        umfGetLastFailedMemoryProvider;
+        umfJemallocPoolOps;
+        umfLevelZeroMemoryProviderOps;
+        umfLevelZeroMemoryProviderParamsCreate;
+        umfLevelZeroMemoryProviderParamsDestroy;
+        umfLevelZeroMemoryProviderParamsSetContext;
+        umfLevelZeroMemoryProviderParamsSetDevice;
+        umfLevelZeroMemoryProviderParamsSetMemoryType;
+        umfLevelZeroMemoryProviderParamsSetResidentDevices;
+        umfMemoryProviderAlloc;
+        umfMemoryProviderAllocationMerge;
+        umfMemoryProviderAllocationSplit;
+        umfMemoryProviderCloseIPCHandle;
+        umfMemoryProviderCreate;
+        umfMemoryProviderCreateFromMemspace;
+        umfMemoryProviderDestroy;
+        umfMemoryProviderFree;
+        umfMemoryProviderGetIPCHandle;
+        umfMemoryProviderGetIPCHandleSize;
+        umfMemoryProviderGetLastNativeError;
+        umfMemoryProviderGetMinPageSize;
+        umfMemoryProviderGetName;
+        umfMemoryProviderGetRecommendedPageSize;
+        umfMemoryProviderOpenIPCHandle;
+        umfMemoryProviderPurgeForce;
+        umfMemoryProviderPurgeLazy;
+        umfMemoryProviderPutIPCHandle;
+        umfMempolicyCreate;
+        umfMempolicyDestroy;
+        umfMempolicySetCustomSplitPartitions;
+        umfMempolicySetInterleavePartSize;
+        umfMemspaceClone;
+        umfMemspaceCreateFromNumaArray;
+        umfMemspaceDestroy;
+        umfMemspaceFilterByCapacity;
+        umfMemspaceFilterById;
+        umfMemspaceHighestBandwidthGet;
+        umfMemspaceHighestCapacityGet;
+        umfMemspaceHostAllGet;
+        umfMemspaceLowestLatencyGet;
+        umfMemspaceMemtargetAdd;
+        umfMemspaceMemtargetGet;
+        umfMemspaceMemtargetNum;
+        umfMemspaceMemtargetRemove;
+        umfMemspaceNew;
+        umfMemspaceUserFilter;
+        umfMemtargetGetCapacity;
+        umfMemtargetGetId;
+        umfMemtargetGetType;
+        umfOpenIPCHandle;
+        umfOsMemoryProviderOps;
+        umfOsMemoryProviderParamsCreate;
+        umfOsMemoryProviderParamsDestroy;
+        umfOsMemoryProviderParamsSetNumaList;
+        umfOsMemoryProviderParamsSetNumaMode;
+        umfOsMemoryProviderParamsSetPartSize;
+        umfOsMemoryProviderParamsSetPartitions;
+        umfOsMemoryProviderParamsSetProtection;
+        umfOsMemoryProviderParamsSetShmName;
+        umfOsMemoryProviderParamsSetVisibility;
+        umfPoolAlignedMalloc;
+        umfPoolByPtr;
+        umfPoolCalloc;
+        umfPoolCreate;
+        umfPoolCreateFromMemspace;
+        umfPoolDestroy;
+        umfPoolFree;
+        umfPoolGetIPCHandler;
+        umfPoolGetIPCHandleSize;
+        umfPoolGetLastAllocationError;
+        umfPoolGetMemoryProvider;
+        umfPoolGetTag;
+        umfPoolMalloc;
+        umfPoolMallocUsableSize;
+        umfPoolRealloc;
+        umfPoolSetTag;
+        umfProxyPoolOps;
+        umfPutIPCHandle;
+        umfScalablePoolOps;
+        umfScalablePoolParamsCreate;
+        umfScalablePoolParamsDestroy;
+        umfScalablePoolParamsSetGranularity;
+        umfScalablePoolParamsSetKeepAllMemory;
+    local:
+        *;
+};
+
+UMF_0.11 {
+        umfCUDAMemoryProviderParamsSetAllocFlags;
+        umfDisjointPoolOps;
+        umfDisjointPoolParamsCreate;
+        umfDisjointPoolParamsDestroy;
+        umfDisjointPoolParamsSetCapacity;
+        umfDisjointPoolParamsSetMaxPoolableSize;
+        umfDisjointPoolParamsSetMinBucketSize;
+        umfDisjointPoolParamsSetName;
+        umfDisjointPoolParamsSetSharedLimits;
+        umfDisjointPoolParamsSetSlabMinSize;
+        umfDisjointPoolParamsSetTrace;
+        umfDisjointPoolSharedLimitsCreate;
+        umfDisjointPoolSharedLimitsDestroy;
+        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/libumf.map.in b/src/libumf.map.in
deleted file mode 100644
index 20031f16e..000000000
--- a/src/libumf.map.in
+++ /dev/null
@@ -1,58 +0,0 @@
-# Copyright (C) 2024 Intel Corporation
-# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-UMF_1.0 {
-    global:
-        umfInit;
-        umfTearDown;
-        umfGetCurrentVersion;
-        umfCloseIPCHandle;
-        umfFree;
-        umfGetIPCHandle;
-        umfGetLastFailedMemoryProvider;
-        umfMemoryTrackerGetAllocInfo;
-        umfMemoryProviderAlloc;
-        umfMemoryProviderAllocationMerge;
-        umfMemoryProviderAllocationSplit;
-        umfMemoryProviderCloseIPCHandle;
-        umfMemoryProviderCreate;
-        umfMemoryProviderCreateFromMemspace;
-        umfMemoryProviderDestroy;
-        umfMemoryProviderFree;
-        umfMemoryProviderGetIPCHandle;
-        umfMemoryProviderGetIPCHandleSize;
-        umfMemoryProviderGetLastNativeError;
-        umfMemoryProviderGetMinPageSize;
-        umfMemoryProviderGetName;
-        umfMemoryProviderGetRecommendedPageSize;
-        umfMemoryProviderOpenIPCHandle;
-        umfMemoryProviderPurgeForce;
-        umfMemoryProviderPurgeLazy;
-        umfMemoryProviderPutIPCHandle;
-        umfMempolicyCreate;
-        umfMempolicyDestroy;
-        umfMempolicySetCustomSplitPartitions;
-        umfMempolicySetInterleavePartSize;
-        umfMemspaceDestroy;
-        umfOpenIPCHandle;
-        umfPoolAlignedMalloc;
-        umfPoolByPtr;
-        umfPoolCalloc;
-        umfPoolCreate;
-        umfPoolCreateFromMemspace;
-        umfPoolDestroy;
-        umfPoolFree;
-        umfPoolGetIPCHandleSize;
-        umfPoolGetLastAllocationError;
-        umfPoolGetMemoryProvider;
-        umfPoolMalloc;
-        umfPoolMallocUsableSize;
-        umfPoolRealloc;
-        umfProxyPoolOps;
-        umfPutIPCHandle;
-        umfScalablePoolOps;
-        @UMF_OPTIONAL_SYMBOLS_LINUX@
-    local:
-        *;
-};
diff --git a/src/libumf.rc.in b/src/libumf.rc.in
index 7aba79e7e..43bed1560 100644
--- a/src/libumf.rc.in
+++ b/src/libumf.rc.in
@@ -1,4 +1,4 @@
-// Copyright (c) 2024 Intel Corporation
+// Copyright (C) 2024-2025 Intel Corporation
 //
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -10,6 +10,8 @@
 
 #define UMF_VERNUMBERS @PROJECT_VERSION_MAJOR@,@PROJECT_VERSION_MINOR@,@PROJECT_VERSION_PATCH@,@UMF_VERSION_REVISION@
 #define _UMF_VERSION "@UMF_VERSION@"
+// Store our CMake vars in the "FileDescription" block, as the custom fields require special parsing.
+#define _UMF_CMAKE_VARS "@UMF_ALL_CMAKE_VARIABLES@"
 
 #ifdef _DEBUG
 #define VERSION_DEBUG VS_FF_DEBUG
@@ -49,9 +51,9 @@ BEGIN
         BLOCK "040904b0" // U.S. English, Unicode (0x04b0 == 1200)
         BEGIN
             VALUE "CompanyName", "Intel Corporation\0"
-            VALUE "FileDescription", "Unified Memory Framework (UMF) library\0"
+            VALUE "FileDescription", "Unified Memory Framework (UMF) library (build options: " _UMF_CMAKE_VARS ")\0"
             VALUE "FileVersion", _UMF_VERSION "\0"
-            VALUE "LegalCopyright", "Copyright 2024, Intel Corporation. All rights reserved.\0"
+            VALUE "LegalCopyright", "Copyright 2024-2025, Intel Corporation. All rights reserved.\0"
             VALUE "LegalTrademarks", "\0"
             VALUE "OriginalFilename", "umf.dll\0"
             VALUE "ProductName", "Unified Memory Framework (UMF)\0"
diff --git a/src/memory_pool.c b/src/memory_pool.c
index 7d65acf36..ad5182236 100644
--- a/src/memory_pool.c
+++ b/src/memory_pool.c
@@ -1,47 +1,189 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  */
 
-#include "libumf.h"
-#include "memory_pool_internal.h"
-#include "utils_assert.h"
-
+#include <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;
     }
 
+    // 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;
     }
 
-    assert(ops->version == UMF_VERSION_CURRENT);
-
     if (!(flags & UMF_POOL_CREATE_FLAG_DISABLE_TRACKING)) {
-        // wrap provider with memory tracking provider
+        // Wrap provider with memory tracking provider.
         ret = umfTrackingMemoryProviderCreate(provider, pool, &pool->provider);
         if (ret != UMF_RESULT_SUCCESS) {
             goto err_provider_create;
@@ -50,19 +192,45 @@ 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");
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+        goto err_lock_init;
+    }
 
     ret = ops->initialize(pool->provider, params, &pool->pool_priv);
     if (ret != UMF_RESULT_SUCCESS) {
         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;
 
 err_pool_init:
+    utils_mutex_destroy_not_free(&pool->lock);
+err_lock_init:
     if (!(flags & UMF_POOL_CREATE_FLAG_DISABLE_TRACKING)) {
         umfMemoryProviderDestroy(pool->provider);
     }
@@ -71,29 +239,46 @@ 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);
-    if (hPool->flags & UMF_POOL_CREATE_FLAG_OWN_PROVIDER) {
-        // Destroy associated memory provider.
-        umf_memory_provider_handle_t hProvider = NULL;
-        umfPoolGetMemoryProvider(hPool, &hProvider);
-        umfMemoryProviderDestroy(hProvider);
+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.
+        umf_result_t ret2 = umfMemoryProviderDestroy(hUpstreamProvider);
+        if (ret == UMF_RESULT_SUCCESS) {
+            ret = ret2;
+        }
+    }
+
+    utils_mutex_destroy_not_free(&hPool->lock);
+
     LOG_INFO("Memory pool destroyed: %p", (void *)hPool);
 
     // TODO: this free keeps memory in base allocator, so it can lead to OOM in some scenarios (it should be optimized)
     umf_ba_global_free(hPool);
+    return ret;
 }
 
 umf_result_t umfFree(void *ptr) {
     umf_memory_pool_handle_t hPool = umfPoolByPtr(ptr);
     if (hPool) {
+        LOG_DEBUG("calling umfPoolFree(pool=%p, ptr=%p) ...", (void *)hPool,
+                  ptr);
         return umfPoolFree(hPool, ptr);
     }
     return UMF_RESULT_SUCCESS;
@@ -119,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();
 
@@ -137,36 +330,90 @@ 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) {
     UMF_CHECK((hPool != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     return hPool->ops.get_last_allocation_error(hPool->pool_priv);
 }
+
+umf_result_t umfPoolSetTag(umf_memory_pool_handle_t hPool, void *tag,
+                           void **oldTag) {
+    UMF_CHECK((hPool != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    utils_mutex_lock(&hPool->lock);
+    if (oldTag) {
+        *oldTag = hPool->tag;
+    }
+    hPool->tag = tag;
+    utils_mutex_unlock(&hPool->lock);
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfPoolGetTag(umf_memory_pool_handle_t hPool, void **tag) {
+    UMF_CHECK((hPool != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((tag != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    utils_mutex_lock(&hPool->lock);
+    *tag = hPool->tag;
+    utils_mutex_unlock(&hPool->lock);
+    return UMF_RESULT_SUCCESS;
+}
diff --git a/src/memory_pool_internal.h b/src/memory_pool_internal.h
index 90f2f1629..ad05464dd 100644
--- a/src/memory_pool_internal.h
+++ b/src/memory_pool_internal.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -22,14 +22,26 @@ extern "C" {
 #endif
 
 #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.
     umf_memory_provider_handle_t provider;
+
+    utils_mutex_t lock;
+    void *tag;
+    // Memory pool statistics
+    umf_pool_stats_t stats;
+
+    // ops should be the last due to possible change size in the future
+    umf_memory_pool_ops_t ops;
 } umf_memory_pool_t;
 
 #ifdef __cplusplus
diff --git a/src/memory_provider.c b/src/memory_provider.c
index f6e07af62..c262ad80d 100644
--- a/src/memory_provider.c
+++ b/src/memory_provider.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -18,12 +18,22 @@
 #include "base_alloc_global.h"
 #include "libumf.h"
 #include "memory_provider_internal.h"
+#include "umf/base.h"
 #include "utils_assert.h"
 
-typedef struct umf_memory_provider_t {
-    umf_memory_provider_ops_t ops;
-    void *provider_priv;
-} umf_memory_provider_t;
+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) {
@@ -98,83 +108,114 @@ 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->ext_get_ipc_handle) {
+        ops->ext_get_ipc_handle = umfDefaultGetIPCHandle;
     }
-    if (!ops->ipc.get_ipc_handle) {
-        ops->ipc.get_ipc_handle = umfDefaultGetIPCHandle;
+    if (!ops->ext_put_ipc_handle) {
+        ops->ext_put_ipc_handle = umfDefaultPutIPCHandle;
     }
-    if (!ops->ipc.put_ipc_handle) {
-        ops->ipc.put_ipc_handle = umfDefaultPutIPCHandle;
+    if (!ops->ext_open_ipc_handle) {
+        ops->ext_open_ipc_handle = umfDefaultOpenIPCHandle;
     }
-    if (!ops->ipc.open_ipc_handle) {
-        ops->ipc.open_ipc_handle = umfDefaultOpenIPCHandle;
+    if (!ops->ext_close_ipc_handle) {
+        ops->ext_close_ipc_handle = umfDefaultCloseIPCHandle;
     }
-    if (!ops->ipc.close_ipc_handle) {
-        ops->ipc.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)) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
+    if (ops->version != UMF_PROVIDER_OPS_VERSION_CURRENT) {
+        LOG_WARN("Memory Provider ops version \"%d\" is different than the "
+                 "current version \"%d\"",
+                 ops->version, UMF_PROVIDER_OPS_VERSION_CURRENT);
+    }
+
     umf_memory_provider_handle_t provider =
         umf_ba_global_alloc(sizeof(umf_memory_provider_t));
     if (!provider) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    assert(ops->version == UMF_VERSION_CURRENT);
-
     provider->ops = *ops;
 
     assignOpsExtDefaults(&(provider->ops));
@@ -194,9 +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) {
-    hProvider->ops.finalize(hProvider->provider_priv);
+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
@@ -210,6 +260,7 @@ checkErrorAndSetLastProvider(umf_result_t result,
 umf_result_t umfMemoryProviderAlloc(umf_memory_provider_handle_t hProvider,
                                     size_t size, size_t alignment, void **ptr) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     umf_result_t res =
         hProvider->ops.alloc(hProvider->provider_priv, size, alignment, ptr);
     checkErrorAndSetLastProvider(res, hProvider);
@@ -241,6 +292,7 @@ umf_result_t
 umfMemoryProviderGetRecommendedPageSize(umf_memory_provider_handle_t hProvider,
                                         size_t size, size_t *pageSize) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((pageSize != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     umf_result_t res = hProvider->ops.get_recommended_page_size(
         hProvider->provider_priv, size, pageSize);
     checkErrorAndSetLastProvider(res, hProvider);
@@ -249,8 +301,9 @@ 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(
         hProvider->provider_priv, ptr, pageSize);
     checkErrorAndSetLastProvider(res, hProvider);
@@ -265,8 +318,9 @@ const char *umfMemoryProviderGetName(umf_memory_provider_handle_t hProvider) {
 umf_result_t umfMemoryProviderPurgeLazy(umf_memory_provider_handle_t hProvider,
                                         void *ptr, size_t size) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     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;
 }
@@ -274,8 +328,9 @@ umf_result_t umfMemoryProviderPurgeLazy(umf_memory_provider_handle_t hProvider,
 umf_result_t umfMemoryProviderPurgeForce(umf_memory_provider_handle_t hProvider,
                                          void *ptr, size_t size) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     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;
 }
@@ -288,17 +343,13 @@ umf_result_t
 umfMemoryProviderAllocationSplit(umf_memory_provider_handle_t hProvider,
                                  void *ptr, size_t totalSize,
                                  size_t firstSize) {
-    if (!ptr) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-    if (firstSize == 0 || totalSize == 0) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-    if (firstSize >= totalSize) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((firstSize != 0 && totalSize != 0),
+              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;
@@ -308,20 +359,15 @@ umf_result_t
 umfMemoryProviderAllocationMerge(umf_memory_provider_handle_t hProvider,
                                  void *lowPtr, void *highPtr,
                                  size_t totalSize) {
-    if (!lowPtr || !highPtr) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-    if (totalSize == 0) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-    if ((uintptr_t)lowPtr >= (uintptr_t)highPtr) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-    if ((uintptr_t)highPtr - (uintptr_t)lowPtr > totalSize) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    umf_result_t res = hProvider->ops.ext.allocation_merge(
+    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((lowPtr && highPtr), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((totalSize != 0), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK(((uintptr_t)lowPtr < (uintptr_t)highPtr),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK(((uintptr_t)highPtr - (uintptr_t)lowPtr < totalSize),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result_t res = hProvider->ops.ext_allocation_merge(
         hProvider->provider_priv, lowPtr, highPtr, totalSize);
     checkErrorAndSetLastProvider(res, hProvider);
     return res;
@@ -330,7 +376,9 @@ umfMemoryProviderAllocationMerge(umf_memory_provider_handle_t hProvider,
 umf_result_t
 umfMemoryProviderGetIPCHandleSize(umf_memory_provider_handle_t hProvider,
                                   size_t *size) {
-    return hProvider->ops.ipc.get_ipc_handle_size(hProvider->provider_priv,
+    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((size != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    return hProvider->ops.ext_get_ipc_handle_size(hProvider->provider_priv,
                                                   size);
 }
 
@@ -338,27 +386,37 @@ umf_result_t
 umfMemoryProviderGetIPCHandle(umf_memory_provider_handle_t hProvider,
                               const void *ptr, size_t size,
                               void *providerIpcData) {
-    return hProvider->ops.ipc.get_ipc_handle(hProvider->provider_priv, ptr,
+    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.ext_get_ipc_handle(hProvider->provider_priv, ptr,
                                              size, providerIpcData);
 }
 
 umf_result_t
 umfMemoryProviderPutIPCHandle(umf_memory_provider_handle_t hProvider,
                               void *providerIpcData) {
-    return hProvider->ops.ipc.put_ipc_handle(hProvider->provider_priv,
+    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((providerIpcData != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    return hProvider->ops.ext_put_ipc_handle(hProvider->provider_priv,
                                              providerIpcData);
 }
 
 umf_result_t
 umfMemoryProviderOpenIPCHandle(umf_memory_provider_handle_t hProvider,
                                void *providerIpcData, void **ptr) {
-    return hProvider->ops.ipc.open_ipc_handle(hProvider->provider_priv,
+    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.ext_open_ipc_handle(hProvider->provider_priv,
                                               providerIpcData, ptr);
 }
 
 umf_result_t
 umfMemoryProviderCloseIPCHandle(umf_memory_provider_handle_t hProvider,
                                 void *ptr, size_t size) {
-    return hProvider->ops.ipc.close_ipc_handle(hProvider->provider_priv, ptr,
+    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    return hProvider->ops.ext_close_ipc_handle(hProvider->provider_priv, ptr,
                                                size);
 }
diff --git a/src/memory_provider_get_last_failed.c b/src/memory_provider_get_last_failed.c
index 9434eea97..09bd075e1 100644
--- a/src/memory_provider_get_last_failed.c
+++ b/src/memory_provider_get_last_failed.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
diff --git a/src/memory_provider_internal.h b/src/memory_provider_internal.h
index 4e858992d..4b4ec8b2d 100644
--- a/src/memory_provider_internal.h
+++ b/src/memory_provider_internal.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -10,15 +10,28 @@
 #ifndef UMF_MEMORY_PROVIDER_INTERNAL_H
 #define UMF_MEMORY_PROVIDER_INTERNAL_H 1
 
+#include <stdbool.h>
+
 #include <umf/memory_provider.h>
 
+#include "ctl/ctl.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+typedef struct umf_memory_provider_t {
+    void *provider_priv;
+    // ops should be the last due to possible change size in the future
+    umf_memory_provider_ops_t ops;
+} umf_memory_provider_t;
+
 void *umfMemoryProviderGetPriv(umf_memory_provider_handle_t hProvider);
 umf_memory_provider_handle_t *umfGetLastFailedMemoryProviderPtr(void);
 
+extern umf_ctl_node_t CTL_NODE(provider)[];
+extern umf_ctl_node_t CTL_NODE(pool)[];
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/memory_target.c b/src/memory_target.c
deleted file mode 100644
index 3cbdb09d9..000000000
--- a/src/memory_target.c
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- *
- * Copyright (C) 2023-2024 Intel Corporation
- *
- * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- *
- */
-
-#include <assert.h>
-#include <stdlib.h>
-
-#include "base_alloc_global.h"
-#include "libumf.h"
-#include "memory_target.h"
-#include "memory_target_ops.h"
-#include "utils_concurrency.h"
-
-umf_result_t umfMemoryTargetCreate(const umf_memory_target_ops_t *ops,
-                                   void *params,
-                                   umf_memory_target_handle_t *memoryTarget) {
-    libumfInit();
-    if (!ops || !memoryTarget) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    umf_memory_target_handle_t target =
-        umf_ba_global_alloc(sizeof(umf_memory_target_t));
-    if (!target) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    assert(ops->version == UMF_VERSION_CURRENT);
-
-    target->ops = ops;
-
-    void *target_priv;
-    umf_result_t ret = ops->initialize(params, &target_priv);
-    if (ret != UMF_RESULT_SUCCESS) {
-        umf_ba_global_free(target);
-        return ret;
-    }
-
-    target->priv = target_priv;
-
-    *memoryTarget = target;
-
-    return UMF_RESULT_SUCCESS;
-}
-
-void umfMemoryTargetDestroy(umf_memory_target_handle_t memoryTarget) {
-    assert(memoryTarget);
-    memoryTarget->ops->finalize(memoryTarget->priv);
-    umf_ba_global_free(memoryTarget);
-}
-
-umf_result_t umfMemoryTargetClone(umf_memory_target_handle_t memoryTarget,
-                                  umf_memory_target_handle_t *outHandle) {
-    assert(memoryTarget);
-    assert(outHandle);
-
-    *outHandle = umf_ba_global_alloc(sizeof(umf_memory_target_t));
-    if (!*outHandle) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    void *outPriv;
-    umf_result_t ret = memoryTarget->ops->clone(memoryTarget->priv, &outPriv);
-    if (ret != UMF_RESULT_SUCCESS) {
-        umf_ba_global_free(*outHandle);
-        return ret;
-    }
-
-    (*outHandle)->ops = memoryTarget->ops;
-    (*outHandle)->priv = outPriv;
-
-    return UMF_RESULT_SUCCESS;
-}
-
-umf_result_t umfMemoryTargetGetCapacity(umf_memory_target_handle_t memoryTarget,
-                                        size_t *capacity) {
-    if (!memoryTarget || !capacity) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    return memoryTarget->ops->get_capacity(memoryTarget->priv, capacity);
-}
-
-umf_result_t
-umfMemoryTargetGetBandwidth(umf_memory_target_handle_t srcMemoryTarget,
-                            umf_memory_target_handle_t dstMemoryTarget,
-                            size_t *bandwidth) {
-    if (!srcMemoryTarget || !dstMemoryTarget || !bandwidth) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    return srcMemoryTarget->ops->get_bandwidth(
-        srcMemoryTarget->priv, dstMemoryTarget->priv, bandwidth);
-}
-
-umf_result_t
-umfMemoryTargetGetLatency(umf_memory_target_handle_t srcMemoryTarget,
-                          umf_memory_target_handle_t dstMemoryTarget,
-                          size_t *latency) {
-    if (!srcMemoryTarget || !dstMemoryTarget || !latency) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    return srcMemoryTarget->ops->get_latency(srcMemoryTarget->priv,
-                                             dstMemoryTarget->priv, latency);
-}
diff --git a/src/memory_target.h b/src/memory_target.h
deleted file mode 100644
index c522cce24..000000000
--- a/src/memory_target.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- *
- * Copyright (C) 2023-2024 Intel Corporation
- *
- * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- *
- */
-
-#ifndef UMF_MEMORY_TARGET_H
-#define UMF_MEMORY_TARGET_H 1
-
-#include <umf/base.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct umf_memory_target_ops_t;
-typedef struct umf_memory_target_ops_t umf_memory_target_ops_t;
-
-typedef struct umf_memory_target_t {
-    const umf_memory_target_ops_t *ops;
-    void *priv;
-} umf_memory_target_t;
-
-typedef umf_memory_target_t *umf_memory_target_handle_t;
-
-umf_result_t umfMemoryTargetCreate(const umf_memory_target_ops_t *ops,
-                                   void *params,
-                                   umf_memory_target_handle_t *memoryTarget);
-void umfMemoryTargetDestroy(umf_memory_target_handle_t memoryTarget);
-
-umf_result_t umfMemoryTargetClone(umf_memory_target_handle_t memoryTarget,
-                                  umf_memory_target_handle_t *outHandle);
-umf_result_t umfMemoryTargetGetCapacity(umf_memory_target_handle_t memoryTarget,
-                                        size_t *capacity);
-umf_result_t
-umfMemoryTargetGetBandwidth(umf_memory_target_handle_t srcMemoryTarget,
-                            umf_memory_target_handle_t dstMemoryTarget,
-                            size_t *bandwidth);
-umf_result_t
-umfMemoryTargetGetLatency(umf_memory_target_handle_t srcMemoryTarget,
-                          umf_memory_target_handle_t dstMemoryTarget,
-                          size_t *latency);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* UMF_MEMORY_TARGET_H */
diff --git a/src/memory_targets/memory_target_numa.h b/src/memory_targets/memory_target_numa.h
deleted file mode 100644
index 843610a2a..000000000
--- a/src/memory_targets/memory_target_numa.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- *
- * Copyright (C) 2023 Intel Corporation
- *
- * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- *
- */
-
-#ifndef UMF_MEMORY_TARGET_NUMA_H
-#define UMF_MEMORY_TARGET_NUMA_H 1
-
-#include <umf.h>
-#include <umf/memspace.h>
-
-#include "../memory_target.h"
-#include "../memory_target_ops.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct umf_numa_memory_target_config_t {
-    size_t physical_id;
-};
-
-extern struct umf_memory_target_ops_t UMF_MEMORY_TARGET_NUMA_OPS;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* UMF_MEMORY_TARGET_NUMA_H */
diff --git a/src/memspace.c b/src/memspace.c
index 03e716c84..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
@@ -13,9 +13,10 @@
 #include <umf/memspace.h>
 
 #include "base_alloc_global.h"
-#include "memory_target.h"
-#include "memory_target_ops.h"
 #include "memspace_internal.h"
+#include "memtarget_internal.h"
+#include "memtarget_ops.h"
+#include "utils_log.h"
 
 #ifndef NDEBUG
 static umf_result_t
@@ -25,7 +26,7 @@ verifyMemTargetsTypes(umf_const_memspace_handle_t memspace) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    const struct umf_memory_target_ops_t *ops = memspace->nodes[0]->ops;
+    const struct umf_memtarget_ops_t *ops = memspace->nodes[0]->ops;
     for (size_t i = 1; i < memspace->size; i++) {
         if (memspace->nodes[i]->ops != ops) {
             return UMF_RESULT_ERROR_INVALID_ARGUMENT;
@@ -60,13 +61,17 @@ umf_result_t umfPoolCreateFromMemspace(umf_const_memspace_handle_t memspace,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
+    if (memspace->size == 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
     void **privs = NULL;
     umf_result_t ret = memoryTargetHandlesToPriv(memspace, &privs);
     if (ret != UMF_RESULT_SUCCESS) {
         return ret;
     }
 
-    // TODO: for now, we only support memspaces that consist of memory_targets
+    // TODO: for now, we only support memspaces that consist of memtargets
     // of the same type. Fix this.
     assert(verifyMemTargetsTypes(memspace) == UMF_RESULT_SUCCESS);
     ret = memspace->nodes[0]->ops->pool_create_from_memspace(
@@ -85,13 +90,17 @@ umfMemoryProviderCreateFromMemspace(umf_const_memspace_handle_t memspace,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
+    if (memspace->size == 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
     void **privs = NULL;
     umf_result_t ret = memoryTargetHandlesToPriv(memspace, &privs);
     if (ret != UMF_RESULT_SUCCESS) {
         return ret;
     }
 
-    // TODO: for now, we only support memspaces that consist of memory_targets
+    // TODO: for now, we only support memspaces that consist of memtargets
     // of the same type. Fix this.
     assert(verifyMemTargetsTypes(memspace) == UMF_RESULT_SUCCESS);
     ret = memspace->nodes[0]->ops->memory_provider_create_from_memspace(
@@ -102,14 +111,34 @@ umfMemoryProviderCreateFromMemspace(umf_const_memspace_handle_t memspace,
     return ret;
 }
 
-void umfMemspaceDestroy(umf_memspace_handle_t memspace) {
+umf_result_t umfMemspaceNew(umf_memspace_handle_t *hMemspace) {
+    if (!hMemspace) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_memspace_handle_t memspace =
+        umf_ba_global_alloc(sizeof(struct umf_memspace_t));
+    if (!memspace) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    memspace->size = 0;
+    memspace->nodes = NULL;
+
+    *hMemspace = memspace;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfMemspaceDestroy(umf_memspace_handle_t memspace) {
     assert(memspace);
     for (size_t i = 0; i < memspace->size; i++) {
-        umfMemoryTargetDestroy(memspace->nodes[i]);
+        umfMemtargetDestroy(memspace->nodes[i]);
     }
 
     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,
@@ -126,7 +155,7 @@ umf_result_t umfMemspaceClone(umf_const_memspace_handle_t hMemspace,
 
     clone->size = hMemspace->size;
     clone->nodes =
-        umf_ba_global_alloc(sizeof(umf_memory_target_handle_t) * clone->size);
+        umf_ba_global_alloc(sizeof(umf_memtarget_handle_t) * clone->size);
     if (!clone->nodes) {
         umf_ba_global_free(clone);
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
@@ -136,7 +165,7 @@ umf_result_t umfMemspaceClone(umf_const_memspace_handle_t hMemspace,
     umf_result_t ret;
 
     for (i = 0; i < clone->size; i++) {
-        ret = umfMemoryTargetClone(hMemspace->nodes[i], &clone->nodes[i]);
+        ret = umfMemtargetClone(hMemspace->nodes[i], &clone->nodes[i]);
         if (ret != UMF_RESULT_SUCCESS) {
             goto err;
         }
@@ -148,21 +177,21 @@ umf_result_t umfMemspaceClone(umf_const_memspace_handle_t hMemspace,
 err:
     while (i != 0) {
         i--;
-        umfMemoryTargetDestroy(clone->nodes[i]);
+        umfMemtargetDestroy(clone->nodes[i]);
     }
     umf_ba_global_free(clone->nodes);
     umf_ba_global_free(clone);
     return ret;
 }
 
-struct memory_target_sort_entry {
+struct memtarget_sort_entry {
     uint64_t property;
-    umf_memory_target_handle_t node;
+    umf_memtarget_handle_t node;
 };
 
 static int propertyCmp(const void *a, const void *b) {
-    const struct memory_target_sort_entry *entryA = a;
-    const struct memory_target_sort_entry *entryB = b;
+    const struct memtarget_sort_entry *entryA = a;
+    const struct memtarget_sort_entry *entryB = b;
 
     if (entryA->property < entryB->property) {
         return 1;
@@ -173,16 +202,14 @@ static int propertyCmp(const void *a, const void *b) {
     }
 }
 
-umf_result_t
-umfMemspaceSortDesc(umf_memspace_handle_t hMemspace,
-                    umf_result_t (*getProperty)(umf_memory_target_handle_t node,
-                                                uint64_t *property)) {
+umf_result_t umfMemspaceSortDesc(umf_memspace_handle_t hMemspace,
+                                 umfGetPropertyFn getProperty) {
     if (!hMemspace || !getProperty) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    struct memory_target_sort_entry *entries = umf_ba_global_alloc(
-        sizeof(struct memory_target_sort_entry) * hMemspace->size);
+    struct memtarget_sort_entry *entries = umf_ba_global_alloc(
+        sizeof(struct memtarget_sort_entry) * hMemspace->size);
     if (!entries) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
@@ -198,7 +225,7 @@ umfMemspaceSortDesc(umf_memspace_handle_t hMemspace,
         }
     }
 
-    qsort(entries, hMemspace->size, sizeof(struct memory_target_sort_entry),
+    qsort(entries, hMemspace->size, sizeof(struct memtarget_sort_entry),
           propertyCmp);
 
     // apply the order to the original array
@@ -218,7 +245,7 @@ umf_result_t umfMemspaceFilter(umf_const_memspace_handle_t hMemspace,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    umf_memory_target_handle_t *uniqueBestNodes =
+    umf_memtarget_handle_t *uniqueBestNodes =
         umf_ba_global_alloc(hMemspace->size * sizeof(*uniqueBestNodes));
     if (!uniqueBestNodes) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
@@ -228,7 +255,7 @@ umf_result_t umfMemspaceFilter(umf_const_memspace_handle_t hMemspace,
 
     size_t numUniqueBestNodes = 0;
     for (size_t nodeIdx = 0; nodeIdx < hMemspace->size; nodeIdx++) {
-        umf_memory_target_handle_t target = NULL;
+        umf_memtarget_handle_t target = NULL;
         ret = getTarget(hMemspace->nodes[nodeIdx], hMemspace->nodes,
                         hMemspace->size, &target);
         if (ret != UMF_RESULT_SUCCESS) {
@@ -268,8 +295,8 @@ umf_result_t umfMemspaceFilter(umf_const_memspace_handle_t hMemspace,
 
     size_t cloneIdx = 0;
     for (cloneIdx = 0; cloneIdx < newMemspace->size; cloneIdx++) {
-        ret = umfMemoryTargetClone(uniqueBestNodes[cloneIdx],
-                                   &newMemspace->nodes[cloneIdx]);
+        ret = umfMemtargetClone(uniqueBestNodes[cloneIdx],
+                                &newMemspace->nodes[cloneIdx]);
         if (ret != UMF_RESULT_SUCCESS) {
             goto err_free_cloned_nodes;
         }
@@ -283,7 +310,7 @@ umf_result_t umfMemspaceFilter(umf_const_memspace_handle_t hMemspace,
 err_free_cloned_nodes:
     while (cloneIdx != 0) {
         cloneIdx--;
-        umfMemoryTargetDestroy(newMemspace->nodes[cloneIdx]);
+        umfMemtargetDestroy(newMemspace->nodes[cloneIdx]);
     }
     umf_ba_global_free(newMemspace->nodes);
 err_free_new_memspace:
@@ -292,3 +319,261 @@ umf_result_t umfMemspaceFilter(umf_const_memspace_handle_t hMemspace,
     umf_ba_global_free(uniqueBestNodes);
     return ret;
 }
+
+size_t umfMemspaceMemtargetNum(umf_const_memspace_handle_t hMemspace) {
+    if (!hMemspace) {
+        return 0;
+    }
+    return hMemspace->size;
+}
+
+umf_const_memtarget_handle_t
+umfMemspaceMemtargetGet(umf_const_memspace_handle_t hMemspace,
+                        unsigned targetNum) {
+    if (!hMemspace || targetNum >= hMemspace->size) {
+        return NULL;
+    }
+    return hMemspace->nodes[targetNum];
+}
+
+umf_result_t umfMemspaceMemtargetAdd(umf_memspace_handle_t hMemspace,
+                                     umf_const_memtarget_handle_t hMemtarget) {
+    if (!hMemspace || !hMemtarget) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    for (size_t i = 0; i < hMemspace->size; i++) {
+        int cmp;
+        umf_result_t ret =
+            umfMemtargetCompare(hMemspace->nodes[i], hMemtarget, &cmp);
+        if (ret != UMF_RESULT_SUCCESS) {
+            return ret;
+        }
+
+        if (cmp == 0) {
+            LOG_ERR("Memory target already exists in the memspace");
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        } else if (cmp < 0) {
+            LOG_ERR("You can't mix different memory target types in the same "
+                    "memspace");
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+    }
+
+    umf_memtarget_handle_t *newNodes =
+        umf_ba_global_alloc(sizeof(*newNodes) * (hMemspace->size + 1));
+    if (!newNodes) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    for (size_t i = 0; i < hMemspace->size; i++) {
+        newNodes[i] = hMemspace->nodes[i];
+    }
+    umf_memtarget_t *hMemtargetClone;
+
+    umf_result_t ret = umfMemtargetClone(hMemtarget, &hMemtargetClone);
+    if (ret != UMF_RESULT_SUCCESS) {
+        umf_ba_global_free(newNodes);
+        return ret;
+    }
+    newNodes[hMemspace->size++] = hMemtargetClone;
+
+    umf_ba_global_free(hMemspace->nodes);
+    hMemspace->nodes = newNodes;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfMemspaceMemtargetRemove(umf_memspace_handle_t hMemspace,
+                           umf_const_memtarget_handle_t hMemtarget) {
+    if (!hMemspace || !hMemtarget) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    unsigned i;
+    for (i = 0; i < hMemspace->size; i++) {
+        int cmp;
+        umf_result_t ret =
+            umfMemtargetCompare(hMemspace->nodes[i], hMemtarget, &cmp);
+
+        if (ret != UMF_RESULT_SUCCESS) {
+            return ret;
+        }
+
+        if (cmp == 0) {
+            break;
+        }
+    }
+
+    if (i == hMemspace->size) {
+        LOG_ERR("Memory target not found in the memspace");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_memtarget_handle_t *newNodes =
+        umf_ba_global_alloc(sizeof(*newNodes) * (hMemspace->size - 1));
+    if (!newNodes) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    for (unsigned j = 0, z = 0; j < hMemspace->size; j++) {
+        if (j != i) {
+            newNodes[z++] = hMemspace->nodes[j];
+        }
+    }
+
+    umfMemtargetDestroy(hMemspace->nodes[i]);
+    umf_ba_global_free(hMemspace->nodes);
+    hMemspace->nodes = newNodes;
+    hMemspace->size--;
+    return UMF_RESULT_SUCCESS;
+}
+
+// Helper function - returns zero on success, negative in case of error in filter function
+// and positive error code, in case of other errors.
+static int umfMemspaceFilterHelper(umf_memspace_handle_t memspace,
+                                   umf_memspace_filter_func_t filter,
+                                   void *args) {
+
+    if (!memspace || !filter) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    size_t idx = 0;
+    int ret;
+    umf_memtarget_handle_t *nodesToRemove =
+        umf_ba_global_alloc(sizeof(*nodesToRemove) * memspace->size);
+    if (!nodesToRemove) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    for (size_t i = 0; i < memspace->size; i++) {
+        ret = filter(memspace, memspace->nodes[i], args);
+        if (ret < 0) {
+            LOG_ERR("filter function failed");
+            goto free_mem;
+        } else if (ret == 0) {
+            nodesToRemove[idx++] = memspace->nodes[i];
+        }
+    }
+
+    size_t i = 0;
+    for (; i < idx; i++) {
+        ret = umfMemspaceMemtargetRemove(memspace, nodesToRemove[i]);
+        if (ret != UMF_RESULT_SUCCESS) {
+            goto re_add;
+        }
+    }
+
+    umf_ba_global_free(nodesToRemove);
+    return UMF_RESULT_SUCCESS;
+
+re_add:
+    // If target removal failed, add back previously removed targets.
+    for (size_t j = 0; j < i; j++) {
+        umf_result_t ret2 = umfMemspaceMemtargetAdd(memspace, nodesToRemove[j]);
+        if (ret2 != UMF_RESULT_SUCCESS) {
+            ret =
+                UMF_RESULT_ERROR_UNKNOWN; // indicate that memspace is corrupted
+            break;
+        }
+    }
+free_mem:
+    umf_ba_global_free(nodesToRemove);
+    return ret;
+}
+
+umf_result_t umfMemspaceUserFilter(umf_memspace_handle_t memspace,
+                                   umf_memspace_filter_func_t filter,
+                                   void *args) {
+
+    if (!memspace || !filter) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    int ret = umfMemspaceFilterHelper(memspace, filter, args);
+    if (ret < 0) {
+        return UMF_RESULT_ERROR_USER_SPECIFIC;
+    }
+
+    return ret;
+}
+
+typedef struct filter_by_id_args {
+    unsigned *ids; // array of numa nodes ids
+    size_t size;   // size of the array
+} filter_by_id_args_t;
+
+/*
+ * The following predefined filter callbacks returns umf_result_t codes as negative value
+ * because only negative values are treated as errors. umfMemspaceFilterHelper() will pass
+ * this error code through and umfMemspaceFilterBy*() functions will translate this code to positive
+ * umf_result_t code.
+ */
+
+static int filterById(umf_const_memspace_handle_t memspace,
+                      umf_const_memtarget_handle_t target, void *args) {
+    if (!memspace || !target || !args) {
+        return -UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    filter_by_id_args_t *filterArgs = args;
+    for (size_t i = 0; i < filterArgs->size; i++) {
+        unsigned id;
+        umf_result_t ret = umfMemtargetGetId(target, &id);
+        if (ret != UMF_RESULT_SUCCESS) {
+            return -ret;
+        }
+
+        if (id == filterArgs->ids[i]) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static int filterByCapacity(umf_const_memspace_handle_t memspace,
+                            umf_const_memtarget_handle_t target, void *args) {
+    if (!memspace || !target || !args) {
+        return -UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    size_t capacity;
+    umf_result_t ret = umfMemtargetGetCapacity(target, &capacity);
+    if (ret != UMF_RESULT_SUCCESS) {
+        return -ret;
+    }
+
+    size_t *targetCapacity = args;
+    return (capacity >= *targetCapacity) ? 1 : 0;
+}
+
+umf_result_t umfMemspaceFilterById(umf_memspace_handle_t memspace,
+                                   unsigned *ids, size_t size) {
+    if (!memspace || !ids || size == 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    filter_by_id_args_t args = {ids, size};
+    int ret = umfMemspaceFilterHelper(memspace, &filterById, &args);
+
+    // if umfMemspaceFilter() returned negative umf_result_t change it to positive
+    return ret < 0 ? -ret : ret;
+}
+
+umf_result_t umfMemspaceFilterByCapacity(umf_memspace_handle_t memspace,
+                                         int64_t capacity) {
+    if (!memspace) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    // TODO: At this moment this function filters out memory targets that capacity is
+    // less than specified size. We can extend this function to support reverse filter,
+    // by using negative values of capacity parameter.
+    // For now we just return invalid argument.
+    if (capacity < 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    int ret = umfMemspaceFilterHelper(memspace, &filterByCapacity, &capacity);
+
+    // if umfMemspaceFilter() returned negative umf_result_t change it to positive
+    return ret < 0 ? -ret : ret;
+}
diff --git a/src/memspace_internal.h b/src/memspace_internal.h
index b570a7472..e31898e84 100644
--- a/src/memspace_internal.h
+++ b/src/memspace_internal.h
@@ -13,7 +13,7 @@
 #include <umf/memspace.h>
 
 #include "base_alloc.h"
-#include "memory_target.h"
+#include "memtarget_internal.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -21,16 +21,10 @@ extern "C" {
 
 struct umf_memspace_t {
     size_t size;
-    umf_memory_target_handle_t *nodes;
+    umf_memtarget_handle_t *nodes;
 };
 
-///
-/// \brief Clones memspace
-///
-umf_result_t umfMemspaceClone(umf_const_memspace_handle_t hMemspace,
-                              umf_memspace_handle_t *outHandle);
-
-typedef umf_result_t (*umfGetPropertyFn)(umf_memory_target_handle_t,
+typedef umf_result_t (*umfGetPropertyFn)(umf_const_memtarget_handle_t,
                                          uint64_t *);
 
 ///
@@ -39,10 +33,10 @@ typedef umf_result_t (*umfGetPropertyFn)(umf_memory_target_handle_t,
 umf_result_t umfMemspaceSortDesc(umf_memspace_handle_t hMemspace,
                                  umfGetPropertyFn getProperty);
 
-typedef umf_result_t (*umfGetTargetFn)(umf_memory_target_handle_t initiator,
-                                       umf_memory_target_handle_t *nodes,
+typedef umf_result_t (*umfGetTargetFn)(umf_memtarget_handle_t initiator,
+                                       umf_memtarget_handle_t *nodes,
                                        size_t numNodes,
-                                       umf_memory_target_handle_t *target);
+                                       umf_memtarget_handle_t *target);
 
 ///
 /// \brief Filters the targets using getTarget() to create a new memspace
diff --git a/src/memspaces/memspace_highest_bandwidth.c b/src/memspaces/memspace_highest_bandwidth.c
index d82e5f4f1..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
@@ -11,24 +11,38 @@
 #include <ctype.h>
 #include <stdlib.h>
 
+#include <umf.h>
+#include <umf/memspace.h>
+
+// UMF_MEMSPACE_HIGHEST_BANDWIDTH requires HWLOC
+// Additionally, it is currently unsupported on Win
+#if defined(_WIN32) || defined(UMF_NO_HWLOC)
+
+umf_const_memspace_handle_t umfMemspaceHighestBandwidthGet(void) {
+    // not supported
+    return NULL;
+}
+
+#else // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+
 #include "base_alloc_global.h"
-#include "memory_target_numa.h"
 #include "memspace_internal.h"
+#include "memtarget_numa.h"
 #include "topology.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
 #include "utils_log.h"
 
-static umf_result_t getBestBandwidthTarget(umf_memory_target_handle_t initiator,
-                                           umf_memory_target_handle_t *nodes,
+static umf_result_t getBestBandwidthTarget(umf_memtarget_handle_t initiator,
+                                           umf_memtarget_handle_t *nodes,
                                            size_t numNodes,
-                                           umf_memory_target_handle_t *target) {
+                                           umf_memtarget_handle_t *target) {
     size_t bestNodeIdx = 0;
     size_t bestBandwidth = 0;
     for (size_t nodeIdx = 0; nodeIdx < numNodes; nodeIdx++) {
         size_t bandwidth = 0;
         umf_result_t ret =
-            umfMemoryTargetGetBandwidth(initiator, nodes[nodeIdx], &bandwidth);
+            umfMemtargetGetBandwidth(initiator, nodes[nodeIdx], &bandwidth);
         if (ret) {
             return ret;
         }
@@ -88,15 +102,21 @@ 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);
+        }
     }
 }
 
 umf_const_memspace_handle_t umfMemspaceHighestBandwidthGet(void) {
-    util_init_once(&UMF_MEMSPACE_HBW_INITIALIZED,
-                   umfMemspaceHighestBandwidthInit);
+    utils_init_once(&UMF_MEMSPACE_HBW_INITIALIZED,
+                    umfMemspaceHighestBandwidthInit);
     return UMF_MEMSPACE_HIGHEST_BANDWIDTH;
 }
+
+#endif // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
diff --git a/src/memspaces/memspace_highest_capacity.c b/src/memspaces/memspace_highest_capacity.c
index 0b8f3522e..4a195316a 100644
--- a/src/memspaces/memspace_highest_capacity.c
+++ b/src/memspaces/memspace_highest_capacity.c
@@ -10,9 +10,23 @@
 #include <assert.h>
 #include <stdlib.h>
 
+#include <umf.h>
+#include <umf/memspace.h>
+
+// UMF_MEMSPACE_HIGHEST_CAPACITY requires HWLOC
+// Additionally, it is currently unsupported on Win
+#if defined(_WIN32) || defined(UMF_NO_HWLOC)
+
+umf_const_memspace_handle_t umfMemspaceHighestCapacityGet(void) {
+    // not supported
+    return NULL;
+}
+
+#else // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+
 #include "base_alloc_global.h"
-#include "memory_target_numa.h"
 #include "memspace_internal.h"
+#include "memtarget_numa.h"
 #include "topology.h"
 #include "utils_concurrency.h"
 
@@ -34,7 +48,7 @@ umfMemspaceHighestCapacityCreate(umf_memspace_handle_t *hMemspace) {
     }
 
     ret = umfMemspaceSortDesc(highCapacityMemspace,
-                              (umfGetPropertyFn)&umfMemoryTargetGetCapacity);
+                              (umfGetPropertyFn)&umfMemtargetGetCapacity);
     if (ret != UMF_RESULT_SUCCESS) {
         return ret;
     }
@@ -68,7 +82,9 @@ static void umfMemspaceHighestCapacityInit(void) {
 }
 
 umf_const_memspace_handle_t umfMemspaceHighestCapacityGet(void) {
-    util_init_once(&UMF_MEMSPACE_HIGHEST_CAPACITY_INITIALIZED,
-                   umfMemspaceHighestCapacityInit);
+    utils_init_once(&UMF_MEMSPACE_HIGHEST_CAPACITY_INITIALIZED,
+                    umfMemspaceHighestCapacityInit);
     return UMF_MEMSPACE_HIGHEST_CAPACITY;
 }
+
+#endif // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
diff --git a/src/memspaces/memspace_host_all.c b/src/memspaces/memspace_host_all.c
index 62c968743..4b7db69d4 100644
--- a/src/memspaces/memspace_host_all.c
+++ b/src/memspaces/memspace_host_all.c
@@ -10,9 +10,23 @@
 #include <assert.h>
 #include <stdlib.h>
 
+#include <umf.h>
+#include <umf/memspace.h>
+
+// UMF_MEMSPACE_HOST_ALL requires HWLOC
+// Additionally, it is currently unsupported on Win
+
+#if defined(_WIN32) || defined(UMF_NO_HWLOC)
+umf_const_memspace_handle_t umfMemspaceHostAllGet(void) {
+    // not supported
+    return NULL;
+}
+
+#else // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+
 #include "base_alloc_global.h"
-#include "memory_target_numa.h"
 #include "memspace_internal.h"
+#include "memtarget_numa.h"
 #include "topology.h"
 #include "utils_concurrency.h"
 
@@ -90,6 +104,8 @@ static void umfMemspaceHostAllInit(void) {
 }
 
 umf_const_memspace_handle_t umfMemspaceHostAllGet(void) {
-    util_init_once(&UMF_MEMSPACE_HOST_ALL_INITIALIZED, umfMemspaceHostAllInit);
+    utils_init_once(&UMF_MEMSPACE_HOST_ALL_INITIALIZED, umfMemspaceHostAllInit);
     return UMF_MEMSPACE_HOST_ALL;
 }
+
+#endif // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
diff --git a/src/memspaces/memspace_lowest_latency.c b/src/memspaces/memspace_lowest_latency.c
index 2c6656ab2..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
@@ -11,24 +11,38 @@
 #include <ctype.h>
 #include <stdlib.h>
 
+#include <umf.h>
+#include <umf/memspace.h>
+
+// UMF_MEMSPACE_LOWEST_LATENCY requires HWLOC
+// Additionally, it is currently unsupported on Win
+#if defined(_WIN32) || defined(UMF_NO_HWLOC)
+
+umf_const_memspace_handle_t umfMemspaceLowestLatencyGet(void) {
+    // not supported
+    return NULL;
+}
+
+#else // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+
 #include "base_alloc_global.h"
-#include "memory_target_numa.h"
 #include "memspace_internal.h"
+#include "memtarget_numa.h"
 #include "topology.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
 #include "utils_log.h"
 
-static umf_result_t getBestLatencyTarget(umf_memory_target_handle_t initiator,
-                                         umf_memory_target_handle_t *nodes,
+static umf_result_t getBestLatencyTarget(umf_memtarget_handle_t initiator,
+                                         umf_memtarget_handle_t *nodes,
                                          size_t numNodes,
-                                         umf_memory_target_handle_t *target) {
+                                         umf_memtarget_handle_t *target) {
     size_t bestNodeIdx = 0;
     size_t bestLatency = SIZE_MAX;
     for (size_t nodeIdx = 0; nodeIdx < numNodes; nodeIdx++) {
         size_t latency = SIZE_MAX;
         umf_result_t ret =
-            umfMemoryTargetGetLatency(initiator, nodes[nodeIdx], &latency);
+            umfMemtargetGetLatency(initiator, nodes[nodeIdx], &latency);
         if (ret) {
             return ret;
         }
@@ -84,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)
@@ -96,7 +114,9 @@ static void umfMemspaceLowestLatencyInit(void) {
 }
 
 umf_const_memspace_handle_t umfMemspaceLowestLatencyGet(void) {
-    util_init_once(&UMF_MEMSPACE_LOWEST_LATENCY_INITIALIZED,
-                   umfMemspaceLowestLatencyInit);
+    utils_init_once(&UMF_MEMSPACE_LOWEST_LATENCY_INITIALIZED,
+                    umfMemspaceLowestLatencyInit);
     return UMF_MEMSPACE_LOWEST_LATENCY;
 }
+
+#endif // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
diff --git a/src/memspaces/memspace_numa.c b/src/memspaces/memspace_numa.c
index 52dc85b64..83e65fc29 100644
--- a/src/memspaces/memspace_numa.c
+++ b/src/memspaces/memspace_numa.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -9,8 +9,26 @@
 
 #include <stdlib.h>
 
-#include "../memory_targets/memory_target_numa.h"
+#include <umf.h>
+#include <umf/memspace.h>
+
+// umfMemspaceCreateFromNumaArray requires HWLOC
+// Additionally, it is currently unsupported on Win
+#if defined(_WIN32) || defined(UMF_NO_HWLOC)
+umf_result_t umfMemspaceCreateFromNumaArray(unsigned *nodeIds, size_t numIds,
+                                            umf_memspace_handle_t *hMemspace) {
+    (void)nodeIds;
+    (void)numIds;
+    (void)hMemspace;
+
+    // not supported
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+#else // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+
 #include "../memspace_internal.h"
+#include "../memtargets/memtarget_numa.h"
 #include "base_alloc_global.h"
 
 umf_result_t umfMemspaceCreateFromNumaArray(unsigned *nodeIds, size_t numIds,
@@ -27,8 +45,8 @@ umf_result_t umfMemspaceCreateFromNumaArray(unsigned *nodeIds, size_t numIds,
     }
 
     memspace->size = numIds;
-    memspace->nodes = umf_ba_global_alloc(memspace->size *
-                                          sizeof(umf_memory_target_handle_t));
+    memspace->nodes =
+        umf_ba_global_alloc(memspace->size * sizeof(umf_memtarget_handle_t));
     if (!memspace->nodes) {
         ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
         goto err_nodes_alloc;
@@ -36,9 +54,9 @@ umf_result_t umfMemspaceCreateFromNumaArray(unsigned *nodeIds, size_t numIds,
 
     size_t nodeIdx;
     for (nodeIdx = 0; nodeIdx < numIds; nodeIdx++) {
-        struct umf_numa_memory_target_config_t config = {nodeIds[nodeIdx]};
-        ret = umfMemoryTargetCreate(&UMF_MEMORY_TARGET_NUMA_OPS, &config,
-                                    &memspace->nodes[nodeIdx]);
+        struct umf_numa_memtarget_config_t config = {nodeIds[nodeIdx]};
+        ret = umfMemtargetCreate(&UMF_MEMTARGET_NUMA_OPS, &config,
+                                 &memspace->nodes[nodeIdx]);
         if (ret) {
             goto err_target_create;
         }
@@ -51,9 +69,11 @@ umf_result_t umfMemspaceCreateFromNumaArray(unsigned *nodeIds, size_t numIds,
 err_target_create:
     umf_ba_global_free(memspace->nodes);
     for (size_t i = 0; i < nodeIdx; i++) {
-        umfMemoryTargetDestroy(memspace->nodes[i]);
+        umfMemtargetDestroy(memspace->nodes[i]);
     }
 err_nodes_alloc:
     umf_ba_global_free(memspace);
     return ret;
 }
+
+#endif // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
diff --git a/src/memtarget.c b/src/memtarget.c
new file mode 100644
index 000000000..8eb6e4e8c
--- /dev/null
+++ b/src/memtarget.c
@@ -0,0 +1,161 @@
+/*
+ *
+ * Copyright (C) 2023-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include "base_alloc_global.h"
+#include "libumf.h"
+#include "memtarget_internal.h"
+#include "memtarget_ops.h"
+#include "utils_concurrency.h"
+#include "utils_log.h"
+
+umf_result_t umfMemtargetCreate(const umf_memtarget_ops_t *ops, void *params,
+                                umf_memtarget_handle_t *memoryTarget) {
+    libumfInit();
+    if (!ops || !memoryTarget) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_memtarget_handle_t target =
+        umf_ba_global_alloc(sizeof(umf_memtarget_t));
+    if (!target) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    if (ops->version != UMF_MEMTARGET_OPS_VERSION_CURRENT) {
+        LOG_WARN("Memtarget ops version \"%d\" is different than the current "
+                 "version \"%d\"",
+                 ops->version, UMF_MEMTARGET_OPS_VERSION_CURRENT);
+    }
+
+    target->ops = ops;
+
+    void *target_priv;
+    umf_result_t ret = ops->initialize(params, &target_priv);
+    if (ret != UMF_RESULT_SUCCESS) {
+        umf_ba_global_free(target);
+        return ret;
+    }
+
+    target->priv = target_priv;
+
+    *memoryTarget = target;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+void umfMemtargetDestroy(umf_memtarget_handle_t memoryTarget) {
+    assert(memoryTarget);
+    memoryTarget->ops->finalize(memoryTarget->priv);
+    umf_ba_global_free(memoryTarget);
+}
+
+umf_result_t umfMemtargetClone(umf_const_memtarget_handle_t memoryTarget,
+                               umf_memtarget_handle_t *outHandle) {
+    assert(memoryTarget);
+    assert(outHandle);
+
+    *outHandle = umf_ba_global_alloc(sizeof(umf_memtarget_t));
+    if (!*outHandle) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    void *outPriv;
+    umf_result_t ret = memoryTarget->ops->clone(memoryTarget->priv, &outPriv);
+    if (ret != UMF_RESULT_SUCCESS) {
+        umf_ba_global_free(*outHandle);
+        return ret;
+    }
+
+    (*outHandle)->ops = memoryTarget->ops;
+    (*outHandle)->priv = outPriv;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfMemtargetGetCapacity(umf_const_memtarget_handle_t memoryTarget,
+                                     size_t *capacity) {
+    if (!memoryTarget || !capacity) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    return memoryTarget->ops->get_capacity(memoryTarget->priv, capacity);
+}
+
+umf_result_t umfMemtargetGetBandwidth(umf_memtarget_handle_t srcMemoryTarget,
+                                      umf_memtarget_handle_t dstMemoryTarget,
+                                      size_t *bandwidth) {
+    if (!srcMemoryTarget || !dstMemoryTarget || !bandwidth) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    return srcMemoryTarget->ops->get_bandwidth(
+        srcMemoryTarget->priv, dstMemoryTarget->priv, bandwidth);
+}
+
+umf_result_t umfMemtargetGetLatency(umf_memtarget_handle_t srcMemoryTarget,
+                                    umf_memtarget_handle_t dstMemoryTarget,
+                                    size_t *latency) {
+    if (!srcMemoryTarget || !dstMemoryTarget || !latency) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    return srcMemoryTarget->ops->get_latency(srcMemoryTarget->priv,
+                                             dstMemoryTarget->priv, latency);
+}
+
+umf_result_t umfMemtargetGetId(umf_const_memtarget_handle_t hMemtarget,
+                               unsigned *id) {
+    if (!hMemtarget || !id) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    return hMemtarget->ops->get_id(hMemtarget->priv, id);
+}
+
+umf_result_t umfMemtargetGetType(umf_const_memtarget_handle_t memoryTarget,
+                                 umf_memtarget_type_t *type) {
+    if (!memoryTarget || !type) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    return memoryTarget->ops->get_type(memoryTarget->priv, type);
+}
+
+umf_result_t umfMemtargetCompare(umf_const_memtarget_handle_t a,
+                                 umf_const_memtarget_handle_t b, int *result) {
+    umf_memtarget_type_t typeA, typeB;
+    umf_result_t ret = umfMemtargetGetType(a, &typeA);
+    if (ret != UMF_RESULT_SUCCESS) {
+        return ret;
+    }
+
+    ret = umfMemtargetGetType(b, &typeB);
+    if (ret != UMF_RESULT_SUCCESS) {
+        return ret;
+    }
+
+    if (typeA != typeB) {
+        *result = -1;
+        return UMF_RESULT_SUCCESS;
+    }
+
+    ret = a->ops->compare(a->priv, b->priv, result);
+    if (ret != UMF_RESULT_SUCCESS) {
+        return ret;
+    }
+
+    if (*result) {
+        *result = 1;
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
diff --git a/src/memtarget_internal.h b/src/memtarget_internal.h
new file mode 100644
index 000000000..85ec99b8e
--- /dev/null
+++ b/src/memtarget_internal.h
@@ -0,0 +1,48 @@
+/*
+ *
+ * Copyright (C) 2023-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+#ifndef UMF_MEMTARGET_INTERNAL_H
+#define UMF_MEMTARGET_INTERNAL_H 1
+
+#include <umf/base.h>
+#include <umf/memtarget.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct umf_memtarget_ops_t umf_memtarget_ops_t;
+
+typedef struct umf_memtarget_t {
+    const umf_memtarget_ops_t *ops;
+    void *priv;
+} umf_memtarget_t;
+
+umf_result_t umfMemtargetCreate(const umf_memtarget_ops_t *ops, void *params,
+                                umf_memtarget_handle_t *memoryTarget);
+void umfMemtargetDestroy(umf_memtarget_handle_t memoryTarget);
+
+umf_result_t umfMemtargetClone(umf_const_memtarget_handle_t memoryTarget,
+                               umf_memtarget_handle_t *outHandle);
+
+umf_result_t umfMemtargetGetBandwidth(umf_memtarget_handle_t srcMemoryTarget,
+                                      umf_memtarget_handle_t dstMemoryTarget,
+                                      size_t *bandwidth);
+umf_result_t umfMemtargetGetLatency(umf_memtarget_handle_t srcMemoryTarget,
+                                    umf_memtarget_handle_t dstMemoryTarget,
+                                    size_t *latency);
+
+/// return 0 if memtargets are equal, -1 if they are of different types,
+/// and 1 if they are different targets of the same type
+umf_result_t umfMemtargetCompare(umf_const_memtarget_handle_t a,
+                                 umf_const_memtarget_handle_t b, int *result);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_MEMTARGET_INTERNAL_H */
diff --git a/src/memory_target_ops.h b/src/memtarget_ops.h
similarity index 64%
rename from src/memory_target_ops.h
rename to src/memtarget_ops.h
index 24e4e8108..4bd9bb899 100644
--- a/src/memory_target_ops.h
+++ b/src/memtarget_ops.h
@@ -1,27 +1,31 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  */
 
-#ifndef UMF_MEMORY_TARGET_OPS_H
-#define UMF_MEMORY_TARGET_OPS_H 1
+#ifndef UMF_MEMTARGET_OPS_H
+#define UMF_MEMTARGET_OPS_H 1
 
 #include <umf/base.h>
 #include <umf/memspace.h>
+#include <umf/memtarget.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef struct umf_memory_target_t *umf_memory_target_handle_t;
+// Version of the Memtarget ops structure.
+// NOTE: This is equal to the latest UMF version, in which the ops structure
+// has been modified.
+#define UMF_MEMTARGET_OPS_VERSION_CURRENT UMF_MAKE_VERSION(0, 11)
 
-typedef struct umf_memory_target_ops_t {
+typedef struct umf_memtarget_ops_t {
     /// Version of the ops structure.
-    /// Should be initialized using UMF_VERSION_CURRENT
+    /// Should be initialized using UMF_MEMTARGET_OPS_VERSION_CURRENT
     uint32_t version;
 
     umf_result_t (*initialize)(void *params, void **memoryTarget);
@@ -44,10 +48,15 @@ typedef struct umf_memory_target_ops_t {
                                   size_t *bandwidth);
     umf_result_t (*get_latency)(void *srcMemoryTarget, void *dstMemoryTarget,
                                 size_t *latency);
-} umf_memory_target_ops_t;
+
+    umf_result_t (*get_type)(void *memoryTarget, umf_memtarget_type_t *type);
+    umf_result_t (*get_id)(void *memoryTarget, unsigned *type);
+    umf_result_t (*compare)(void *memTarget, void *otherMemTarget, int *result);
+
+} umf_memtarget_ops_t;
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* #ifndef UMF_MEMORY_TARGET_OPS_H */
+#endif /* #ifndef UMF_MEMTARGET_OPS_H */
diff --git a/src/memory_targets/memory_target_numa.c b/src/memtargets/memtarget_numa.c
similarity index 61%
rename from src/memory_targets/memory_target_numa.c
rename to src/memtargets/memtarget_numa.c
index aa33a1853..a0a1e592a 100644
--- a/src/memory_targets/memory_target_numa.c
+++ b/src/memtargets/memtarget_numa.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -16,13 +16,13 @@
 #include "../memory_pool_internal.h"
 #include "base_alloc.h"
 #include "base_alloc_global.h"
-#include "memory_target_numa.h"
 #include "mempolicy_internal.h"
+#include "memtarget_numa.h"
 #include "topology.h"
 #include "utils_assert.h"
 #include "utils_log.h"
 
-struct numa_memory_target_t {
+struct numa_memtarget_t {
     unsigned physical_id;
 };
 
@@ -31,16 +31,16 @@ static umf_result_t numa_initialize(void *params, void **memTarget) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    struct umf_numa_memory_target_config_t *config =
-        (struct umf_numa_memory_target_config_t *)params;
+    struct umf_numa_memtarget_config_t *config =
+        (struct umf_numa_memtarget_config_t *)params;
 
-    struct numa_memory_target_t *numaTarget =
-        umf_ba_global_alloc(sizeof(struct numa_memory_target_t));
+    struct numa_memtarget_t *numaTarget =
+        umf_ba_global_alloc(sizeof(struct numa_memtarget_t));
     if (!numaTarget) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    numaTarget->physical_id = config->physical_id;
+    numaTarget->physical_id = (unsigned)config->physical_id;
     *memTarget = numaTarget;
     return UMF_RESULT_SUCCESS;
 }
@@ -52,8 +52,8 @@ static umf_result_t numa_memory_provider_create_from_memspace(
     umf_const_mempolicy_handle_t policy,
     umf_memory_provider_handle_t *provider) {
 
-    struct numa_memory_target_t **numaTargets =
-        (struct numa_memory_target_t **)memTargets;
+    struct numa_memtarget_t **numaTargets =
+        (struct numa_memtarget_t **)memTargets;
 
     size_t numNodesProvider;
 
@@ -69,22 +69,27 @@ static umf_result_t numa_memory_provider_create_from_memspace(
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    umf_os_memory_provider_params_t params = umfOsMemoryProviderParamsDefault();
+    umf_numa_mode_t numa_mode = UMF_NUMA_MODE_DEFAULT;
+    size_t part_size = 0;
+    umf_numa_split_partition_t *partitions = NULL;
+    unsigned partitions_len = 0;
+    unsigned *numa_list = NULL;
+    unsigned numa_list_len = 0;
 
     if (policy) {
         switch (policy->type) {
         case UMF_MEMPOLICY_INTERLEAVE:
-            params.numa_mode = UMF_NUMA_MODE_INTERLEAVE;
-            params.part_size = policy->ops.interleave.part_size;
+            numa_mode = UMF_NUMA_MODE_INTERLEAVE;
+            part_size = policy->ops.interleave.part_size;
             break;
         case UMF_MEMPOLICY_BIND:
-            params.numa_mode = UMF_NUMA_MODE_BIND;
+            numa_mode = UMF_NUMA_MODE_BIND;
             break;
         case UMF_MEMPOLICY_PREFERRED:
-            params.numa_mode = UMF_NUMA_MODE_PREFERRED;
+            numa_mode = UMF_NUMA_MODE_PREFERRED;
             break;
         case UMF_MEMPOLICY_SPLIT:
-            params.numa_mode = UMF_NUMA_MODE_SPLIT;
+            numa_mode = UMF_NUMA_MODE_SPLIT;
 
             // compile time check to ensure we can just cast
             // umf_mempolicy_split_partition_t to
@@ -98,9 +103,8 @@ static umf_result_t numa_memory_provider_create_from_memspace(
                 offsetof(umf_mempolicy_split_partition_t, target) !=
                 offsetof(umf_numa_split_partition_t, target));
 
-            params.partitions =
-                (umf_numa_split_partition_t *)policy->ops.split.part;
-            params.partitions_len = policy->ops.split.part_len;
+            partitions = (umf_numa_split_partition_t *)policy->ops.split.part;
+            partitions_len = (unsigned)policy->ops.split.part_len;
             break;
         default:
             return UMF_RESULT_ERROR_INVALID_ARGUMENT;
@@ -109,44 +113,80 @@ static umf_result_t numa_memory_provider_create_from_memspace(
         if (memspace == umfMemspaceHostAllGet()) {
             // For the default memspace, we use the default mode without any
             // call to mbind
-            params.numa_mode = UMF_NUMA_MODE_DEFAULT;
+            numa_mode = UMF_NUMA_MODE_DEFAULT;
         } else {
-            params.numa_mode = UMF_NUMA_MODE_BIND;
+            numa_mode = UMF_NUMA_MODE_BIND;
         }
     }
 
     if (memspace == umfMemspaceHostAllGet() && policy == NULL) {
         // For default memspace with default policy we use all numa nodes so
         // simply left numa list empty
-        params.numa_list_len = 0;
-        params.numa_list = NULL;
+        numa_list_len = 0;
+        numa_list = NULL;
     } else {
-        params.numa_list =
-            umf_ba_global_alloc(sizeof(*params.numa_list) * numNodesProvider);
+        numa_list = umf_ba_global_alloc(sizeof(*numa_list) * numNodesProvider);
 
-        if (!params.numa_list) {
+        if (!numa_list) {
             return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
         }
 
         for (size_t i = 0; i < numNodesProvider; i++) {
-            params.numa_list[i] = numaTargets[i]->physical_id;
+            numa_list[i] = numaTargets[i]->physical_id;
         }
-        params.numa_list_len = numNodesProvider;
+        numa_list_len = (unsigned)numNodesProvider;
     }
 
-    umf_memory_provider_handle_t numaProvider = NULL;
-    int ret = umfMemoryProviderCreate(umfOsMemoryProviderOps(), &params,
-                                      &numaProvider);
+    umf_os_memory_provider_params_handle_t params = NULL;
+    umf_result_t ret = umfOsMemoryProviderParamsCreate(&params);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Creating OS memory provider params failed");
+        goto destroy_numa_list;
+    }
 
-    umf_ba_global_free(params.numa_list);
+    ret = umfOsMemoryProviderParamsSetNumaMode(params, numa_mode);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Setting NUMA mode failed");
+        goto destroy_provider_params;
+    }
 
-    if (ret) {
-        return ret;
+    ret =
+        umfOsMemoryProviderParamsSetNumaList(params, numa_list, numa_list_len);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Setting NUMA list failed");
+        goto destroy_provider_params;
+    }
+
+    ret = umfOsMemoryProviderParamsSetPartitions(params, partitions,
+                                                 partitions_len);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Setting partitions failed");
+        goto destroy_provider_params;
+    }
+
+    ret = umfOsMemoryProviderParamsSetPartSize(params, part_size);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Setting part size failed");
+        goto destroy_provider_params;
+    }
+
+    umf_memory_provider_handle_t numaProvider = NULL;
+    ret = umfMemoryProviderCreate(umfOsMemoryProviderOps(), params,
+                                  &numaProvider);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Creating OS memory provider failed");
+        goto destroy_provider_params;
     }
 
     *provider = numaProvider;
 
-    return UMF_RESULT_SUCCESS;
+destroy_provider_params:
+    umfOsMemoryProviderParamsDestroy(params);
+
+destroy_numa_list:
+    umf_ba_global_free(numa_list);
+
+    return ret;
 }
 
 static umf_result_t numa_pool_create_from_memspace(
@@ -161,10 +201,9 @@ static umf_result_t numa_pool_create_from_memspace(
 }
 
 static umf_result_t numa_clone(void *memTarget, void **outMemTarget) {
-    struct numa_memory_target_t *numaTarget =
-        (struct numa_memory_target_t *)memTarget;
-    struct numa_memory_target_t *newNumaTarget =
-        umf_ba_global_alloc(sizeof(struct numa_memory_target_t));
+    struct numa_memtarget_t *numaTarget = (struct numa_memtarget_t *)memTarget;
+    struct numa_memtarget_t *newNumaTarget =
+        umf_ba_global_alloc(sizeof(struct numa_memtarget_t));
     if (!newNumaTarget) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
@@ -185,7 +224,7 @@ static umf_result_t numa_get_capacity(void *memTarget, size_t *capacity) {
     }
 
     hwloc_obj_t numaNode = hwloc_get_numanode_obj_by_os_index(
-        topology, ((struct numa_memory_target_t *)memTarget)->physical_id);
+        topology, ((struct numa_memtarget_t *)memTarget)->physical_id);
     if (!numaNode) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
@@ -224,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_memory_target_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_memory_target_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;
@@ -270,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;
     }
@@ -291,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_memory_target_t *)srcMemoryTarget)->physical_id,
-                ((struct numa_memory_target_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;
     }
 
@@ -309,17 +347,49 @@ 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_memory_target_t *)srcMemoryTarget)->physical_id,
-                ((struct numa_memory_target_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;
     }
 
     return UMF_RESULT_SUCCESS;
 }
 
-struct umf_memory_target_ops_t UMF_MEMORY_TARGET_NUMA_OPS = {
-    .version = UMF_VERSION_CURRENT,
+static umf_result_t numa_get_type(void *memTarget, umf_memtarget_type_t *type) {
+    if (!memTarget || !type) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    *type = UMF_MEMTARGET_TYPE_NUMA;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t numa_get_id(void *memTarget, unsigned *id) {
+    if (!memTarget || !id) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    *id = ((struct numa_memtarget_t *)memTarget)->physical_id;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t numa_compare(void *memTarget, void *otherMemTarget,
+                                 int *result) {
+    if (!memTarget || !otherMemTarget || !result) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    struct numa_memtarget_t *numaTarget = (struct numa_memtarget_t *)memTarget;
+    struct numa_memtarget_t *otherNumaTarget =
+        (struct numa_memtarget_t *)otherMemTarget;
+
+    *result = numaTarget->physical_id != otherNumaTarget->physical_id;
+    return UMF_RESULT_SUCCESS;
+}
+
+struct umf_memtarget_ops_t UMF_MEMTARGET_NUMA_OPS = {
+    .version = UMF_MEMTARGET_OPS_VERSION_CURRENT,
     .initialize = numa_initialize,
     .finalize = numa_finalize,
     .pool_create_from_memspace = numa_pool_create_from_memspace,
@@ -327,5 +397,8 @@ struct umf_memory_target_ops_t UMF_MEMORY_TARGET_NUMA_OPS = {
     .get_capacity = numa_get_capacity,
     .get_bandwidth = numa_get_bandwidth,
     .get_latency = numa_get_latency,
+    .get_type = numa_get_type,
+    .get_id = numa_get_id,
+    .compare = numa_compare,
     .memory_provider_create_from_memspace =
         numa_memory_provider_create_from_memspace};
diff --git a/src/memtargets/memtarget_numa.h b/src/memtargets/memtarget_numa.h
new file mode 100644
index 000000000..6659d045e
--- /dev/null
+++ b/src/memtargets/memtarget_numa.h
@@ -0,0 +1,33 @@
+/*
+ *
+ * Copyright (C) 2023-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+#ifndef UMF_MEMTARGET_NUMA_H
+#define UMF_MEMTARGET_NUMA_H 1
+
+#include <umf.h>
+#include <umf/memspace.h>
+
+#include "../memtarget_internal.h"
+#include "../memtarget_ops.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct umf_numa_memtarget_config_t {
+    size_t physical_id;
+};
+
+extern struct umf_memtarget_ops_t UMF_MEMTARGET_NUMA_OPS;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_MEMTARGET_NUMA_H */
diff --git a/src/pool/CMakeLists.txt b/src/pool/CMakeLists.txt
deleted file mode 100644
index bdd196b04..000000000
--- a/src/pool/CMakeLists.txt
+++ /dev/null
@@ -1,54 +0,0 @@
-# Copyright (C) 2023 Intel Corporation
-# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-if(UMF_BUILD_SHARED_LIBRARY)
-    set(POOL_EXTRA_SRCS ${BA_SOURCES})
-    set(POOL_EXTRA_LIBS $<BUILD_INTERFACE:umf_utils>)
-endif()
-
-set(POOL_COMPILE_DEFINITIONS ${UMF_COMMON_COMPILE_DEFINITIONS})
-
-# libumf_pool_disjoint
-if(UMF_BUILD_LIBUMF_POOL_DISJOINT)
-    add_umf_library(
-        NAME disjoint_pool
-        TYPE STATIC
-        SRCS pool_disjoint.cpp ${POOL_EXTRA_SRCS}
-        LIBS ${POOL_EXTRA_LIBS})
-
-    target_compile_definitions(disjoint_pool
-                               PRIVATE ${POOL_COMPILE_DEFINITIONS})
-
-    if(WINDOWS)
-        target_compile_options(disjoint_pool PRIVATE /DWIN32_LEAN_AND_MEAN
-                                                     /DNOMINMAX)
-    endif()
-
-    add_library(${PROJECT_NAME}::disjoint_pool ALIAS disjoint_pool)
-
-    add_dependencies(disjoint_pool umf)
-
-    target_link_libraries(disjoint_pool PRIVATE umf)
-
-    target_include_directories(
-        disjoint_pool
-        PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include/umf/pools>
-               $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
-
-    install(TARGETS disjoint_pool EXPORT ${PROJECT_NAME}-targets)
-endif()
-
-# libumf_pool_jemalloc
-if(UMF_BUILD_LIBUMF_POOL_JEMALLOC)
-    add_umf_library(
-        NAME jemalloc_pool
-        TYPE STATIC
-        SRCS pool_jemalloc.c ${POOL_EXTRA_SRCS}
-        LIBS jemalloc ${POOL_EXTRA_LIBS})
-    target_include_directories(jemalloc_pool PRIVATE ${JEMALLOC_INCLUDE_DIRS})
-    target_compile_definitions(jemalloc_pool
-                               PRIVATE ${POOL_COMPILE_DEFINITIONS})
-    add_library(${PROJECT_NAME}::jemalloc_pool ALIAS jemalloc_pool)
-    install(TARGETS jemalloc_pool EXPORT ${PROJECT_NAME}-targets)
-endif()
diff --git a/src/pool/pool_disjoint.c b/src/pool/pool_disjoint.c
new file mode 100644
index 000000000..ca5e483f5
--- /dev/null
+++ b/src/pool/pool_disjoint.c
@@ -0,0 +1,1200 @@
+/*
+ * Copyright (C) 2022-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <umf/base.h>
+#include <umf/memory_pool.h>
+#include <umf/memory_pool_ops.h>
+#include <umf/memory_provider.h>
+
+#include "base_alloc_global.h"
+#include "ctl/ctl.h"
+#include "pool_disjoint_internal.h"
+#include "provider/provider_tracking.h"
+#include "uthash/utlist.h"
+#include "utils_common.h"
+#include "utils_concurrency.h"
+#include "utils_log.h"
+#include "utils_math.h"
+
+static 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;
+    }
+
+    if (size > 0) {
+        strncpy((char *)arg, pool->params.name, size - 1);
+        ((char *)arg)[size - 1] = '\0';
+    }
+    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);
+    pool->params.name[sizeof(pool->params.name) - 1] = '\0';
+    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
+#ifndef POISON_MEMORY
+#undef __SANITIZE_ADDRESS__
+#endif
+#include "utils_sanitizers.h"
+
+// Forward declarations
+static void bucket_update_stats(bucket_t *bucket, int in_use, int in_pool);
+static bool bucket_can_pool(bucket_t *bucket);
+static slab_list_item_t *bucket_get_avail_slab(bucket_t *bucket,
+                                               bool *from_pool);
+
+static __TLS umf_result_t TLS_last_allocation_error;
+
+// Allocations are a minimum of 4KB/64KB/2MB even when a smaller size is
+// requested. The implementation distinguishes between allocations of size
+// ChunkCutOff = (minimum-alloc-size / 2) and those that are larger.
+// Allocation requests smaller than ChunkCutoff use chunks taken from a single
+// coarse-grain allocation. Thus, for example, for a 64KB minimum allocation
+// size, and 8-byte allocations, only 1 in ~8000 requests results in a new
+// coarse-grain allocation. Freeing results only in a chunk of a larger
+// allocation to be marked as available and no real return to the system. An
+// allocation is returned to the system only when all chunks in the larger
+// allocation are freed by the program. Allocations larger than ChunkCutOff use
+// a separate coarse-grain allocation for each request. These are subject to
+// "pooling". That is, when such an allocation is freed by the program it is
+// retained in a pool. The pool is available for future allocations, which means
+// there are fewer actual coarse-grain allocations/deallocations.
+
+// The largest size which is allocated via the allocator.
+// Allocations with size > CutOff bypass the pool and
+// go directly to the provider.
+static const size_t CutOff = (size_t)1 << 31; // 2GB
+
+static size_t bucket_slab_min_size(bucket_t *bucket) {
+    return bucket->pool->params.slab_min_size;
+}
+
+static size_t bucket_slab_alloc_size(bucket_t *bucket) {
+    return utils_max(bucket->size, bucket_slab_min_size(bucket));
+}
+
+static slab_t *create_slab(bucket_t *bucket) {
+    assert(bucket);
+
+    umf_result_t res = UMF_RESULT_SUCCESS;
+    umf_memory_provider_handle_t provider = bucket->pool->provider;
+
+    size_t num_chunks_total =
+        utils_max(bucket_slab_min_size(bucket) / bucket->size, 1);
+
+    // Calculate the number of 64-bit words needed.
+    size_t num_words =
+        (num_chunks_total + CHUNK_BITMAP_SIZE - 1) / CHUNK_BITMAP_SIZE;
+
+    slab_t *slab = umf_ba_global_alloc(sizeof(*slab) +
+                                       num_words * sizeof(slab->chunks[0]));
+    if (slab == NULL) {
+        LOG_ERR("allocation of new slab failed!");
+        return NULL;
+    }
+
+    slab->num_chunks_allocated = 0;
+    slab->bucket = bucket;
+
+    slab->iter.val = slab;
+    slab->iter.prev = slab->iter.next = NULL;
+
+    slab->num_chunks_total = num_chunks_total;
+    slab->num_words = num_words;
+
+    // set all chunks as free
+    memset(slab->chunks, ~0, num_words * sizeof(slab->chunks[0]));
+    if (num_chunks_total % CHUNK_BITMAP_SIZE) {
+        // clear remaining bits
+        slab->chunks[num_words - 1] =
+            ((1ULL << (num_chunks_total % CHUNK_BITMAP_SIZE)) - 1);
+    }
+
+    // if slab_min_size is not a multiple of bucket size, we would have some
+    // padding at the end of the slab
+    slab->slab_size = bucket_slab_alloc_size(bucket);
+
+    // TODO not true
+    // NOTE: originally slabs memory were allocated without alignment
+    // with this registering a slab is simpler and doesn't require multimap
+    res = umfMemoryProviderAlloc(provider, slab->slab_size, 0, &slab->mem_ptr);
+    if (res != UMF_RESULT_SUCCESS) {
+        LOG_ERR("allocation of slab data failed!");
+        goto free_slab;
+    }
+
+    // raw allocation is not available for user so mark it as inaccessible
+    utils_annotate_memory_inaccessible(slab->mem_ptr, slab->slab_size);
+
+    LOG_DEBUG("bucket: %p, slab_size: %zu", (void *)bucket, slab->slab_size);
+    return slab;
+
+free_slab:
+    umf_ba_global_free(slab);
+    return NULL;
+}
+
+static void destroy_slab(slab_t *slab) {
+    LOG_DEBUG("bucket: %p, slab_size: %zu", (void *)slab->bucket,
+              slab->slab_size);
+
+    umf_memory_provider_handle_t provider = slab->bucket->pool->provider;
+    umf_result_t res =
+        umfMemoryProviderFree(provider, slab->mem_ptr, slab->slab_size);
+    if (res != UMF_RESULT_SUCCESS) {
+        LOG_ERR("deallocation of slab data failed!");
+    }
+}
+
+static size_t slab_find_first_available_chunk_idx(const slab_t *slab) {
+    for (size_t i = 0; i < slab->num_words; i++) {
+        // NOTE: free chunks are represented as set bits
+        uint64_t word = slab->chunks[i];
+        if (word != 0) {
+            size_t bit_index = utils_lsb64(word);
+            size_t free_chunk = i * CHUNK_BITMAP_SIZE + bit_index;
+            return free_chunk;
+        }
+    }
+
+    // No free chunk was found.
+    return SIZE_MAX;
+}
+
+static void *slab_get_chunk(slab_t *slab) {
+    // free chunk must exist, otherwise we would have allocated another slab
+    const size_t chunk_idx = slab_find_first_available_chunk_idx(slab);
+    assert(chunk_idx != SIZE_MAX);
+
+    void *free_chunk =
+        (void *)((uintptr_t)slab->mem_ptr + chunk_idx * slab->bucket->size);
+
+    // mark chunk as used
+    slab_set_chunk_bit(slab, chunk_idx, false);
+    slab->num_chunks_allocated += 1;
+
+    return free_chunk;
+}
+
+static void *slab_get(const slab_t *slab) { return slab->mem_ptr; }
+static void *slab_get_end(const slab_t *slab) {
+    return (void *)((uintptr_t)slab->mem_ptr +
+                    bucket_slab_min_size(slab->bucket));
+}
+
+static void slab_free_chunk(slab_t *slab, void *ptr) {
+    // This method should be called through bucket (since we might remove the
+    // slab as a result), therefore all locks are done on bucket level.
+
+    // Make sure that we're in the right slab
+    assert(ptr >= slab_get(slab) && ptr < slab_get_end(slab));
+
+    // Get the chunk index
+    uintptr_t ptr_diff = (uintptr_t)ptr - (uintptr_t)slab->mem_ptr;
+    assert((ptr_diff % slab->bucket->size) == 0);
+    size_t chunk_idx = ptr_diff / slab->bucket->size;
+
+    // Make sure that the chunk was allocated
+    assert(slab_read_chunk_bit(slab, chunk_idx) == 0 && "double free detected");
+    slab_set_chunk_bit(slab, chunk_idx, true);
+    slab->num_chunks_allocated -= 1;
+}
+
+static bool slab_has_avail(const slab_t *slab) {
+    return slab->num_chunks_allocated < slab->num_chunks_total;
+}
+
+static umf_result_t pool_register_slab(disjoint_pool_t *pool, slab_t *slab) {
+    critnib *slabs = pool->known_slabs;
+
+    // NOTE: changed vs original DisjointPool implementation - currently slab
+    // is already aligned to bucket size.
+    void *slab_addr = slab_get(slab);
+    // TODO ASSERT_IS_ALIGNED((uintptr_t)slab_addr, bucket->size);
+    LOG_DEBUG("slab: %p, start: %p", (void *)slab, slab_addr);
+
+    // NOTE: we don't need to lock the slabs map as the critnib already has a
+    // lock inside it
+    int ret = critnib_insert(slabs, (uintptr_t)slab_addr, slab, 0);
+    umf_result_t res = UMF_RESULT_SUCCESS;
+    if (ret == ENOMEM) {
+        LOG_ERR("register failed because of out of memory!");
+        res = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    } else if (ret == EEXIST) {
+        LOG_ERR("register failed because the address is already registered!");
+        res = UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    return res;
+}
+
+static umf_result_t pool_unregister_slab(disjoint_pool_t *pool, slab_t *slab) {
+    critnib *slabs = pool->known_slabs;
+
+    void *slab_addr = slab_get(slab);
+    // TODO ASSERT_IS_ALIGNED((uintptr_t)slab_addr, bucket->size);
+    LOG_DEBUG("slab: %p, start: %p", (void *)slab, slab_addr);
+
+    critnib_remove_release(slabs, (uintptr_t)slab_addr);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static bucket_t *
+create_bucket(size_t sz, disjoint_pool_t *pool,
+              umf_disjoint_pool_shared_limits_handle_t shared_limits) {
+
+    bucket_t *bucket = umf_ba_global_alloc(sizeof(*bucket));
+    if (bucket == NULL) {
+        LOG_ERR("allocation of new bucket failed!");
+        return NULL;
+    }
+
+    memset(bucket, 0, sizeof(*bucket));
+    bucket->size = sz;
+    bucket->pool = pool;
+    bucket->shared_limits = shared_limits;
+
+    utils_mutex_init(&bucket->bucket_lock);
+    return bucket;
+}
+
+static void destroy_bucket(bucket_t *bucket) {
+    // use an extra tmp to store the next iterator before destroying the slab
+    slab_list_item_t *it = NULL, *tmp = NULL;
+    LL_FOREACH_SAFE(bucket->available_slabs, it, tmp) {
+        LL_DELETE(bucket->available_slabs, it);
+        destroy_slab(it->val);
+    }
+
+    LL_FOREACH_SAFE(bucket->unavailable_slabs, it, tmp) {
+        LL_DELETE(bucket->unavailable_slabs, it);
+        destroy_slab(it->val);
+    }
+
+    utils_mutex_destroy_not_free(&bucket->bucket_lock);
+    umf_ba_global_free(bucket);
+}
+
+static size_t slab_get_num_free_chunks(const slab_t *slab) {
+    return slab->num_chunks_total - slab->num_chunks_allocated;
+}
+
+// NOTE: this function must be called under bucket->bucket_lock
+static void bucket_free_chunk(bucket_t *bucket, void *ptr, slab_t *slab,
+                              bool *to_pool) {
+    slab_free_chunk(slab, ptr);
+
+    // in case if the slab was previously full and now has single available
+    // chunk, it should be moved to the list of available slabs
+    if (slab_get_num_free_chunks(slab) == 1) {
+        slab_list_item_t *slab_it = &slab->iter;
+        assert(slab_it->val != NULL);
+        DL_DELETE(bucket->unavailable_slabs, slab_it);
+        DL_PREPEND(bucket->available_slabs, slab_it);
+        bucket->available_slabs_num++;
+    }
+
+    // check if slab is empty, and pool it if we can
+    if (slab->num_chunks_allocated == 0) {
+        // The slab is now empty.
+        // If the pool has capacity then put the slab in the pool.
+        // The to_pool parameter indicates whether the slab will be put in the
+        // pool or freed.
+        *to_pool = bucket_can_pool(bucket);
+        if (*to_pool == false) {
+            // remove slab
+            slab_list_item_t *slab_it = &slab->iter;
+            assert(slab_it->val != NULL);
+            pool_unregister_slab(bucket->pool, slab_it->val);
+            DL_DELETE(bucket->available_slabs, slab_it);
+            assert(bucket->available_slabs_num > 0);
+            bucket->available_slabs_num--;
+            destroy_slab(slab_it->val);
+        }
+    } else {
+        // return this chunk to the pool
+        *to_pool = true;
+    }
+}
+
+// NOTE: this function must be called under bucket->bucket_lock
+static void *bucket_get_free_chunk(bucket_t *bucket, bool *from_pool) {
+    slab_list_item_t *slab_it = bucket_get_avail_slab(bucket, from_pool);
+    if (slab_it == NULL) {
+        return NULL;
+    }
+
+    void *free_chunk = slab_get_chunk(slab_it->val);
+
+    // if we allocated last free chunk from the slab and now it is full, move
+    // it to unavailable slabs and update its iterator
+    if (!(slab_has_avail(slab_it->val))) {
+        DL_DELETE(bucket->available_slabs, slab_it);
+        bucket->available_slabs_num--;
+        slab_it->prev = NULL;
+        DL_PREPEND(bucket->unavailable_slabs, slab_it);
+    }
+
+    return free_chunk;
+}
+
+static size_t bucket_chunk_cut_off(bucket_t *bucket) {
+    return bucket_slab_min_size(bucket) / 2;
+}
+
+static slab_t *bucket_create_slab(bucket_t *bucket) {
+    slab_t *slab = create_slab(bucket);
+    if (slab == NULL) {
+        LOG_ERR("create_slab failed!")
+        return NULL;
+    }
+
+    umf_result_t res = pool_register_slab(bucket->pool, slab);
+    if (res != UMF_RESULT_SUCCESS) {
+        LOG_ERR("slab_reg failed!")
+        destroy_slab(slab);
+        return NULL;
+    }
+
+    DL_PREPEND(bucket->available_slabs, &slab->iter);
+    bucket->available_slabs_num++;
+    bucket_update_stats(bucket, 1, 0);
+
+    return slab;
+}
+
+static slab_list_item_t *bucket_get_avail_slab(bucket_t *bucket,
+                                               bool *from_pool) {
+    if (bucket->available_slabs == NULL) {
+        bucket_create_slab(bucket);
+        *from_pool = false;
+    } else {
+        slab_t *slab = bucket->available_slabs->val;
+        // Allocation from existing slab is treated as from pool for statistics.
+        *from_pool = true;
+        if (slab->num_chunks_allocated == 0) {
+            assert(bucket->chunked_slabs_in_pool > 0);
+            // If this was an empty slab, it was in the pool.
+            // Now it is no longer in the pool, so update count.
+            --bucket->chunked_slabs_in_pool;
+            uint64_t size_to_sub = bucket_slab_alloc_size(bucket);
+            uint64_t old_size = utils_fetch_and_sub_u64(
+                &bucket->shared_limits->total_size, size_to_sub);
+            (void)old_size;
+            assert(old_size >= size_to_sub);
+            bucket_update_stats(bucket, 1, -1);
+        }
+    }
+
+    return bucket->available_slabs;
+}
+
+static size_t bucket_max_pooled_slabs(bucket_t *bucket) {
+    // For small buckets where slabs are split to chunks, just one pooled slab is sufficient.
+    // For larger buckets, the capacity could be more and is adjustable.
+    if (bucket->size <= bucket_chunk_cut_off(bucket)) {
+        return 1;
+    } else {
+        return bucket->pool->params.capacity;
+    }
+}
+
+static void bucket_update_stats(bucket_t *bucket, int in_use, int in_pool) {
+    if (bucket->pool->params.pool_trace == 0) {
+        return;
+    }
+
+    bucket->curr_slabs_in_use += in_use;
+    bucket->max_slabs_in_use =
+        utils_max(bucket->curr_slabs_in_use, bucket->max_slabs_in_use);
+
+    bucket->curr_slabs_in_pool += in_pool;
+    bucket->max_slabs_in_pool =
+        utils_max(bucket->curr_slabs_in_pool, bucket->max_slabs_in_pool);
+
+    // Increment or decrement current pool sizes based on whether
+    // slab was added to or removed from pool.
+    bucket->pool->params.cur_pool_size +=
+        in_pool * bucket_slab_alloc_size(bucket);
+}
+
+static bool bucket_can_pool(bucket_t *bucket) {
+    size_t new_free_slabs_in_bucket;
+
+    new_free_slabs_in_bucket = bucket->chunked_slabs_in_pool + 1;
+
+    // we keep at most params.capacity slabs in the pool
+    if (bucket_max_pooled_slabs(bucket) >= new_free_slabs_in_bucket) {
+
+        uint64_t size_to_add = bucket_slab_alloc_size(bucket);
+        size_t previous_size = utils_fetch_and_add_u64(
+            &bucket->shared_limits->total_size, size_to_add);
+
+        if (previous_size + size_to_add <= bucket->shared_limits->max_size) {
+            ++bucket->chunked_slabs_in_pool;
+            bucket_update_stats(bucket, -1, 1);
+            return true;
+        } else {
+            uint64_t old = utils_fetch_and_sub_u64(
+                &bucket->shared_limits->total_size, size_to_add);
+            (void)old;
+            assert(old >= size_to_add);
+        }
+    }
+
+    bucket_update_stats(bucket, -1, 0);
+    return false;
+}
+
+static size_t size_to_idx(disjoint_pool_t *pool, size_t size) {
+    assert(size <= CutOff && "Unexpected size");
+    assert(size > 0 && "Unexpected size");
+
+    size_t min_bucket_size = (size_t)1 << pool->min_bucket_size_exp;
+    if (size < min_bucket_size) {
+        return 0;
+    }
+
+    // get the position of the leftmost set bit
+    size_t position = utils_msb64(size);
+
+    bool is_power_of_2 = IS_POWER_OF_2(size);
+    bool larger_than_halfway_between_powers_of_2 =
+        !is_power_of_2 &&
+        (bool)((size - 1) & ((uint64_t)(1) << (position - 1)));
+    size_t index = (position - pool->min_bucket_size_exp) * 2 +
+                   (int)(!is_power_of_2) +
+                   (int)larger_than_halfway_between_powers_of_2;
+
+    return index;
+}
+
+static umf_disjoint_pool_shared_limits_t *
+disjoint_pool_get_limits(disjoint_pool_t *pool) {
+    if (pool->params.shared_limits) {
+        return pool->params.shared_limits;
+    } else {
+        return pool->default_shared_limits;
+    }
+}
+
+static bucket_t *disjoint_pool_find_bucket(disjoint_pool_t *pool, size_t size) {
+    size_t calculated_idx = size_to_idx(pool, size);
+    return pool->buckets[calculated_idx];
+}
+
+static void disjoint_pool_print_stats(disjoint_pool_t *pool) {
+    size_t high_bucket_size = 0;
+    size_t high_peak_slabs_in_use = 0;
+    const char *name = pool->params.name;
+
+    LOG_DEBUG("\"%s\" pool memory statistics", name);
+    LOG_DEBUG("%14s %12s %12s %18s %20s %21s", "Bucket Size", "Allocs", "Frees",
+              "Allocs from Pool", "Peak Slabs in Use", "Peak Slabs in Pool");
+
+    for (size_t i = 0; i < pool->buckets_num; i++) {
+        bucket_t *bucket = pool->buckets[i];
+        // lock bucket before accessing its stats
+        utils_mutex_lock(&bucket->bucket_lock);
+
+        if (bucket->alloc_count) {
+            LOG_DEBUG("%14zu %12zu %12zu %18zu %20zu %21zu", bucket->size,
+                      bucket->alloc_count, bucket->free_count,
+                      bucket->alloc_pool_count, bucket->max_slabs_in_use,
+                      bucket->max_slabs_in_pool);
+            high_bucket_size =
+                utils_max(bucket_slab_alloc_size(bucket), high_bucket_size);
+        }
+
+        high_peak_slabs_in_use =
+            utils_max(bucket->max_slabs_in_use, high_peak_slabs_in_use);
+
+        utils_mutex_unlock(&bucket->bucket_lock);
+    }
+
+    LOG_DEBUG("current pool size: %" PRIu64,
+              disjoint_pool_get_limits(pool)->total_size);
+    LOG_DEBUG("suggested setting=;%c%s:%zu,%zu,64K", (char)tolower(name[0]),
+              (name + 1), high_bucket_size, high_peak_slabs_in_use);
+}
+
+static void *disjoint_pool_allocate(disjoint_pool_t *pool, size_t size) {
+    if (size == 0) {
+        return NULL;
+    }
+
+    void *ptr = NULL;
+
+    if (size > pool->params.max_poolable_size) {
+        umf_result_t ret =
+            umfMemoryProviderAlloc(pool->provider, size, 0, &ptr);
+        if (ret != UMF_RESULT_SUCCESS) {
+            TLS_last_allocation_error = ret;
+            LOG_ERR("allocation from the memory provider failed");
+            return NULL;
+        }
+
+        utils_annotate_memory_undefined(ptr, size);
+        return ptr;
+    }
+
+    bucket_t *bucket = disjoint_pool_find_bucket(pool, size);
+
+    utils_mutex_lock(&bucket->bucket_lock);
+
+    bool from_pool = false;
+    ptr = bucket_get_free_chunk(bucket, &from_pool);
+
+    if (ptr == NULL) {
+        TLS_last_allocation_error = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        utils_mutex_unlock(&bucket->bucket_lock);
+        return NULL;
+    }
+
+    if (pool->params.pool_trace > 1) {
+        // update stats
+        ++bucket->alloc_count;
+        if (from_pool) {
+            ++bucket->alloc_pool_count;
+        }
+    }
+
+    utils_mutex_unlock(&bucket->bucket_lock);
+
+    if (pool->params.pool_trace > 2) {
+        LOG_DEBUG("Allocated %8zu %s bytes from %s -> %p", size,
+                  pool->params.name, (from_pool ? "pool" : "provider"), ptr);
+    }
+
+    VALGRIND_DO_MEMPOOL_ALLOC(pool, ptr, size);
+    utils_annotate_memory_undefined(ptr, bucket->size);
+    return ptr;
+}
+
+/*
+ * free_slab - callback for freeing the slab.
+ *             It is called by critnib when the slab
+ *             is removed from the critnib.
+ */
+static void free_slab(void *unused, void *slab) {
+    (void)unused;
+    if (slab) {
+        umf_ba_global_free(slab);
+    }
+}
+
+umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
+                                      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;
+    }
+
+    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.
+    if (!dp_params->min_bucket_size ||
+        !IS_POWER_OF_2(dp_params->min_bucket_size)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    disjoint_pool_t *disjoint_pool =
+        umf_ba_global_alloc(sizeof(*disjoint_pool));
+    if (disjoint_pool == NULL) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    VALGRIND_DO_CREATE_MEMPOOL(disjoint_pool, 0, 0);
+
+    disjoint_pool->provider = provider;
+    disjoint_pool->params = *dp_params;
+
+    disjoint_pool->known_slabs = critnib_new(free_slab, NULL);
+    if (disjoint_pool->known_slabs == NULL) {
+        goto err_free_disjoint_pool;
+    }
+
+    // Generate buckets sized such as: 64, 96, 128, 192, ..., CutOff.
+    // Powers of 2 and the value halfway between the powers of 2.
+    size_t Size1 = disjoint_pool->params.min_bucket_size;
+
+    // min_bucket_size cannot be larger than CutOff.
+    Size1 = utils_min(Size1, CutOff);
+
+    // Buckets sized smaller than the bucket default size- 8 aren't needed.
+    Size1 = utils_max(Size1, UMF_DISJOINT_POOL_MIN_BUCKET_DEFAULT_SIZE);
+
+    // Calculate the exponent for min_bucket_size used for finding buckets.
+    disjoint_pool->min_bucket_size_exp = (size_t)utils_msb64(Size1);
+    disjoint_pool->default_shared_limits =
+        umfDisjointPoolSharedLimitsCreate(SIZE_MAX);
+    if (disjoint_pool->default_shared_limits == NULL) {
+        goto err_free_known_slabs;
+    }
+
+    // count number of buckets, start from 1
+    disjoint_pool->buckets_num = 1;
+    size_t Size2 = Size1 + Size1 / 2;
+    size_t ts2 = Size2, ts1 = Size1;
+    while (Size2 < CutOff) {
+        disjoint_pool->buckets_num += 2;
+        Size2 *= 2;
+    }
+
+    disjoint_pool->buckets = umf_ba_global_alloc(
+        sizeof(*disjoint_pool->buckets) * disjoint_pool->buckets_num);
+    if (disjoint_pool->buckets == NULL) {
+        goto err_free_shared_limits;
+    }
+
+    size_t i = 0;
+    Size1 = ts1;
+    Size2 = ts2;
+    for (; Size2 < CutOff; Size1 *= 2, Size2 *= 2, i += 2) {
+        disjoint_pool->buckets[i] = create_bucket(
+            Size1, disjoint_pool, disjoint_pool_get_limits(disjoint_pool));
+        disjoint_pool->buckets[i + 1] = create_bucket(
+            Size2, disjoint_pool, disjoint_pool_get_limits(disjoint_pool));
+    }
+    disjoint_pool->buckets[i] = create_bucket(
+        CutOff, disjoint_pool, disjoint_pool_get_limits(disjoint_pool));
+
+    // check if all buckets were created successfully
+    for (i = 0; i < disjoint_pool->buckets_num; i++) {
+        if (disjoint_pool->buckets[i] == NULL) {
+            goto err_free_buckets;
+        }
+    }
+
+    umf_result_t ret = umfMemoryProviderGetMinPageSize(
+        provider, NULL, &disjoint_pool->provider_min_page_size);
+    if (ret != UMF_RESULT_SUCCESS) {
+        disjoint_pool->provider_min_page_size = 0;
+    }
+
+    *ppPool = (void *)disjoint_pool;
+
+    return UMF_RESULT_SUCCESS;
+
+err_free_buckets:
+    for (i = 0; i < disjoint_pool->buckets_num; i++) {
+        if (disjoint_pool->buckets[i] != NULL) {
+            destroy_bucket(disjoint_pool->buckets[i]);
+        }
+    }
+    umf_ba_global_free(disjoint_pool->buckets);
+
+err_free_shared_limits:
+    umfDisjointPoolSharedLimitsDestroy(disjoint_pool->default_shared_limits);
+
+err_free_known_slabs:
+    critnib_delete(disjoint_pool->known_slabs);
+
+err_free_disjoint_pool:
+    umf_ba_global_free(disjoint_pool);
+
+    return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+}
+
+void *disjoint_pool_malloc(void *pool, size_t size) {
+    disjoint_pool_t *hPool = (disjoint_pool_t *)pool;
+    void *ptr = disjoint_pool_allocate(hPool, size);
+
+    return ptr;
+}
+
+void *disjoint_pool_calloc(void *pool, size_t num, size_t size) {
+    (void)pool;
+    (void)num;
+    (void)size;
+
+    // Not supported
+    TLS_last_allocation_error = UMF_RESULT_ERROR_NOT_SUPPORTED;
+    return NULL;
+}
+
+void *disjoint_pool_realloc(void *pool, void *ptr, size_t size) {
+    (void)pool;
+    (void)ptr;
+    (void)size;
+
+    // Not supported
+    TLS_last_allocation_error = UMF_RESULT_ERROR_NOT_SUPPORTED;
+    return NULL;
+}
+
+void *disjoint_pool_aligned_malloc(void *pool, size_t size, size_t alignment) {
+    disjoint_pool_t *disjoint_pool = (disjoint_pool_t *)pool;
+
+    void *ptr = NULL;
+
+    if (size == 0) {
+        return NULL;
+    }
+
+    if (alignment <= 1) {
+        return disjoint_pool_allocate(pool, size);
+    }
+
+    size_t aligned_size;
+    if (alignment <= disjoint_pool->provider_min_page_size) {
+        // This allocation will be served from a Bucket which size is multiple
+        // of Alignment and Slab address is aligned to provider_min_page_size
+        // so the address will be properly aligned.
+        aligned_size = (size > 1) ? ALIGN_UP_SAFE(size, alignment) : alignment;
+    } else {
+        // Slabs are only aligned to provider_min_page_size, we need to compensate
+        // for that in case the allocation is within pooling limit.
+        // TODO: consider creating properly-aligned Slabs on demand
+        aligned_size = size + alignment - 1;
+    }
+
+    // Check if requested allocation size is within pooling limit.
+    // If not, just request aligned pointer from the system.
+    if (aligned_size > disjoint_pool->params.max_poolable_size) {
+
+        umf_result_t ret = umfMemoryProviderAlloc(disjoint_pool->provider, size,
+                                                  alignment, &ptr);
+        if (ret != UMF_RESULT_SUCCESS) {
+            TLS_last_allocation_error = ret;
+            LOG_ERR("allocation from the memory provider failed");
+            return NULL;
+        }
+
+        assert(ptr);
+        utils_annotate_memory_undefined(ptr, size);
+        return ptr;
+    }
+
+    bool from_pool = false;
+    bucket_t *bucket = disjoint_pool_find_bucket(pool, aligned_size);
+
+    utils_mutex_lock(&bucket->bucket_lock);
+
+    ptr = bucket_get_free_chunk(bucket, &from_pool);
+
+    if (ptr == NULL) {
+        TLS_last_allocation_error = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        utils_mutex_unlock(&bucket->bucket_lock);
+        return NULL;
+    }
+
+    if (disjoint_pool->params.pool_trace > 1) {
+        // update stats
+        ++bucket->alloc_count;
+        if (from_pool) {
+            ++bucket->alloc_pool_count;
+        }
+    }
+
+    void *aligned_ptr = (void *)ALIGN_UP_SAFE((size_t)ptr, alignment);
+    size_t diff = (ptrdiff_t)aligned_ptr - (ptrdiff_t)ptr;
+    size_t real_size = bucket->size - diff;
+    VALGRIND_DO_MEMPOOL_ALLOC(disjoint_pool, aligned_ptr, real_size);
+    utils_annotate_memory_undefined(aligned_ptr, real_size);
+
+    utils_mutex_unlock(&bucket->bucket_lock);
+
+    if (disjoint_pool->params.pool_trace > 2) {
+        LOG_DEBUG("Allocated %8zu %s bytes aligned at %zu from %s -> %p", size,
+                  disjoint_pool->params.name, alignment,
+                  (from_pool ? "pool" : "provider"), ptr);
+    }
+
+    return aligned_ptr;
+}
+
+static size_t get_chunk_idx(const void *ptr, slab_t *slab) {
+    return (((uintptr_t)ptr - (uintptr_t)slab->mem_ptr) / slab->bucket->size);
+}
+
+static void *get_unaligned_ptr(size_t chunk_idx, slab_t *slab) {
+    return (void *)((uintptr_t)slab->mem_ptr + chunk_idx * slab->bucket->size);
+}
+
+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
+    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) {
+            return 0;
+        }
+
+        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);
+    void *unaligned_ptr = get_unaligned_ptr(chunk_idx, slab);
+
+    ptrdiff_t diff = (ptrdiff_t)ptr - (ptrdiff_t)unaligned_ptr;
+
+    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) {
+    disjoint_pool_t *disjoint_pool = (disjoint_pool_t *)pool;
+    if (ptr == NULL) {
+        return UMF_RESULT_SUCCESS;
+    }
+
+    // check if given pointer is allocated inside any Disjoint Pool slab
+    void *ref_slab = NULL;
+    slab_t *slab = (slab_t *)critnib_find_le(disjoint_pool->known_slabs,
+                                             (uintptr_t)ptr, &ref_slab);
+
+    if (slab == NULL || ptr >= slab_get_end(slab)) {
+        // regular free
+        if (ref_slab) {
+            critnib_release(disjoint_pool->known_slabs, ref_slab);
+        }
+
+        umf_alloc_info_t allocInfo = {NULL, 0, NULL};
+        umf_result_t ret = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
+        if (ret != UMF_RESULT_SUCCESS) {
+            TLS_last_allocation_error = ret;
+            LOG_ERR("failed to get allocation info from the memory tracker");
+            return ret;
+        }
+
+        size_t size = allocInfo.baseSize;
+        umf_memory_provider_handle_t provider = disjoint_pool->provider;
+        ret = umfMemoryProviderFree(provider, ptr, size);
+        if (ret != UMF_RESULT_SUCCESS) {
+            TLS_last_allocation_error = ret;
+            LOG_ERR("deallocation from the memory provider failed");
+        }
+
+        return ret;
+    }
+
+    bool to_pool = false;
+
+    if (ptr < slab_get(slab) || ptr >= slab_get_end(slab)) {
+        assert(0);
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    // The slab object won't be deleted until it's removed from the map which is
+    // protected by the lock, so it's safe to access it here.
+
+    bucket_t *bucket = slab->bucket;
+
+    utils_mutex_lock(&bucket->bucket_lock);
+    VALGRIND_DO_MEMPOOL_FREE(pool, ptr);
+
+    // Get the unaligned pointer
+    // NOTE: the base pointer slab->mem_ptr needn't to be aligned to bucket size
+    size_t chunk_idx = get_chunk_idx(ptr, slab);
+    void *unaligned_ptr = get_unaligned_ptr(chunk_idx, slab);
+
+    utils_annotate_memory_inaccessible(unaligned_ptr, bucket->size);
+    bucket_free_chunk(bucket, unaligned_ptr, slab, &to_pool);
+
+    assert(ref_slab);
+    critnib_release(disjoint_pool->known_slabs, ref_slab);
+
+    if (disjoint_pool->params.pool_trace > 1) {
+        bucket->free_count++;
+    }
+
+    utils_mutex_unlock(&bucket->bucket_lock);
+
+    if (disjoint_pool->params.pool_trace > 2) {
+        const char *name = disjoint_pool->params.name;
+        LOG_DEBUG("freed %s %p to %s, current total pool size: %" PRIu64
+                  ", current "
+                  "pool size for %s: %zu",
+                  name, ptr, (to_pool ? "pool" : "provider"),
+                  disjoint_pool_get_limits(disjoint_pool)->total_size, name,
+                  disjoint_pool->params.cur_pool_size);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t disjoint_pool_get_last_allocation_error(void *pool) {
+    (void)pool;
+    return TLS_last_allocation_error;
+}
+
+// Define destructor for use with unique_ptr
+umf_result_t disjoint_pool_finalize(void *pool) {
+    disjoint_pool_t *hPool = (disjoint_pool_t *)pool;
+    umf_result_t ret = UMF_RESULT_SUCCESS;
+    if (hPool->params.pool_trace > 1) {
+        disjoint_pool_print_stats(hPool);
+    }
+
+    for (size_t i = 0; i < hPool->buckets_num; i++) {
+        destroy_bucket(hPool->buckets[i]);
+    }
+
+    VALGRIND_DO_DESTROY_MEMPOOL(hPool);
+    ret = umfDisjointPoolSharedLimitsDestroy(hPool->default_shared_limits);
+    if (ret != UMF_RESULT_SUCCESS) {
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+        LOG_ERR("umfDisjointPoolSharedLimitsDestroy failed");
+    }
+
+    critnib_delete(hPool->known_slabs);
+
+    umf_ba_global_free(hPool);
+    return ret;
+}
+
+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 = {
+    .version = UMF_VERSION_CURRENT,
+    .initialize = disjoint_pool_initialize,
+    .finalize = disjoint_pool_finalize,
+    .malloc = disjoint_pool_malloc,
+    .calloc = disjoint_pool_calloc,
+    .realloc = disjoint_pool_realloc,
+    .aligned_malloc = disjoint_pool_aligned_malloc,
+    .malloc_usable_size = disjoint_pool_malloc_usable_size,
+    .free = disjoint_pool_free,
+    .get_last_allocation_error = disjoint_pool_get_last_allocation_error,
+    .ext_get_name = disjoint_pool_get_name,
+    .ext_ctl = disjoint_pool_ctl,
+};
+
+const umf_memory_pool_ops_t *umfDisjointPoolOps(void) {
+    return &UMF_DISJOINT_POOL_OPS;
+}
+
+umf_disjoint_pool_shared_limits_t *
+umfDisjointPoolSharedLimitsCreate(size_t max_size) {
+    umf_disjoint_pool_shared_limits_t *ptr = umf_ba_global_alloc(sizeof(*ptr));
+    if (ptr == NULL) {
+        LOG_ERR("cannot allocate memory for disjoint pool shared limits");
+        return NULL;
+    }
+    ptr->max_size = max_size;
+    ptr->total_size = 0;
+    return ptr;
+}
+
+umf_result_t
+umfDisjointPoolSharedLimitsDestroy(umf_disjoint_pool_shared_limits_t *limits) {
+    umf_ba_global_free(limits);
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsCreate(umf_disjoint_pool_params_handle_t *hParams) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_disjoint_pool_params_handle_t params =
+        umf_ba_global_alloc(sizeof(*params));
+    if (params == NULL) {
+        LOG_ERR("cannot allocate memory for disjoint pool params");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    *params = (umf_disjoint_pool_params_t){
+        .slab_min_size = 0,
+        .max_poolable_size = 0,
+        .capacity = 0,
+        .min_bucket_size = UMF_DISJOINT_POOL_MIN_BUCKET_DEFAULT_SIZE,
+        .cur_pool_size = 0,
+        .pool_trace = 0,
+        .shared_limits = NULL,
+    };
+
+    strncpy(params->name, DEFAULT_NAME, sizeof(params->name) - 1);
+    params->name[sizeof(params->name) - 1] = '\0';
+
+    *hParams = params;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsDestroy(umf_disjoint_pool_params_handle_t hParams) {
+    // NOTE: dereferencing hParams when BA is already destroyed leads to crash
+    if (hParams && !umf_ba_global_is_destroyed()) {
+        umf_ba_global_free(hParams);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsSetSlabMinSize(umf_disjoint_pool_params_handle_t hParams,
+                                    size_t slabMinSize) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->slab_min_size = slabMinSize;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfDisjointPoolParamsSetMaxPoolableSize(
+    umf_disjoint_pool_params_handle_t hParams, size_t maxPoolableSize) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->max_poolable_size = maxPoolableSize;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsSetCapacity(umf_disjoint_pool_params_handle_t hParams,
+                                 size_t maxCapacity) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->capacity = maxCapacity;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsSetMinBucketSize(umf_disjoint_pool_params_handle_t hParams,
+                                      size_t minBucketSize) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    // minBucketSize parameter must be a power of 2 and greater than 0.
+    if (minBucketSize == 0 || (minBucketSize & (minBucketSize - 1))) {
+        LOG_ERR("minBucketSize must be a power of 2 and greater than 0");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->min_bucket_size = minBucketSize;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsSetTrace(umf_disjoint_pool_params_handle_t hParams,
+                              int poolTrace) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->pool_trace = poolTrace;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfDisjointPoolParamsSetSharedLimits(
+    umf_disjoint_pool_params_handle_t hParams,
+    umf_disjoint_pool_shared_limits_handle_t hSharedLimits) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->shared_limits = hSharedLimits;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfDisjointPoolParamsSetName(umf_disjoint_pool_params_handle_t hParams,
+                             const char *name) {
+    if (!hParams) {
+        LOG_ERR("disjoint pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    strncpy(hParams->name, name, sizeof(hParams->name) - 1);
+    hParams->name[sizeof(hParams->name) - 1] = '\0';
+    return UMF_RESULT_SUCCESS;
+}
diff --git a/src/pool/pool_disjoint.cpp b/src/pool/pool_disjoint.cpp
deleted file mode 100644
index edb5fc649..000000000
--- a/src/pool/pool_disjoint.cpp
+++ /dev/null
@@ -1,1131 +0,0 @@
-// Copyright (C) 2023 Intel Corporation
-// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-#include <algorithm>
-#include <array>
-#include <atomic>
-#include <bitset>
-#include <cassert>
-#include <cctype>
-#include <iomanip>
-#include <limits>
-#include <list>
-#include <memory>
-#include <mutex>
-#include <shared_mutex>
-#include <string>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-// TODO: replace with logger?
-#include <iostream>
-
-#include "provider/provider_tracking.h"
-
-#include "../cpp_helpers.hpp"
-#include "pool_disjoint.h"
-#include "umf.h"
-#include "utils_log.h"
-#include "utils_math.h"
-#include "utils_sanitizers.h"
-
-// Temporary solution for disabling memory poisoning. This is needed because
-// AddressSanitizer does not support memory poisoning for GPU allocations.
-// More info: https://github.com/oneapi-src/unified-memory-framework/issues/634
-#ifndef POISON_MEMORY
-#define POISON_MEMORY 0
-#endif
-
-static inline void annotate_memory_inaccessible([[maybe_unused]] void *ptr,
-                                                [[maybe_unused]] size_t size) {
-#if (POISON_MEMORY != 0)
-    utils_annotate_memory_inaccessible(ptr, size);
-#endif
-}
-
-static inline void annotate_memory_undefined([[maybe_unused]] void *ptr,
-                                             [[maybe_unused]] size_t size) {
-#if (POISON_MEMORY != 0)
-    utils_annotate_memory_undefined(ptr, size);
-#endif
-}
-
-typedef struct umf_disjoint_pool_shared_limits_t {
-    size_t MaxSize;
-    std::atomic<size_t> TotalSize;
-} umf_disjoint_pool_shared_limits_t;
-
-class DisjointPool {
-  public:
-    class AllocImpl;
-    using Config = umf_disjoint_pool_params_t;
-
-    umf_result_t initialize(umf_memory_provider_handle_t provider,
-                            umf_disjoint_pool_params_t *parameters);
-    void *malloc(size_t size);
-    void *calloc(size_t, size_t);
-    void *realloc(void *, size_t);
-    void *aligned_malloc(size_t size, size_t alignment);
-    size_t malloc_usable_size(void *);
-    umf_result_t free(void *ptr);
-    umf_result_t get_last_allocation_error();
-
-    DisjointPool();
-    ~DisjointPool();
-
-  private:
-    std::unique_ptr<AllocImpl> impl;
-};
-
-umf_disjoint_pool_shared_limits_t *
-umfDisjointPoolSharedLimitsCreate(size_t MaxSize) {
-    return new umf_disjoint_pool_shared_limits_t{MaxSize, 0};
-}
-
-void umfDisjointPoolSharedLimitsDestroy(
-    umf_disjoint_pool_shared_limits_t *limits) {
-    delete limits;
-}
-
-// Allocations are a minimum of 4KB/64KB/2MB even when a smaller size is
-// requested. The implementation distinguishes between allocations of size
-// ChunkCutOff = (minimum-alloc-size / 2) and those that are larger.
-// Allocation requests smaller than ChunkCutoff use chunks taken from a single
-// coarse-grain allocation. Thus, for example, for a 64KB minimum allocation
-// size, and 8-byte allocations, only 1 in ~8000 requests results in a new
-// coarse-grain allocation. Freeing results only in a chunk of a larger
-// allocation to be marked as available and no real return to the system. An
-// allocation is returned to the system only when all chunks in the larger
-// allocation are freed by the program. Allocations larger than ChunkCutOff use
-// a separate coarse-grain allocation for each request. These are subject to
-// "pooling". That is, when such an allocation is freed by the program it is
-// retained in a pool. The pool is available for future allocations, which means
-// there are fewer actual coarse-grain allocations/deallocations.
-
-// The largest size which is allocated via the allocator.
-// Allocations with size > CutOff bypass the pool and
-// go directly to the provider.
-static constexpr size_t CutOff = (size_t)1 << 31; // 2GB
-
-// Aligns the pointer down to the specified alignment
-// (e.g. returns 8 for Size = 13, Alignment = 8)
-static void *AlignPtrDown(void *Ptr, const size_t Alignment) {
-    return reinterpret_cast<void *>((reinterpret_cast<size_t>(Ptr)) &
-                                    (~(Alignment - 1)));
-}
-
-// Aligns the pointer up to the specified alignment
-// (e.g. returns 16 for Size = 13, Alignment = 8)
-static void *AlignPtrUp(void *Ptr, const size_t Alignment) {
-    void *AlignedPtr = AlignPtrDown(Ptr, Alignment);
-    // Special case when the pointer is already aligned
-    if (Ptr == AlignedPtr) {
-        return Ptr;
-    }
-    return static_cast<char *>(AlignedPtr) + Alignment;
-}
-
-// Aligns the value up to the specified alignment
-// (e.g. returns 16 for Size = 13, Alignment = 8)
-static size_t AlignUp(size_t Val, size_t Alignment) {
-    assert(Alignment > 0);
-    return (Val + Alignment - 1) & (~(Alignment - 1));
-}
-
-typedef struct MemoryProviderError {
-    umf_result_t code;
-} MemoryProviderError_t;
-
-class Bucket;
-
-// Represents the allocated memory block of size 'SlabMinSize'
-// Internally, it splits the memory block into chunks. The number of
-// chunks depends of the size of a Bucket which created the Slab.
-// Note: Bucket's methods are responsible for thread safety of Slab access,
-// so no locking happens here.
-class Slab {
-
-    // Pointer to the allocated memory of SlabMinSize bytes
-    void *MemPtr;
-
-    // Represents the current state of each chunk:
-    // if the bit is set then the chunk is allocated
-    // the chunk is free for allocation otherwise
-    std::vector<bool> Chunks;
-
-    // Total number of allocated chunks at the moment.
-    size_t NumAllocated = 0;
-
-    // The bucket which the slab belongs to
-    Bucket &bucket;
-
-    using ListIter = std::list<std::unique_ptr<Slab>>::iterator;
-
-    // Store iterator to the corresponding node in avail/unavail list
-    // to achieve O(1) removal
-    ListIter SlabListIter;
-
-    // Hints where to start search for free chunk in a slab
-    size_t FirstFreeChunkIdx = 0;
-
-    // Return the index of the first available chunk, SIZE_MAX otherwise
-    size_t FindFirstAvailableChunkIdx() const;
-
-    // Register/Unregister the slab in the global slab address map.
-    void regSlab(Slab &);
-    void unregSlab(Slab &);
-    static void regSlabByAddr(void *, Slab &);
-    static void unregSlabByAddr(void *, Slab &);
-
-  public:
-    Slab(Bucket &);
-    ~Slab();
-
-    void setIterator(ListIter It) { SlabListIter = It; }
-    ListIter getIterator() const { return SlabListIter; }
-
-    size_t getNumAllocated() const { return NumAllocated; }
-
-    // Get pointer to allocation that is one piece of this slab.
-    void *getChunk();
-
-    // Get pointer to allocation that is this entire slab.
-    void *getSlab();
-
-    void *getPtr() const { return MemPtr; }
-    void *getEnd() const;
-
-    size_t getChunkSize() const;
-    size_t getNumChunks() const { return Chunks.size(); }
-
-    bool hasAvail();
-
-    Bucket &getBucket();
-    const Bucket &getBucket() const;
-
-    void freeChunk(void *Ptr);
-};
-
-class Bucket {
-    const size_t Size;
-
-    // List of slabs which have at least 1 available chunk.
-    std::list<std::unique_ptr<Slab>> AvailableSlabs;
-
-    // List of slabs with 0 available chunk.
-    std::list<std::unique_ptr<Slab>> UnavailableSlabs;
-
-    // Protects the bucket and all the corresponding slabs
-    std::mutex BucketLock;
-
-    // Reference to the allocator context, used access memory allocation
-    // routines, slab map and etc.
-    DisjointPool::AllocImpl &OwnAllocCtx;
-
-    // For buckets used in chunked mode, a counter of slabs in the pool.
-    // For allocations that use an entire slab each, the entries in the Available
-    // list are entries in the pool.Each slab is available for a new
-    // allocation.The size of the Available list is the size of the pool.
-    // For allocations that use slabs in chunked mode, slabs will be in the
-    // Available list if any one or more of their chunks is free.The entire slab
-    // is not necessarily free, just some chunks in the slab are free. To
-    // implement pooling we will allow one slab in the Available list to be
-    // entirely empty. Normally such a slab would have been freed. But
-    // now we don't, and treat this slab as "in the pool".
-    // When a slab becomes entirely free we have to decide whether to return it
-    // to the provider or keep it allocated. A simple check for size of the
-    // Available list is not sufficient to check whether any slab has been
-    // pooled yet.We would have to traverse the entire Available listand check
-    // if any of them is entirely free. Instead we keep a counter of entirely
-    // empty slabs within the Available list to speed up the process of checking
-    // if a slab in this bucket is already pooled.
-    size_t chunkedSlabsInPool;
-
-    // Statistics
-    size_t allocPoolCount;
-    size_t freeCount;
-    size_t currSlabsInUse;
-    size_t currSlabsInPool;
-    size_t maxSlabsInPool;
-
-  public:
-    // Statistics
-    size_t allocCount;
-    size_t maxSlabsInUse;
-
-    Bucket(size_t Sz, DisjointPool::AllocImpl &AllocCtx)
-        : Size{Sz}, OwnAllocCtx{AllocCtx}, chunkedSlabsInPool(0),
-          allocPoolCount(0), freeCount(0), currSlabsInUse(0),
-          currSlabsInPool(0), maxSlabsInPool(0), allocCount(0),
-          maxSlabsInUse(0) {}
-
-    // Get pointer to allocation that is one piece of an available slab in this
-    // bucket.
-    void *getChunk(bool &FromPool);
-
-    // Get pointer to allocation that is a full slab in this bucket.
-    void *getSlab(bool &FromPool);
-
-    // Return the allocation size of this bucket.
-    size_t getSize() const { return Size; }
-
-    // Free an allocation that is one piece of a slab in this bucket.
-    void freeChunk(void *Ptr, Slab &Slab, bool &ToPool);
-
-    // Free an allocation that is a full slab in this bucket.
-    void freeSlab(Slab &Slab, bool &ToPool);
-
-    umf_memory_provider_handle_t getMemHandle();
-
-    DisjointPool::AllocImpl &getAllocCtx() { return OwnAllocCtx; }
-
-    // Check whether an allocation to be freed can be placed in the pool.
-    bool CanPool(bool &ToPool);
-
-    // The minimum allocation size for any slab.
-    size_t SlabMinSize();
-
-    // The allocation size for a slab in this bucket.
-    size_t SlabAllocSize();
-
-    // The minimum size of a chunk from this bucket's slabs.
-    size_t ChunkCutOff();
-
-    // The number of slabs in this bucket that can be in the pool.
-    size_t Capacity();
-
-    // The maximum allocation size subject to pooling.
-    size_t MaxPoolableSize();
-
-    // Update allocation count
-    void countAlloc(bool FromPool);
-
-    // Update free count
-    void countFree();
-
-    // Update statistics of Available/Unavailable
-    void updateStats(int InUse, int InPool);
-
-    // Print bucket statistics
-    void printStats(bool &TitlePrinted, const std::string &Label);
-
-  private:
-    void onFreeChunk(Slab &, bool &ToPool);
-
-    // Update statistics of pool usage, and indicate that an allocation was made
-    // from the pool.
-    void decrementPool(bool &FromPool);
-
-    // Get a slab to be used for chunked allocations.
-    decltype(AvailableSlabs.begin()) getAvailSlab(bool &FromPool);
-
-    // Get a slab that will be used as a whole for a single allocation.
-    decltype(AvailableSlabs.begin()) getAvailFullSlab(bool &FromPool);
-};
-
-class DisjointPool::AllocImpl {
-    // It's important for the map to be destroyed last after buckets and their
-    // slabs This is because slab's destructor removes the object from the map.
-    std::unordered_multimap<void *, Slab &> KnownSlabs;
-    std::shared_timed_mutex KnownSlabsMapLock;
-
-    // Handle to the memory provider
-    umf_memory_provider_handle_t MemHandle;
-
-    // Store as unique_ptrs since Bucket is not Movable(because of std::mutex)
-    std::vector<std::unique_ptr<Bucket>> Buckets;
-
-    // Configuration for this instance
-    umf_disjoint_pool_params_t params;
-
-    umf_disjoint_pool_shared_limits_t DefaultSharedLimits = {
-        (std::numeric_limits<size_t>::max)(), 0};
-
-    // Used in algorithm for finding buckets
-    std::size_t MinBucketSizeExp;
-
-    // Coarse-grain allocation min alignment
-    size_t ProviderMinPageSize;
-
-  public:
-    AllocImpl(umf_memory_provider_handle_t hProvider,
-              umf_disjoint_pool_params_t *params)
-        : MemHandle{hProvider}, params(*params) {
-
-        VALGRIND_DO_CREATE_MEMPOOL(this, 0, 0);
-
-        // Generate buckets sized such as: 64, 96, 128, 192, ..., CutOff.
-        // Powers of 2 and the value halfway between the powers of 2.
-        auto Size1 = this->params.MinBucketSize;
-        // MinBucketSize cannot be larger than CutOff.
-        Size1 = std::min(Size1, CutOff);
-        // Buckets sized smaller than the bucket default size- 8 aren't needed.
-        Size1 = std::max(Size1, UMF_DISJOINT_POOL_MIN_BUCKET_DEFAULT_SIZE);
-        // Calculate the exponent for MinBucketSize used for finding buckets.
-        MinBucketSizeExp = (size_t)log2Utils(Size1);
-        auto Size2 = Size1 + Size1 / 2;
-        for (; Size2 < CutOff; Size1 *= 2, Size2 *= 2) {
-            Buckets.push_back(std::make_unique<Bucket>(Size1, *this));
-            Buckets.push_back(std::make_unique<Bucket>(Size2, *this));
-        }
-        Buckets.push_back(std::make_unique<Bucket>(CutOff, *this));
-
-        auto ret = umfMemoryProviderGetMinPageSize(hProvider, nullptr,
-                                                   &ProviderMinPageSize);
-        if (ret != UMF_RESULT_SUCCESS) {
-            ProviderMinPageSize = 0;
-        }
-    }
-
-    ~AllocImpl() { VALGRIND_DO_DESTROY_MEMPOOL(this); }
-
-    void *allocate(size_t Size, size_t Alignment, bool &FromPool);
-    void *allocate(size_t Size, bool &FromPool);
-    void deallocate(void *Ptr, bool &ToPool);
-
-    umf_memory_provider_handle_t getMemHandle() { return MemHandle; }
-
-    std::shared_timed_mutex &getKnownSlabsMapLock() {
-        return KnownSlabsMapLock;
-    }
-    std::unordered_multimap<void *, Slab &> &getKnownSlabs() {
-        return KnownSlabs;
-    }
-
-    size_t SlabMinSize() { return params.SlabMinSize; };
-
-    umf_disjoint_pool_params_t &getParams() { return params; }
-
-    umf_disjoint_pool_shared_limits_t *getLimits() {
-        if (params.SharedLimits) {
-            return params.SharedLimits;
-        } else {
-            return &DefaultSharedLimits;
-        }
-    };
-
-    void printStats(bool &TitlePrinted, size_t &HighBucketSize,
-                    size_t &HighPeakSlabsInUse, const std::string &Label);
-
-  private:
-    Bucket &findBucket(size_t Size);
-    std::size_t sizeToIdx(size_t Size);
-};
-
-static void *memoryProviderAlloc(umf_memory_provider_handle_t hProvider,
-                                 size_t size, size_t alignment = 0) {
-    void *ptr;
-    auto ret = umfMemoryProviderAlloc(hProvider, size, alignment, &ptr);
-    if (ret != UMF_RESULT_SUCCESS) {
-        throw MemoryProviderError{ret};
-    }
-    annotate_memory_inaccessible(ptr, size);
-    return ptr;
-}
-
-static void memoryProviderFree(umf_memory_provider_handle_t hProvider,
-                               void *ptr) {
-    size_t size = 0;
-
-    if (ptr) {
-        umf_alloc_info_t allocInfo = {NULL, 0, NULL};
-        umf_result_t umf_result = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
-        if (umf_result == UMF_RESULT_SUCCESS) {
-            size = allocInfo.baseSize;
-        }
-    }
-
-    auto ret = umfMemoryProviderFree(hProvider, ptr, size);
-    if (ret != UMF_RESULT_SUCCESS) {
-        throw MemoryProviderError{ret};
-    }
-}
-
-bool operator==(const Slab &Lhs, const Slab &Rhs) {
-    return Lhs.getPtr() == Rhs.getPtr();
-}
-
-std::ostream &operator<<(std::ostream &Os, const Slab &Slab) {
-    Os << "Slab<" << Slab.getPtr() << ", " << Slab.getEnd() << ", "
-       << Slab.getBucket().getSize() << ">";
-    return Os;
-}
-
-Slab::Slab(Bucket &Bkt)
-    : // In case bucket size is not a multiple of SlabMinSize, we would have
-      // some padding at the end of the slab.
-      Chunks(Bkt.SlabMinSize() / Bkt.getSize()), NumAllocated{0},
-      bucket(Bkt), SlabListIter{}, FirstFreeChunkIdx{0} {
-    auto SlabSize = Bkt.SlabAllocSize();
-    MemPtr = memoryProviderAlloc(Bkt.getMemHandle(), SlabSize);
-    regSlab(*this);
-}
-
-Slab::~Slab() {
-    try {
-        unregSlab(*this);
-    } catch (std::exception &e) {
-        LOG_ERR("DisjointPool: unexpected error: %s", e.what());
-    }
-
-    try {
-        memoryProviderFree(bucket.getMemHandle(), MemPtr);
-    } catch (MemoryProviderError &e) {
-        LOG_ERR("DisjointPool: error from memory provider: %d", e.code);
-
-        if (e.code == UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC) {
-            const char *message = "";
-            int error = 0;
-
-            try {
-                umfMemoryProviderGetLastNativeError(
-                    umfGetLastFailedMemoryProvider(), &message, &error);
-                LOG_ERR("Native error msg: %s, native error code: %d", message,
-                        error);
-            } catch (...) {
-                // ignore any additional errors from logger
-            }
-        }
-    }
-}
-
-// Return the index of the first available chunk, SIZE_MAX otherwise
-size_t Slab::FindFirstAvailableChunkIdx() const {
-    // Use the first free chunk index as a hint for the search.
-    auto It = std::find_if(Chunks.begin() + FirstFreeChunkIdx, Chunks.end(),
-                           [](auto x) { return !x; });
-    if (It != Chunks.end()) {
-        return It - Chunks.begin();
-    }
-
-    return std::numeric_limits<size_t>::max();
-}
-
-void *Slab::getChunk() {
-    // assert(NumAllocated != Chunks.size());
-
-    const size_t ChunkIdx = FindFirstAvailableChunkIdx();
-    // Free chunk must exist, otherwise we would have allocated another slab
-    assert(ChunkIdx != (std::numeric_limits<size_t>::max()));
-
-    void *const FreeChunk =
-        (static_cast<uint8_t *>(getPtr())) + ChunkIdx * getChunkSize();
-    Chunks[ChunkIdx] = true;
-    NumAllocated += 1;
-
-    // Use the found index as the next hint
-    FirstFreeChunkIdx = ChunkIdx;
-
-    return FreeChunk;
-}
-
-void *Slab::getSlab() { return getPtr(); }
-
-Bucket &Slab::getBucket() { return bucket; }
-const Bucket &Slab::getBucket() const { return bucket; }
-
-size_t Slab::getChunkSize() const { return bucket.getSize(); }
-
-void Slab::regSlabByAddr(void *Addr, Slab &Slab) {
-    auto &Lock = Slab.getBucket().getAllocCtx().getKnownSlabsMapLock();
-    auto &Map = Slab.getBucket().getAllocCtx().getKnownSlabs();
-
-    std::lock_guard<std::shared_timed_mutex> Lg(Lock);
-    Map.insert({Addr, Slab});
-}
-
-void Slab::unregSlabByAddr(void *Addr, Slab &Slab) {
-    auto &Lock = Slab.getBucket().getAllocCtx().getKnownSlabsMapLock();
-    auto &Map = Slab.getBucket().getAllocCtx().getKnownSlabs();
-
-    std::lock_guard<std::shared_timed_mutex> Lg(Lock);
-
-    auto Slabs = Map.equal_range(Addr);
-    // At least the must get the current slab from the map.
-    assert(Slabs.first != Slabs.second && "Slab is not found");
-
-    for (auto It = Slabs.first; It != Slabs.second; ++It) {
-        if (It->second == Slab) {
-            Map.erase(It);
-            return;
-        }
-    }
-
-    assert(false && "Slab is not found");
-}
-
-void Slab::regSlab(Slab &Slab) {
-    void *StartAddr = AlignPtrDown(Slab.getPtr(), bucket.SlabMinSize());
-    void *EndAddr = static_cast<char *>(StartAddr) + bucket.SlabMinSize();
-
-    regSlabByAddr(StartAddr, Slab);
-    regSlabByAddr(EndAddr, Slab);
-}
-
-void Slab::unregSlab(Slab &Slab) {
-    void *StartAddr = AlignPtrDown(Slab.getPtr(), bucket.SlabMinSize());
-    void *EndAddr = static_cast<char *>(StartAddr) + bucket.SlabMinSize();
-
-    unregSlabByAddr(StartAddr, Slab);
-    unregSlabByAddr(EndAddr, Slab);
-}
-
-void Slab::freeChunk(void *Ptr) {
-    // This method should be called through bucket(since we might remove the slab
-    // as a result), therefore all locks are done on that level.
-
-    // Make sure that we're in the right slab
-    assert(Ptr >= getPtr() && Ptr < getEnd());
-
-    // Even if the pointer p was previously aligned, it's still inside the
-    // corresponding chunk, so we get the correct index here.
-    auto ChunkIdx = (static_cast<char *>(Ptr) - static_cast<char *>(MemPtr)) /
-                    getChunkSize();
-
-    // Make sure that the chunk was allocated
-    assert(Chunks[ChunkIdx] && "double free detected");
-
-    Chunks[ChunkIdx] = false;
-    NumAllocated -= 1;
-
-    if (ChunkIdx < FirstFreeChunkIdx) {
-        FirstFreeChunkIdx = ChunkIdx;
-    }
-}
-
-void *Slab::getEnd() const {
-    return static_cast<char *>(getPtr()) + bucket.SlabMinSize();
-}
-
-bool Slab::hasAvail() { return NumAllocated != getNumChunks(); }
-
-// If a slab was available in the pool then note that the current pooled
-// size has reduced by the size of a slab in this bucket.
-void Bucket::decrementPool(bool &FromPool) {
-    FromPool = true;
-    updateStats(1, -1);
-    OwnAllocCtx.getLimits()->TotalSize -= SlabAllocSize();
-}
-
-auto Bucket::getAvailFullSlab(bool &FromPool)
-    -> decltype(AvailableSlabs.begin()) {
-    // Return a slab that will be used for a single allocation.
-    if (AvailableSlabs.size() == 0) {
-        auto It = AvailableSlabs.insert(AvailableSlabs.begin(),
-                                        std::make_unique<Slab>(*this));
-        (*It)->setIterator(It);
-        FromPool = false;
-        updateStats(1, 0);
-    } else {
-        decrementPool(FromPool);
-    }
-
-    return AvailableSlabs.begin();
-}
-
-void *Bucket::getSlab(bool &FromPool) {
-    std::lock_guard<std::mutex> Lg(BucketLock);
-
-    auto SlabIt = getAvailFullSlab(FromPool);
-    auto *FreeSlab = (*SlabIt)->getSlab();
-    auto It =
-        UnavailableSlabs.insert(UnavailableSlabs.begin(), std::move(*SlabIt));
-    AvailableSlabs.erase(SlabIt);
-    (*It)->setIterator(It);
-    return FreeSlab;
-}
-
-void Bucket::freeSlab(Slab &Slab, bool &ToPool) {
-    std::lock_guard<std::mutex> Lg(BucketLock);
-    auto SlabIter = Slab.getIterator();
-    assert(SlabIter != UnavailableSlabs.end());
-    if (CanPool(ToPool)) {
-        auto It =
-            AvailableSlabs.insert(AvailableSlabs.begin(), std::move(*SlabIter));
-        UnavailableSlabs.erase(SlabIter);
-        (*It)->setIterator(It);
-    } else {
-        UnavailableSlabs.erase(SlabIter);
-    }
-}
-
-auto Bucket::getAvailSlab(bool &FromPool) -> decltype(AvailableSlabs.begin()) {
-
-    if (AvailableSlabs.size() == 0) {
-        auto It = AvailableSlabs.insert(AvailableSlabs.begin(),
-                                        std::make_unique<Slab>(*this));
-        (*It)->setIterator(It);
-
-        updateStats(1, 0);
-        FromPool = false;
-    } else {
-        if ((*(AvailableSlabs.begin()))->getNumAllocated() == 0) {
-            // If this was an empty slab, it was in the pool.
-            // Now it is no longer in the pool, so update count.
-            --chunkedSlabsInPool;
-            decrementPool(FromPool);
-        } else {
-            // Allocation from existing slab is treated as from pool for statistics.
-            FromPool = true;
-        }
-    }
-
-    return AvailableSlabs.begin();
-}
-
-void *Bucket::getChunk(bool &FromPool) {
-    std::lock_guard<std::mutex> Lg(BucketLock);
-
-    auto SlabIt = getAvailSlab(FromPool);
-    auto *FreeChunk = (*SlabIt)->getChunk();
-
-    // If the slab is full, move it to unavailable slabs and update its iterator
-    if (!((*SlabIt)->hasAvail())) {
-        auto It = UnavailableSlabs.insert(UnavailableSlabs.begin(),
-                                          std::move(*SlabIt));
-        AvailableSlabs.erase(SlabIt);
-        (*It)->setIterator(It);
-    }
-
-    return FreeChunk;
-}
-
-void Bucket::freeChunk(void *Ptr, Slab &Slab, bool &ToPool) {
-    std::lock_guard<std::mutex> Lg(BucketLock);
-
-    Slab.freeChunk(Ptr);
-
-    onFreeChunk(Slab, ToPool);
-}
-
-// The lock must be acquired before calling this method
-void Bucket::onFreeChunk(Slab &Slab, bool &ToPool) {
-    ToPool = true;
-
-    // In case if the slab was previously full and now has 1 available
-    // chunk, it should be moved to the list of available slabs
-    if (Slab.getNumAllocated() == (Slab.getNumChunks() - 1)) {
-        auto SlabIter = Slab.getIterator();
-        assert(SlabIter != UnavailableSlabs.end());
-
-        auto It =
-            AvailableSlabs.insert(AvailableSlabs.begin(), std::move(*SlabIter));
-        UnavailableSlabs.erase(SlabIter);
-
-        (*It)->setIterator(It);
-    }
-
-    // Check if slab is empty, and pool it if we can.
-    if (Slab.getNumAllocated() == 0) {
-        // The slab is now empty.
-        // If pool has capacity then put the slab in the pool.
-        // The ToPool parameter indicates whether the Slab will be put in the
-        // pool or freed.
-        if (!CanPool(ToPool)) {
-            // Note: since the slab is stored as unique_ptr, just remove it from
-            // the list to destroy the object.
-            auto It = Slab.getIterator();
-            assert(It != AvailableSlabs.end());
-            AvailableSlabs.erase(It);
-        }
-    }
-}
-
-bool Bucket::CanPool(bool &ToPool) {
-    size_t NewFreeSlabsInBucket;
-    // Check if this bucket is used in chunked form or as full slabs.
-    bool chunkedBucket = getSize() <= ChunkCutOff();
-    if (chunkedBucket) {
-        NewFreeSlabsInBucket = chunkedSlabsInPool + 1;
-    } else {
-        NewFreeSlabsInBucket = AvailableSlabs.size() + 1;
-    }
-    if (Capacity() >= NewFreeSlabsInBucket) {
-        size_t PoolSize = OwnAllocCtx.getLimits()->TotalSize;
-        while (true) {
-            size_t NewPoolSize = PoolSize + SlabAllocSize();
-
-            if (OwnAllocCtx.getLimits()->MaxSize < NewPoolSize) {
-                break;
-            }
-
-            if (OwnAllocCtx.getLimits()->TotalSize.compare_exchange_strong(
-                    PoolSize, NewPoolSize)) {
-                if (chunkedBucket) {
-                    ++chunkedSlabsInPool;
-                }
-
-                updateStats(-1, 1);
-                ToPool = true;
-                return true;
-            }
-        }
-    }
-
-    updateStats(-1, 0);
-    ToPool = false;
-    return false;
-}
-
-umf_memory_provider_handle_t Bucket::getMemHandle() {
-    return OwnAllocCtx.getMemHandle();
-}
-
-size_t Bucket::SlabMinSize() { return OwnAllocCtx.getParams().SlabMinSize; }
-
-size_t Bucket::SlabAllocSize() { return std::max(getSize(), SlabMinSize()); }
-
-size_t Bucket::Capacity() {
-    // For buckets used in chunked mode, just one slab in pool is sufficient.
-    // For larger buckets, the capacity could be more and is adjustable.
-    if (getSize() <= ChunkCutOff()) {
-        return 1;
-    } else {
-        return OwnAllocCtx.getParams().Capacity;
-    }
-}
-
-size_t Bucket::MaxPoolableSize() {
-    return OwnAllocCtx.getParams().MaxPoolableSize;
-}
-
-size_t Bucket::ChunkCutOff() { return SlabMinSize() / 2; }
-
-void Bucket::countAlloc(bool FromPool) {
-    ++allocCount;
-    if (FromPool) {
-        ++allocPoolCount;
-    }
-}
-
-void Bucket::countFree() { ++freeCount; }
-
-void Bucket::updateStats(int InUse, int InPool) {
-    if (OwnAllocCtx.getParams().PoolTrace == 0) {
-        return;
-    }
-    currSlabsInUse += InUse;
-    maxSlabsInUse = std::max(currSlabsInUse, maxSlabsInUse);
-    currSlabsInPool += InPool;
-    maxSlabsInPool = std::max(currSlabsInPool, maxSlabsInPool);
-    // Increment or decrement current pool sizes based on whether
-    // slab was added to or removed from pool.
-    OwnAllocCtx.getParams().CurPoolSize += InPool * SlabAllocSize();
-}
-
-void Bucket::printStats(bool &TitlePrinted, const std::string &Label) {
-    if (allocCount) {
-        if (!TitlePrinted) {
-            std::cout << Label << " memory statistics\n";
-            std::cout << std::setw(14) << "Bucket Size" << std::setw(12)
-                      << "Allocs" << std::setw(12) << "Frees" << std::setw(18)
-                      << "Allocs from Pool" << std::setw(20)
-                      << "Peak Slabs in Use" << std::setw(21)
-                      << "Peak Slabs in Pool" << std::endl;
-            TitlePrinted = true;
-        }
-        std::cout << std::setw(14) << getSize() << std::setw(12) << allocCount
-                  << std::setw(12) << freeCount << std::setw(18)
-                  << allocPoolCount << std::setw(20) << maxSlabsInUse
-                  << std::setw(21) << maxSlabsInPool << std::endl;
-    }
-}
-
-void *DisjointPool::AllocImpl::allocate(size_t Size, bool &FromPool) try {
-    void *Ptr;
-
-    if (Size == 0) {
-        return nullptr;
-    }
-
-    FromPool = false;
-    if (Size > getParams().MaxPoolableSize) {
-        Ptr = memoryProviderAlloc(getMemHandle(), Size);
-        annotate_memory_undefined(Ptr, Size);
-        return Ptr;
-    }
-
-    auto &Bucket = findBucket(Size);
-
-    if (Size > Bucket.ChunkCutOff()) {
-        Ptr = Bucket.getSlab(FromPool);
-    } else {
-        Ptr = Bucket.getChunk(FromPool);
-    }
-
-    if (getParams().PoolTrace > 1) {
-        Bucket.countAlloc(FromPool);
-    }
-
-    VALGRIND_DO_MEMPOOL_ALLOC(this, Ptr, Size);
-    annotate_memory_undefined(Ptr, Bucket.getSize());
-
-    return Ptr;
-} catch (MemoryProviderError &e) {
-    umf::getPoolLastStatusRef<DisjointPool>() = e.code;
-    return nullptr;
-}
-
-void *DisjointPool::AllocImpl::allocate(size_t Size, size_t Alignment,
-                                        bool &FromPool) try {
-    void *Ptr;
-
-    if (Size == 0) {
-        return nullptr;
-    }
-
-    if (Alignment <= 1) {
-        return allocate(Size, FromPool);
-    }
-
-    size_t AlignedSize;
-    if (Alignment <= ProviderMinPageSize) {
-        // This allocation will be served from a Bucket which size is multiple
-        // of Alignment and Slab address is aligned to ProviderMinPageSize
-        // so the address will be properly aligned.
-        AlignedSize = (Size > 1) ? AlignUp(Size, Alignment) : Alignment;
-    } else {
-        // Slabs are only aligned to ProviderMinPageSize, we need to compensate
-        // for that in case the allocation is within pooling limit.
-        // TODO: consider creating properly-aligned Slabs on demand
-        AlignedSize = Size + Alignment - 1;
-    }
-
-    // Check if requested allocation size is within pooling limit.
-    // If not, just request aligned pointer from the system.
-    FromPool = false;
-    if (AlignedSize > getParams().MaxPoolableSize) {
-        Ptr = memoryProviderAlloc(getMemHandle(), Size, Alignment);
-        annotate_memory_undefined(Ptr, Size);
-        return Ptr;
-    }
-
-    auto &Bucket = findBucket(AlignedSize);
-
-    if (AlignedSize > Bucket.ChunkCutOff()) {
-        Ptr = Bucket.getSlab(FromPool);
-    } else {
-        Ptr = Bucket.getChunk(FromPool);
-    }
-
-    if (getParams().PoolTrace > 1) {
-        Bucket.countAlloc(FromPool);
-    }
-
-    VALGRIND_DO_MEMPOOL_ALLOC(this, AlignPtrUp(Ptr, Alignment), Size);
-    annotate_memory_undefined(AlignPtrUp(Ptr, Alignment), Size);
-    return AlignPtrUp(Ptr, Alignment);
-} catch (MemoryProviderError &e) {
-    umf::getPoolLastStatusRef<DisjointPool>() = e.code;
-    return nullptr;
-}
-
-std::size_t DisjointPool::AllocImpl::sizeToIdx(size_t Size) {
-    assert(Size <= CutOff && "Unexpected size");
-    assert(Size > 0 && "Unexpected size");
-
-    size_t MinBucketSize = (size_t)1 << MinBucketSizeExp;
-    if (Size < MinBucketSize) {
-        return 0;
-    }
-
-    // Get the position of the leftmost set bit.
-    size_t position = getLeftmostSetBitPos(Size);
-
-    auto isPowerOf2 = 0 == (Size & (Size - 1));
-    auto largerThanHalfwayBetweenPowersOf2 =
-        !isPowerOf2 && bool((Size - 1) & (uint64_t(1) << (position - 1)));
-    auto index = (position - MinBucketSizeExp) * 2 + (int)(!isPowerOf2) +
-                 (int)largerThanHalfwayBetweenPowersOf2;
-
-    return index;
-}
-
-Bucket &DisjointPool::AllocImpl::findBucket(size_t Size) {
-    auto calculatedIdx = sizeToIdx(Size);
-    assert((*(Buckets[calculatedIdx])).getSize() >= Size);
-    if (calculatedIdx > 0) {
-        assert((*(Buckets[calculatedIdx - 1])).getSize() < Size);
-    }
-
-    return *(Buckets[calculatedIdx]);
-}
-
-void DisjointPool::AllocImpl::deallocate(void *Ptr, bool &ToPool) {
-    auto *SlabPtr = AlignPtrDown(Ptr, SlabMinSize());
-
-    // Lock the map on read
-    std::shared_lock<std::shared_timed_mutex> Lk(getKnownSlabsMapLock());
-
-    ToPool = false;
-    auto Slabs = getKnownSlabs().equal_range(SlabPtr);
-    if (Slabs.first == Slabs.second) {
-        Lk.unlock();
-        memoryProviderFree(getMemHandle(), Ptr);
-        return;
-    }
-
-    for (auto It = Slabs.first; It != Slabs.second; ++It) {
-        // The slab object won't be deleted until it's removed from the map which is
-        // protected by the lock, so it's safe to access it here.
-        auto &Slab = It->second;
-        if (Ptr >= Slab.getPtr() && Ptr < Slab.getEnd()) {
-            // Unlock the map before freeing the chunk, it may be locked on write
-            // there
-            Lk.unlock();
-            auto &Bucket = Slab.getBucket();
-
-            if (getParams().PoolTrace > 1) {
-                Bucket.countFree();
-            }
-
-            VALGRIND_DO_MEMPOOL_FREE(this, Ptr);
-            annotate_memory_inaccessible(Ptr, Bucket.getSize());
-            if (Bucket.getSize() <= Bucket.ChunkCutOff()) {
-                Bucket.freeChunk(Ptr, Slab, ToPool);
-            } else {
-                Bucket.freeSlab(Slab, ToPool);
-            }
-
-            return;
-        }
-    }
-
-    Lk.unlock();
-    // There is a rare case when we have a pointer from system allocation next
-    // to some slab with an entry in the map. So we find a slab
-    // but the range checks fail.
-    memoryProviderFree(getMemHandle(), Ptr);
-}
-
-void DisjointPool::AllocImpl::printStats(bool &TitlePrinted,
-                                         size_t &HighBucketSize,
-                                         size_t &HighPeakSlabsInUse,
-                                         const std::string &MTName) {
-    HighBucketSize = 0;
-    HighPeakSlabsInUse = 0;
-    for (auto &B : Buckets) {
-        (*B).printStats(TitlePrinted, MTName);
-        HighPeakSlabsInUse = std::max((*B).maxSlabsInUse, HighPeakSlabsInUse);
-        if ((*B).allocCount) {
-            HighBucketSize = std::max((*B).SlabAllocSize(), HighBucketSize);
-        }
-    }
-}
-
-umf_result_t DisjointPool::initialize(umf_memory_provider_handle_t provider,
-                                      umf_disjoint_pool_params_t *parameters) {
-    if (!provider) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-    // MinBucketSize parameter must be a power of 2 for bucket sizes
-    // to generate correctly.
-    if (!parameters->MinBucketSize ||
-        !((parameters->MinBucketSize & (parameters->MinBucketSize - 1)) == 0)) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    impl = std::make_unique<AllocImpl>(provider, parameters);
-    return UMF_RESULT_SUCCESS;
-}
-
-void *DisjointPool::malloc(size_t size) { // For full-slab allocations indicates
-                                          // whether slab is from Pool.
-    bool FromPool;
-    auto Ptr = impl->allocate(size, FromPool);
-
-    if (impl->getParams().PoolTrace > 2) {
-        auto MT = impl->getParams().Name;
-        std::cout << "Allocated " << std::setw(8) << size << " " << MT
-                  << " bytes from " << (FromPool ? "Pool" : "Provider") << " ->"
-                  << Ptr << std::endl;
-    }
-    return Ptr;
-}
-
-void *DisjointPool::calloc(size_t, size_t) {
-    // Not supported
-    umf::getPoolLastStatusRef<DisjointPool>() = UMF_RESULT_ERROR_NOT_SUPPORTED;
-    return NULL;
-}
-
-void *DisjointPool::realloc(void *, size_t) {
-    // Not supported
-    umf::getPoolLastStatusRef<DisjointPool>() = UMF_RESULT_ERROR_NOT_SUPPORTED;
-    return NULL;
-}
-
-void *DisjointPool::aligned_malloc(size_t size, size_t alignment) {
-    bool FromPool;
-    auto Ptr = impl->allocate(size, alignment, FromPool);
-
-    if (impl->getParams().PoolTrace > 2) {
-        auto MT = impl->getParams().Name;
-        std::cout << "Allocated " << std::setw(8) << size << " " << MT
-                  << " bytes aligned at " << alignment << " from "
-                  << (FromPool ? "Pool" : "Provider") << " ->" << Ptr
-                  << std::endl;
-    }
-    return Ptr;
-}
-
-size_t DisjointPool::malloc_usable_size(void *) {
-    // Not supported
-    return 0;
-}
-
-umf_result_t DisjointPool::free(void *ptr) try {
-    bool ToPool;
-    impl->deallocate(ptr, ToPool);
-
-    if (impl->getParams().PoolTrace > 2) {
-        auto MT = impl->getParams().Name;
-        std::cout << "Freed " << MT << " " << ptr << " to "
-                  << (ToPool ? "Pool" : "Provider")
-                  << ", Current total pool size "
-                  << impl->getLimits()->TotalSize.load()
-                  << ", Current pool size for " << MT << " "
-                  << impl->getParams().CurPoolSize << "\n";
-    }
-    return UMF_RESULT_SUCCESS;
-} catch (MemoryProviderError &e) {
-    return e.code;
-}
-
-umf_result_t DisjointPool::get_last_allocation_error() {
-    return umf::getPoolLastStatusRef<DisjointPool>();
-}
-
-DisjointPool::DisjointPool() {}
-
-// Define destructor for use with unique_ptr
-DisjointPool::~DisjointPool() {
-    bool TitlePrinted = false;
-    size_t HighBucketSize;
-    size_t HighPeakSlabsInUse;
-    if (impl->getParams().PoolTrace > 1) {
-        auto name = impl->getParams().Name;
-        try { // cannot throw in destructor
-            impl->printStats(TitlePrinted, HighBucketSize, HighPeakSlabsInUse,
-                             name);
-            if (TitlePrinted) {
-                std::cout << "Current Pool Size "
-                          << impl->getLimits()->TotalSize.load() << std::endl;
-                std::cout << "Suggested Setting=;"
-                          << std::string(1, (char)tolower(name[0]))
-                          << std::string(name + 1) << ":" << HighBucketSize
-                          << "," << HighPeakSlabsInUse << ",64K" << std::endl;
-            }
-        } catch (...) { // ignore exceptions
-        }
-    }
-}
-
-static umf_memory_pool_ops_t UMF_DISJOINT_POOL_OPS =
-    umf::poolMakeCOps<DisjointPool, umf_disjoint_pool_params_t>();
-
-umf_memory_pool_ops_t *umfDisjointPoolOps(void) {
-    return &UMF_DISJOINT_POOL_OPS;
-}
diff --git a/src/pool/pool_disjoint_internal.h b/src/pool/pool_disjoint_internal.h
new file mode 100644
index 000000000..7a63dd72a
--- /dev/null
+++ b/src/pool/pool_disjoint_internal.h
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#ifndef UMF_POOL_DISJOINT_INTERNAL_H
+#define UMF_POOL_DISJOINT_INTERNAL_H 1
+
+#include <stdbool.h>
+
+#include <umf/pools/pool_disjoint.h>
+
+#include "critnib/critnib.h"
+#include "utils_concurrency.h"
+
+#define CHUNK_BITMAP_SIZE 64
+
+typedef struct bucket_t bucket_t;
+typedef struct slab_t slab_t;
+typedef struct slab_list_item_t slab_list_item_t;
+typedef struct disjoint_pool_t disjoint_pool_t;
+
+typedef struct bucket_t {
+    size_t size;
+
+    // Linked list of slabs which have at least 1 available chunk.
+    // We always count available slabs as an optimization.
+    slab_list_item_t *available_slabs;
+    size_t available_slabs_num;
+
+    // Linked list of slabs with 0 available chunks
+    slab_list_item_t *unavailable_slabs;
+
+    // Protects the bucket and all the corresponding slabs
+    utils_mutex_t bucket_lock;
+
+    // Reference to the allocator context, used to access memory allocation
+    // routines, slab map and etc.
+    disjoint_pool_t *pool;
+
+    umf_disjoint_pool_shared_limits_handle_t shared_limits;
+
+    // For buckets used in chunked mode, a counter of slabs in the pool.
+    // For allocations that use an entire slab each, the entries in the
+    // "available" list are entries in the pool. Each slab is available for a
+    // new allocation. The size of the available list is the size of the pool.
+    //
+    // For allocations that use slabs in chunked mode, slabs will be in the
+    // "available" list if any one or more of their chunks are free. The entire
+    // slab is not necessarily free, just some chunks in the slab are free. To
+    // implement pooling, we will allow one slab in the "available" list to be
+    // entirely empty, and treat this slab as "in the pool".
+    // When a slab becomes entirely free, we must decide whether to return it
+    // to the provider or keep it allocated. We keep a counter of entirely
+    // empty slabs within the "available" list to speed up the process of
+    // checking if a slab in this bucket is already pooled.
+    size_t chunked_slabs_in_pool;
+
+    // Statistics
+    size_t alloc_count;
+    size_t alloc_pool_count;
+    size_t free_count;
+    size_t curr_slabs_in_use;
+    size_t curr_slabs_in_pool;
+    size_t max_slabs_in_pool;
+    size_t max_slabs_in_use;
+} bucket_t;
+
+typedef struct slab_list_item_t {
+    slab_t *val;
+    struct slab_list_item_t *prev, *next;
+} slab_list_item_t;
+
+// Represents the allocated memory block of size 'slab_min_size'
+// Internally, it splits the memory block into chunks. The number of
+// chunks depends on the size of a Bucket which created the Slab.
+// Note: Bucket's methods are responsible for thread safety of Slab access,
+// so no locking happens here.
+typedef struct slab_t {
+    // Pointer to the allocated memory of slab_min_size bytes
+    void *mem_ptr;
+    size_t slab_size;
+
+    size_t num_chunks_total;
+
+    // Num of 64-bit words needed to store chunk state
+    size_t num_words;
+
+    // Total number of allocated chunks at the moment.
+    size_t num_chunks_allocated;
+
+    // The bucket which the slab belongs to
+    bucket_t *bucket;
+
+    // Store iterator to the corresponding node in avail/unavail list
+    // to achieve O(1) removal
+    slab_list_item_t iter;
+
+    // Represents the current state of each chunk: if the bit is clear, the
+    // chunk is allocated; otherwise, the chunk is free for allocation
+    uint64_t chunks[];
+} slab_t;
+
+typedef struct umf_disjoint_pool_shared_limits_t {
+    size_t max_size;
+    uint64_t total_size; // requires atomic access
+} umf_disjoint_pool_shared_limits_t;
+
+typedef struct umf_disjoint_pool_params_t {
+    // Minimum allocation size that will be requested from the memory provider.
+    size_t slab_min_size;
+
+    // Allocations up to this limit will be subject to chunking/pooling
+    size_t max_poolable_size;
+
+    // When pooling, each bucket will hold a max of 'capacity' unfreed slabs
+    size_t capacity;
+
+    // Holds the minimum bucket size valid for allocation of a memory type.
+    // This value must be a power of 2.
+    size_t min_bucket_size;
+
+    // Holds size of the pool managed by the allocator.
+    size_t cur_pool_size;
+
+    // Whether to print pool usage statistics
+    int pool_trace;
+
+    // Memory limits that can be shared between multiple pool instances,
+    // i.e. if multiple pools use the same shared_limits sum of those pools'
+    // sizes cannot exceed max_size.
+    umf_disjoint_pool_shared_limits_handle_t shared_limits;
+
+    // Name used in traces
+    char name[64];
+} umf_disjoint_pool_params_t;
+
+typedef struct disjoint_pool_t {
+    // Keep the list of known slabs to quickly find required one during the
+    // free()
+    critnib *known_slabs; // (void *, slab_t *)
+
+    // Handle to the memory provider
+    umf_memory_provider_handle_t provider;
+
+    // Array of bucket_t*
+    bucket_t **buckets;
+    size_t buckets_num;
+
+    // Configuration for this instance
+    umf_disjoint_pool_params_t params;
+
+    umf_disjoint_pool_shared_limits_handle_t default_shared_limits;
+
+    // Used in algorithm for finding buckets
+    size_t min_bucket_size_exp;
+
+    // Coarse-grain allocation min alignment
+    size_t provider_min_page_size;
+} disjoint_pool_t;
+
+static inline void slab_set_chunk_bit(slab_t *slab, size_t index, bool value) {
+    assert(index < slab->num_chunks_total && "Index out of range");
+
+    size_t word_index = index / CHUNK_BITMAP_SIZE;
+    unsigned bit_index = index % CHUNK_BITMAP_SIZE;
+    if (value) {
+        slab->chunks[word_index] |= (1ULL << bit_index);
+    } else {
+        slab->chunks[word_index] &= ~(1ULL << bit_index);
+    }
+}
+
+static inline int slab_read_chunk_bit(const slab_t *slab, size_t index) {
+    assert(index < slab->num_chunks_total && "Index out of range");
+
+    size_t word_index = index / CHUNK_BITMAP_SIZE;
+    unsigned bit_index = index % CHUNK_BITMAP_SIZE;
+    return (slab->chunks[word_index] >> bit_index) & 1;
+}
+
+#endif // UMF_POOL_DISJOINT_INTERNAL_H
diff --git a/src/pool/pool_jemalloc.c b/src/pool/pool_jemalloc.c
index 094ceeaf7..8d6a2daf2 100644
--- a/src/pool/pool_jemalloc.c
+++ b/src/pool/pool_jemalloc.c
@@ -1,11 +1,12 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 */
 
 #include <assert.h>
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -20,25 +21,43 @@
 #include <umf/memory_pool_ops.h>
 #include <umf/pools/pool_jemalloc.h>
 
-#include <jemalloc/jemalloc.h>
+#ifndef UMF_POOL_JEMALLOC_ENABLED
 
-// The Windows version of jemalloc uses API with je_ prefix,
-// while the Linux one does not.
-#ifndef _WIN32
-#define je_mallocx mallocx
-#define je_dallocx dallocx
-#define je_rallocx rallocx
-#define je_mallctl mallctl
-#define je_malloc_usable_size malloc_usable_size
-#endif
+const umf_memory_pool_ops_t *umfJemallocPoolOps(void) { return NULL; }
+umf_result_t
+umfJemallocPoolParamsCreate(umf_jemalloc_pool_params_handle_t *hParams) {
+    (void)hParams; // unused
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t
+umfJemallocPoolParamsDestroy(umf_jemalloc_pool_params_handle_t hParams) {
+    (void)hParams; // unused
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t
+umfJemallocPoolParamsSetNumArenas(umf_jemalloc_pool_params_handle_t hParams,
+                                  size_t numArenas) {
+    (void)hParams;   // unused
+    (void)numArenas; // unused
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+#else
+
+#include <jemalloc/jemalloc.h>
 
 #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
-    // set to true if umfMemoryProviderFree() should never be called
-    bool disable_provider_free;
+    size_t n_arenas;
+    unsigned int arena_index[];
 } jemalloc_memory_pool_t;
 
 static __TLS umf_result_t TLS_last_allocation_error;
@@ -53,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
@@ -82,9 +109,7 @@ static void *arena_extent_alloc(extent_hooks_t *extent_hooks, void *new_addr,
     }
 
     if (new_addr != NULL && ptr != new_addr) {
-        if (!pool->disable_provider_free) {
-            umfMemoryProviderFree(pool->provider, ptr, size);
-        }
+        umfMemoryProviderFree(pool->provider, ptr, size);
         return NULL;
     }
 
@@ -118,10 +143,6 @@ static void arena_extent_destroy(extent_hooks_t *extent_hooks, void *addr,
 
     jemalloc_memory_pool_t *pool = get_pool_by_arena_index(arena_ind);
 
-    if (pool->disable_provider_free) {
-        return;
-    }
-
     umf_result_t ret;
     ret = umfMemoryProviderFree(pool->provider, addr, size);
     if (ret != UMF_RESULT_SUCCESS) {
@@ -144,10 +165,6 @@ static bool arena_extent_dalloc(extent_hooks_t *extent_hooks, void *addr,
 
     jemalloc_memory_pool_t *pool = get_pool_by_arena_index(arena_ind);
 
-    if (pool->disable_provider_free) {
-        return true; // opt-out from deallocation
-    }
-
     umf_result_t ret;
     ret = umfMemoryProviderFree(pool->provider, addr, size);
     if (ret != UMF_RESULT_SUCCESS) {
@@ -203,7 +220,7 @@ static bool arena_extent_decommit(extent_hooks_t *extent_hooks, void *addr,
 // physical pages within the virtual memory mapping associated with an extent at given addr and size
 // at offset bytes, extending for length on behalf of arena arena_ind. A lazy extent purge function
 // (e.g. implemented via madvise(...MADV_FREE)) can delay purging indefinitely and leave the pages
-// within the purged virtual memory range in an indeterminite state, whereas a forced extent purge
+// within the purged virtual memory range in an indeterminate state, whereas a forced extent purge
 // function immediately purges, and the pages within the virtual memory range will be zero-filled
 // the next time they are accessed. If the function returns true, this indicates failure to purge.
 // (from https://jemalloc.net/jemalloc.3.html)
@@ -301,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;
@@ -359,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;
@@ -380,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 =
@@ -397,79 +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) {
+                                  const void *params, void **out_pool) {
     assert(provider);
     assert(out_pool);
 
-    umf_jemalloc_pool_params_t *je_params =
-        (umf_jemalloc_pool_params_t *)params;
-
     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;
-
-    if (je_params) {
-        pool->disable_provider_free = je_params->disable_provider_free;
-    } else {
-        pool->disable_provider_free = false;
+    if (n_arenas == 0) {
+        n_arenas = utils_get_num_cores() * 4;
+        if (n_arenas > MALLOCX_ARENA_MAX) {
+            n_arenas = MALLOCX_ARENA_MAX;
+        }
     }
 
-    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 > MALLOCX_ARENA_MAX) {
+        LOG_ERR("Number of arenas %zu exceeds the limit (%i).", n_arenas,
+                MALLOCX_ARENA_MAX);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    // setup extent_hooks for newly created arena
-    char cmd[64];
-    snprintf(cmd, sizeof(cmd), "arena.%u.extent_hooks", arena_index);
-    err = je_mallctl(cmd, NULL, NULL, (void *)&pHooks, sizeof(void *));
-    if (err) {
-        snprintf(cmd, sizeof(cmd), "arena.%u.destroy", arena_index);
-        je_mallctl(cmd, NULL, 0, NULL, 0);
-        LOG_ERR("Could not setup extent_hooks for newly created arena.");
-        goto err_free_pool;
+    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->arena_index = arena_index;
-    pool_by_arena_index[arena_index] = pool;
+    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);
-    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) {
@@ -478,7 +553,7 @@ static umf_result_t op_get_last_allocation_error(void *pool) {
 }
 
 static umf_memory_pool_ops_t UMF_JEMALLOC_POOL_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_POOL_OPS_VERSION_CURRENT,
     .initialize = op_initialize,
     .finalize = op_finalize,
     .malloc = op_malloc,
@@ -490,6 +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 2269d9344..208b46d4c 100644
--- a/src/pool/pool_proxy.c
+++ b/src/pool/pool_proxy.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -23,8 +23,8 @@ struct proxy_memory_pool {
 };
 
 static umf_result_t
-proxy_pool_initialize(umf_memory_provider_handle_t hProvider, void *params,
-                      void **ppPool) {
+proxy_pool_initialize(umf_memory_provider_handle_t hProvider,
+                      const void *params, void **ppPool) {
     (void)params; // unused
 
     struct proxy_memory_pool *pool =
@@ -39,7 +39,10 @@ proxy_pool_initialize(umf_memory_provider_handle_t hProvider, void *params,
     return UMF_RESULT_SUCCESS;
 }
 
-static void proxy_pool_finalize(void *pool) { umf_ba_global_free(pool); }
+static umf_result_t proxy_pool_finalize(void *pool) {
+    umf_ba_global_free(pool);
+    return UMF_RESULT_SUCCESS;
+}
 
 static void *proxy_aligned_malloc(void *pool, size_t size, size_t alignment) {
     assert(pool);
@@ -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;
@@ -123,7 +126,7 @@ static umf_result_t proxy_get_last_allocation_error(void *pool) {
 }
 
 static umf_memory_pool_ops_t UMF_PROXY_POOL_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_POOL_OPS_VERSION_CURRENT,
     .initialize = proxy_pool_initialize,
     .finalize = proxy_pool_finalize,
     .malloc = proxy_malloc,
@@ -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 cb5d5b157..fa63351c2 100644
--- a/src/pool/pool_scalable.c
+++ b/src/pool/pool_scalable.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -13,12 +13,16 @@
 #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>
 #include <umf/pools/pool_scalable.h>
 
 #include "base_alloc_global.h"
+#include "libumf.h"
+#include "pool_scalable_internal.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
 #include "utils_load_library.h"
@@ -31,6 +35,8 @@ typedef void (*raw_free_tbb_type)(intptr_t, void *, size_t);
 static __TLS umf_result_t TLS_last_allocation_error;
 static __TLS umf_result_t TLS_last_free_error;
 
+static const size_t DEFAULT_GRANULARITY = 2 * 1024 * 1024; // 2MB
+
 typedef struct tbb_mem_pool_policy_t {
     raw_alloc_tbb_type pAlloc;
     raw_free_tbb_type pFree;
@@ -39,6 +45,11 @@ typedef struct tbb_mem_pool_policy_t {
     unsigned fixed_pool : 1, keep_all_memory : 1, reserved : 30;
 } tbb_mem_pool_policy_t;
 
+typedef struct umf_scalable_pool_params_t {
+    size_t granularity;
+    bool keep_all_memory;
+} umf_scalable_pool_params_t;
+
 typedef struct tbb_callbacks_t {
     void *(*pool_malloc)(void *, size_t);
     void *(*pool_realloc)(void *, void *, size_t);
@@ -59,7 +70,6 @@ typedef struct tbb_callbacks_t {
 typedef struct tbb_memory_pool_t {
     umf_memory_provider_handle_t mem_provider;
     void *tbb_pool;
-    tbb_callbacks_t tbb_callbacks;
 } tbb_memory_pool_t;
 
 typedef enum tbb_enums_t {
@@ -75,6 +85,10 @@ typedef enum tbb_enums_t {
     TBB_POOL_SYMBOLS_MAX // it has to be the last one
 } tbb_enums_t;
 
+static UTIL_ONCE_FLAG tbb_initialized = UTIL_ONCE_FLAG_INIT;
+static int tbb_init_result = 0;
+static tbb_callbacks_t tbb_callbacks = {0};
+
 static const char *tbb_symbol[TBB_POOL_SYMBOLS_MAX] = {
 #ifdef _WIN32
     // symbols copied from oneTBB/src/tbbmalloc/def/win64-tbbmalloc.def
@@ -102,46 +116,64 @@ static const char *tbb_symbol[TBB_POOL_SYMBOLS_MAX] = {
 #endif
 };
 
-static int init_tbb_callbacks(tbb_callbacks_t *tbb_callbacks) {
-    assert(tbb_callbacks);
+struct ctl pool_scallable_ctl_root;
 
+static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT;
+
+static void init_tbb_callbacks_once(void) {
     const char *lib_name = tbb_symbol[TBB_LIB_NAME];
-    tbb_callbacks->lib_handle = util_open_library(lib_name, 0);
-    if (!tbb_callbacks->lib_handle) {
+    tbb_callbacks.lib_handle = utils_open_library(lib_name, 0);
+    if (!tbb_callbacks.lib_handle) {
         LOG_ERR("%s required by Scalable Pool not found - install TBB malloc "
                 "or make sure it is in the default search paths.",
                 lib_name);
-        return -1;
+        tbb_init_result = -1;
+        return;
     }
-
-    *(void **)&tbb_callbacks->pool_malloc = util_get_symbol_addr(
-        tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_MALLOC], lib_name);
-    *(void **)&tbb_callbacks->pool_realloc = util_get_symbol_addr(
-        tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_REALLOC], lib_name);
-    *(void **)&tbb_callbacks->pool_aligned_malloc =
-        util_get_symbol_addr(tbb_callbacks->lib_handle,
-                             tbb_symbol[TBB_POOL_ALIGNED_MALLOC], lib_name);
-    *(void **)&tbb_callbacks->pool_free = util_get_symbol_addr(
-        tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_FREE], lib_name);
-    *(void **)&tbb_callbacks->pool_create_v1 = util_get_symbol_addr(
-        tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_CREATE_V1], lib_name);
-    *(void **)&tbb_callbacks->pool_destroy = util_get_symbol_addr(
-        tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_DESTROY], lib_name);
-    *(void **)&tbb_callbacks->pool_identify = util_get_symbol_addr(
-        tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_IDENTIFY], lib_name);
-    *(void **)&tbb_callbacks->pool_msize = util_get_symbol_addr(
-        tbb_callbacks->lib_handle, tbb_symbol[TBB_POOL_MSIZE], lib_name);
-
-    if (!tbb_callbacks->pool_malloc || !tbb_callbacks->pool_realloc ||
-        !tbb_callbacks->pool_aligned_malloc || !tbb_callbacks->pool_free ||
-        !tbb_callbacks->pool_create_v1 || !tbb_callbacks->pool_destroy ||
-        !tbb_callbacks->pool_identify) {
-        LOG_ERR("Could not find symbols in %s", lib_name);
-        util_close_library(tbb_callbacks->lib_handle);
-        return -1;
+    *(void **)&tbb_callbacks.pool_malloc = utils_get_symbol_addr(
+        tbb_callbacks.lib_handle, tbb_symbol[TBB_POOL_MALLOC], lib_name);
+    *(void **)&tbb_callbacks.pool_realloc = utils_get_symbol_addr(
+        tbb_callbacks.lib_handle, tbb_symbol[TBB_POOL_REALLOC], lib_name);
+    *(void **)&tbb_callbacks.pool_aligned_malloc =
+        utils_get_symbol_addr(tbb_callbacks.lib_handle,
+                              tbb_symbol[TBB_POOL_ALIGNED_MALLOC], lib_name);
+    *(void **)&tbb_callbacks.pool_free = utils_get_symbol_addr(
+        tbb_callbacks.lib_handle, tbb_symbol[TBB_POOL_FREE], lib_name);
+    *(void **)&tbb_callbacks.pool_create_v1 = utils_get_symbol_addr(
+        tbb_callbacks.lib_handle, tbb_symbol[TBB_POOL_CREATE_V1], lib_name);
+    *(void **)&tbb_callbacks.pool_destroy = utils_get_symbol_addr(
+        tbb_callbacks.lib_handle, tbb_symbol[TBB_POOL_DESTROY], lib_name);
+    *(void **)&tbb_callbacks.pool_identify = utils_get_symbol_addr(
+        tbb_callbacks.lib_handle, tbb_symbol[TBB_POOL_IDENTIFY], lib_name);
+    *(void **)&tbb_callbacks.pool_msize = utils_get_symbol_addr(
+        tbb_callbacks.lib_handle, tbb_symbol[TBB_POOL_MSIZE], lib_name);
+
+    if (!tbb_callbacks.pool_malloc || !tbb_callbacks.pool_realloc ||
+        !tbb_callbacks.pool_aligned_malloc || !tbb_callbacks.pool_free ||
+        !tbb_callbacks.pool_create_v1 || !tbb_callbacks.pool_destroy ||
+        !tbb_callbacks.pool_identify) {
+        LOG_FATAL("Could not find all TBB symbols in %s", lib_name);
+        if (utils_close_library(tbb_callbacks.lib_handle)) {
+            LOG_ERR("Could not close %s library", lib_name);
+        }
+        tbb_init_result = -1;
     }
+}
 
-    return 0;
+static int init_tbb_callbacks(void) {
+    utils_init_once(&tbb_initialized, init_tbb_callbacks_once);
+    return tbb_init_result;
+}
+
+void fini_tbb_global_state(void) {
+    if (tbb_callbacks.lib_handle) {
+        if (!utils_close_library(tbb_callbacks.lib_handle)) {
+            tbb_callbacks.lib_handle = NULL;
+            LOG_DEBUG("TBB library closed");
+        } else {
+            LOG_ERR("TBB library cannot be unloaded");
+        }
+    }
 }
 
 static void *tbb_raw_alloc_wrapper(intptr_t pool_id, size_t *raw_bytes) {
@@ -167,19 +199,88 @@ static void tbb_raw_free_wrapper(intptr_t pool_id, void *ptr, size_t bytes) {
     }
 }
 
-static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
-                                        void *params, void **pool) {
-    (void)params; // unused
+umf_result_t
+umfScalablePoolParamsCreate(umf_scalable_pool_params_handle_t *hParams) {
+    libumfInit();
+    if (!hParams) {
+        LOG_ERR("scalable pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_scalable_pool_params_t *params_data =
+        umf_ba_global_alloc(sizeof(umf_scalable_pool_params_t));
+    if (!params_data) {
+        LOG_ERR("cannot allocate memory for scalable pool params");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    params_data->granularity = DEFAULT_GRANULARITY;
+    params_data->keep_all_memory = false;
+
+    *hParams = (umf_scalable_pool_params_handle_t)params_data;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfScalablePoolParamsDestroy(umf_scalable_pool_params_handle_t hParams) {
+    if (!hParams) {
+        LOG_ERR("scalable pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_ba_global_free(hParams);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfScalablePoolParamsSetGranularity(umf_scalable_pool_params_handle_t hParams,
+                                    size_t granularity) {
+    if (!hParams) {
+        LOG_ERR("scalable pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (granularity == 0) {
+        LOG_ERR("granularity cannot be 0");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->granularity = granularity;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfScalablePoolParamsSetKeepAllMemory(umf_scalable_pool_params_handle_t hParams,
+                                      bool keepAllMemory) {
+    if (!hParams) {
+        LOG_ERR("scalable pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
 
-    const size_t GRANULARITY = 2 * 1024 * 1024;
+    hParams->keep_all_memory = keepAllMemory;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
+                                        const void *params, void **pool) {
     tbb_mem_pool_policy_t policy = {.pAlloc = tbb_raw_alloc_wrapper,
                                     .pFree = tbb_raw_free_wrapper,
-                                    .granularity = GRANULARITY,
+                                    .granularity = DEFAULT_GRANULARITY,
                                     .version = 1,
                                     .fixed_pool = false,
                                     .keep_all_memory = false,
                                     .reserved = 0};
 
+    if (params) {
+        const umf_scalable_pool_params_t *scalable_params = params;
+        policy.granularity = scalable_params->granularity;
+        policy.keep_all_memory = scalable_params->keep_all_memory;
+    }
+
     tbb_memory_pool_t *pool_data =
         umf_ba_global_alloc(sizeof(tbb_memory_pool_t));
     if (!pool_data) {
@@ -187,35 +288,46 @@ static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    int ret = init_tbb_callbacks(&pool_data->tbb_callbacks);
+    umf_result_t res = UMF_RESULT_SUCCESS;
+    int ret = init_tbb_callbacks();
     if (ret != 0) {
-        LOG_ERR("loading TBB symbols failed");
-        return UMF_RESULT_ERROR_UNKNOWN;
+        LOG_FATAL("loading TBB symbols failed");
+        res = UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
+        goto err_tbb_init;
     }
 
     pool_data->mem_provider = provider;
-    ret = pool_data->tbb_callbacks.pool_create_v1((intptr_t)pool_data, &policy,
-                                                  &(pool_data->tbb_pool));
+    ret = tbb_callbacks.pool_create_v1((intptr_t)pool_data, &policy,
+                                       &(pool_data->tbb_pool));
     if (ret != 0 /* TBBMALLOC_OK */) {
-        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+        res = UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+        goto err_tbb_init;
     }
 
     *pool = (void *)pool_data;
 
-    return UMF_RESULT_SUCCESS;
+    return res;
+
+err_tbb_init:
+    umf_ba_global_free(pool_data);
+    return res;
 }
 
-static void tbb_pool_finalize(void *pool) {
+static umf_result_t tbb_pool_finalize(void *pool) {
     tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
-    pool_data->tbb_callbacks.pool_destroy(pool_data->tbb_pool);
-    util_close_library(pool_data->tbb_callbacks.lib_handle);
+    umf_result_t ret = UMF_RESULT_SUCCESS;
+    if (!tbb_callbacks.pool_destroy(pool_data->tbb_pool)) {
+        LOG_ERR("TBB pool destroy failed");
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+    }
     umf_ba_global_free(pool_data);
+    return ret;
 }
 
 static void *tbb_malloc(void *pool, size_t size) {
     tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
     TLS_last_allocation_error = UMF_RESULT_SUCCESS;
-    void *ptr = pool_data->tbb_callbacks.pool_malloc(pool_data->tbb_pool, size);
+    void *ptr = tbb_callbacks.pool_malloc(pool_data->tbb_pool, size);
     if (ptr == NULL) {
         if (TLS_last_allocation_error == UMF_RESULT_SUCCESS) {
             TLS_last_allocation_error = UMF_RESULT_ERROR_UNKNOWN;
@@ -242,8 +354,7 @@ static void *tbb_calloc(void *pool, size_t num, size_t size) {
 static void *tbb_realloc(void *pool, void *ptr, size_t size) {
     tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
     TLS_last_allocation_error = UMF_RESULT_SUCCESS;
-    void *new_ptr =
-        pool_data->tbb_callbacks.pool_realloc(pool_data->tbb_pool, ptr, size);
+    void *new_ptr = tbb_callbacks.pool_realloc(pool_data->tbb_pool, ptr, size);
     if (new_ptr == NULL) {
         if (TLS_last_allocation_error == UMF_RESULT_SUCCESS) {
             TLS_last_allocation_error = UMF_RESULT_ERROR_UNKNOWN;
@@ -257,8 +368,8 @@ static void *tbb_realloc(void *pool, void *ptr, size_t size) {
 static void *tbb_aligned_malloc(void *pool, size_t size, size_t alignment) {
     tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
     TLS_last_allocation_error = UMF_RESULT_SUCCESS;
-    void *ptr = pool_data->tbb_callbacks.pool_aligned_malloc(
-        pool_data->tbb_pool, size, alignment);
+    void *ptr =
+        tbb_callbacks.pool_aligned_malloc(pool_data->tbb_pool, size, alignment);
     if (ptr == NULL) {
         if (TLS_last_allocation_error == UMF_RESULT_SUCCESS) {
             TLS_last_allocation_error = UMF_RESULT_ERROR_UNKNOWN;
@@ -283,7 +394,7 @@ static umf_result_t tbb_free(void *pool, void *ptr) {
     utils_annotate_release(pool);
 
     tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
-    if (pool_data->tbb_callbacks.pool_free(pool_data->tbb_pool, ptr)) {
+    if (tbb_callbacks.pool_free(pool_data->tbb_pool, ptr)) {
         return UMF_RESULT_SUCCESS;
     }
 
@@ -294,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 pool_data->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) {
@@ -304,8 +416,23 @@ 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_VERSION_CURRENT,
+    .version = UMF_POOL_OPS_VERSION_CURRENT,
     .initialize = tbb_pool_initialize,
     .finalize = tbb_pool_finalize,
     .malloc = tbb_malloc,
@@ -314,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/pool/pool_scalable_internal.h b/src/pool/pool_scalable_internal.h
new file mode 100644
index 000000000..cfdc668fc
--- /dev/null
+++ b/src/pool/pool_scalable_internal.h
@@ -0,0 +1,10 @@
+/*
+ *
+ * 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
+ *
+ */
+
+void fini_tbb_global_state(void);
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
new file mode 100644
index 000000000..29083d453
--- /dev/null
+++ b/src/provider/provider_cuda.c
@@ -0,0 +1,765 @@
+/*
+ * 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 <stdbool.h>
+#include <stddef.h>
+#include <string.h>
+
+#include <umf.h>
+#include <umf/providers/provider_cuda.h>
+
+#include "provider_cuda_internal.h"
+#include "utils_load_library.h"
+#include "utils_log.h"
+
+static void *cu_lib_handle = NULL;
+
+void fini_cu_global_state(void) {
+    if (cu_lib_handle) {
+        utils_close_library(cu_lib_handle);
+        cu_lib_handle = NULL;
+    }
+}
+
+#if UMF_BUILD_CUDA_PROVIDER
+
+// disable warning 4201: nonstandard extension used: nameless struct/union
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4201)
+#endif // _MSC_VER
+
+#include "cuda.h"
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif // _MSC_VER
+
+#include "base_alloc_global.h"
+#include "libumf.h"
+#include "utils_assert.h"
+#include "utils_common.h"
+#include "utils_concurrency.h"
+#include "utils_log.h"
+#include "utils_sanitizers.h"
+
+typedef struct cu_memory_provider_t {
+    CUcontext context;
+    CUdevice device;
+    umf_usm_memory_type_t memory_type;
+    size_t min_alignment;
+    unsigned int alloc_flags;
+} cu_memory_provider_t;
+
+// CUDA Memory Provider settings struct
+typedef struct umf_cuda_memory_provider_params_t {
+    // Handle to the CUDA context
+    void *cuda_context_handle;
+
+    // Handle to the CUDA device
+    int cuda_device_handle;
+
+    // Allocation memory type
+    umf_usm_memory_type_t memory_type;
+
+    // Allocation flags for cuMemHostAlloc/cuMemAllocManaged
+    unsigned int alloc_flags;
+} umf_cuda_memory_provider_params_t;
+
+typedef struct cu_ops_t {
+    CUresult (*cuMemGetAllocationGranularity)(
+        size_t *granularity, const CUmemAllocationProp *prop,
+        CUmemAllocationGranularity_flags option);
+    CUresult (*cuMemAlloc)(CUdeviceptr *dptr, size_t bytesize);
+    CUresult (*cuMemHostAlloc)(void **pp, size_t bytesize, unsigned int flags);
+    CUresult (*cuMemAllocManaged)(CUdeviceptr *dptr, size_t bytesize,
+                                  unsigned int flags);
+    CUresult (*cuMemFree)(CUdeviceptr dptr);
+    CUresult (*cuMemFreeHost)(void *p);
+
+    CUresult (*cuGetErrorName)(CUresult error, const char **pStr);
+    CUresult (*cuGetErrorString)(CUresult error, const char **pStr);
+    CUresult (*cuCtxGetCurrent)(CUcontext *pctx);
+    CUresult (*cuCtxGetDevice)(CUdevice *device);
+    CUresult (*cuCtxSetCurrent)(CUcontext ctx);
+    CUresult (*cuIpcGetMemHandle)(CUipcMemHandle *pHandle, CUdeviceptr dptr);
+    CUresult (*cuIpcOpenMemHandle)(CUdeviceptr *pdptr, CUipcMemHandle handle,
+                                   unsigned int Flags);
+    CUresult (*cuIpcCloseMemHandle)(CUdeviceptr dptr);
+} cu_ops_t;
+
+typedef CUipcMemHandle cu_ipc_data_t;
+
+static cu_ops_t g_cu_ops;
+static UTIL_ONCE_FLAG cu_is_initialized = UTIL_ONCE_FLAG_INIT;
+static bool Init_cu_global_state_failed;
+
+// forward decl needed for alloc
+static umf_result_t cu_memory_provider_free(void *provider, void *ptr,
+                                            size_t bytes);
+
+#define TLS_MSG_BUF_LEN 1024
+
+typedef struct cu_last_native_error_t {
+    CUresult native_error;
+    char msg_buff[TLS_MSG_BUF_LEN];
+} cu_last_native_error_t;
+
+static __TLS cu_last_native_error_t TLS_last_native_error;
+
+static void cu_store_last_native_error(CUresult native_error) {
+    TLS_last_native_error.native_error = native_error;
+}
+
+static umf_result_t cu2umf_result(CUresult result) {
+    switch (result) {
+    case CUDA_SUCCESS:
+        return UMF_RESULT_SUCCESS;
+    case CUDA_ERROR_OUT_OF_MEMORY:
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    case CUDA_ERROR_INVALID_VALUE:
+    case CUDA_ERROR_INVALID_HANDLE:
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    case CUDA_ERROR_DEINITIALIZED:
+        LOG_ERR("CUDA driver has been deinitialized");
+        return UMF_RESULT_ERROR_OUT_OF_RESOURCES;
+    default:
+        cu_store_last_native_error(result);
+        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    }
+}
+
+static void init_cu_global_state(void) {
+#ifdef _WIN32
+    const char *lib_name = "nvcuda.dll";
+#else
+    const char *lib_name = "libcuda.so";
+#endif
+    // The CUDA shared library should be already loaded by the user
+    // of the CUDA provider. UMF just want to reuse it
+    // and increase the reference count to the CUDA shared library.
+    void *lib_handle =
+        utils_open_library(lib_name, UMF_UTIL_OPEN_LIBRARY_NO_LOAD);
+    if (!lib_handle) {
+        LOG_ERR("Failed to open CUDA shared library");
+        Init_cu_global_state_failed = true;
+        return;
+    }
+
+    // NOTE: some symbols defined in the lib have _vX postfixes - it is
+    // important to load the proper version of functions
+    *(void **)&g_cu_ops.cuMemGetAllocationGranularity = utils_get_symbol_addr(
+        lib_handle, "cuMemGetAllocationGranularity", lib_name);
+    *(void **)&g_cu_ops.cuMemAlloc =
+        utils_get_symbol_addr(lib_handle, "cuMemAlloc_v2", lib_name);
+    *(void **)&g_cu_ops.cuMemHostAlloc =
+        utils_get_symbol_addr(lib_handle, "cuMemHostAlloc", lib_name);
+    *(void **)&g_cu_ops.cuMemAllocManaged =
+        utils_get_symbol_addr(lib_handle, "cuMemAllocManaged", lib_name);
+    *(void **)&g_cu_ops.cuMemFree =
+        utils_get_symbol_addr(lib_handle, "cuMemFree_v2", lib_name);
+    *(void **)&g_cu_ops.cuMemFreeHost =
+        utils_get_symbol_addr(lib_handle, "cuMemFreeHost", lib_name);
+    *(void **)&g_cu_ops.cuGetErrorName =
+        utils_get_symbol_addr(lib_handle, "cuGetErrorName", lib_name);
+    *(void **)&g_cu_ops.cuGetErrorString =
+        utils_get_symbol_addr(lib_handle, "cuGetErrorString", lib_name);
+    *(void **)&g_cu_ops.cuCtxGetCurrent =
+        utils_get_symbol_addr(lib_handle, "cuCtxGetCurrent", lib_name);
+    *(void **)&g_cu_ops.cuCtxGetDevice =
+        utils_get_symbol_addr(lib_handle, "cuCtxGetDevice", lib_name);
+    *(void **)&g_cu_ops.cuCtxSetCurrent =
+        utils_get_symbol_addr(lib_handle, "cuCtxSetCurrent", lib_name);
+    *(void **)&g_cu_ops.cuIpcGetMemHandle =
+        utils_get_symbol_addr(lib_handle, "cuIpcGetMemHandle", lib_name);
+    *(void **)&g_cu_ops.cuIpcOpenMemHandle =
+        utils_get_symbol_addr(lib_handle, "cuIpcOpenMemHandle_v2", lib_name);
+    *(void **)&g_cu_ops.cuIpcCloseMemHandle =
+        utils_get_symbol_addr(lib_handle, "cuIpcCloseMemHandle", lib_name);
+
+    if (!g_cu_ops.cuMemGetAllocationGranularity || !g_cu_ops.cuMemAlloc ||
+        !g_cu_ops.cuMemHostAlloc || !g_cu_ops.cuMemAllocManaged ||
+        !g_cu_ops.cuMemFree || !g_cu_ops.cuMemFreeHost ||
+        !g_cu_ops.cuGetErrorName || !g_cu_ops.cuGetErrorString ||
+        !g_cu_ops.cuCtxGetCurrent || !g_cu_ops.cuCtxGetDevice ||
+        !g_cu_ops.cuCtxSetCurrent || !g_cu_ops.cuIpcGetMemHandle ||
+        !g_cu_ops.cuIpcOpenMemHandle || !g_cu_ops.cuIpcCloseMemHandle) {
+        LOG_FATAL("Required CUDA symbols not found.");
+        Init_cu_global_state_failed = true;
+        utils_close_library(lib_handle);
+        return;
+    }
+    cu_lib_handle = lib_handle;
+}
+
+umf_result_t umfCUDAMemoryProviderParamsCreate(
+    umf_cuda_memory_provider_params_handle_t *hParams) {
+    libumfInit();
+    if (!hParams) {
+        LOG_ERR("CUDA Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_cuda_memory_provider_params_handle_t params_data =
+        umf_ba_global_alloc(sizeof(umf_cuda_memory_provider_params_t));
+    if (!params_data) {
+        LOG_ERR("Cannot allocate memory for CUDA Memory Provider params");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    utils_init_once(&cu_is_initialized, init_cu_global_state);
+    if (Init_cu_global_state_failed) {
+        LOG_FATAL("Loading CUDA symbols failed");
+        return UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
+    }
+
+    // initialize context and device to the current ones
+    CUcontext current_ctx = NULL;
+    CUresult cu_result = g_cu_ops.cuCtxGetCurrent(&current_ctx);
+    if (cu_result == CUDA_SUCCESS) {
+        params_data->cuda_context_handle = current_ctx;
+    } else {
+        params_data->cuda_context_handle = NULL;
+    }
+
+    CUdevice current_device = -1;
+    cu_result = g_cu_ops.cuCtxGetDevice(&current_device);
+    if (cu_result == CUDA_SUCCESS) {
+        params_data->cuda_device_handle = current_device;
+    } else {
+        params_data->cuda_device_handle = -1;
+    }
+
+    params_data->memory_type = UMF_MEMORY_TYPE_UNKNOWN;
+    params_data->alloc_flags = 0;
+
+    *hParams = params_data;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfCUDAMemoryProviderParamsDestroy(
+    umf_cuda_memory_provider_params_handle_t hParams) {
+    umf_ba_global_free(hParams);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfCUDAMemoryProviderParamsSetContext(
+    umf_cuda_memory_provider_params_handle_t hParams, void *hContext) {
+    if (!hParams) {
+        LOG_ERR("CUDA Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->cuda_context_handle = hContext;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfCUDAMemoryProviderParamsSetDevice(
+    umf_cuda_memory_provider_params_handle_t hParams, int hDevice) {
+    if (!hParams) {
+        LOG_ERR("CUDA Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->cuda_device_handle = hDevice;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfCUDAMemoryProviderParamsSetMemoryType(
+    umf_cuda_memory_provider_params_handle_t hParams,
+    umf_usm_memory_type_t memoryType) {
+    if (!hParams) {
+        LOG_ERR("CUDA Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->memory_type = memoryType;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfCUDAMemoryProviderParamsSetAllocFlags(
+    umf_cuda_memory_provider_params_handle_t hParams, unsigned int flags) {
+    if (!hParams) {
+        LOG_ERR("CUDA Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->alloc_flags = flags;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t cu_memory_provider_initialize(const void *params,
+                                                  void **provider) {
+    if (params == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    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) {
+        LOG_ERR("Invalid memory type value");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (cu_params->cuda_context_handle == NULL) {
+        LOG_ERR("Invalid context handle");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (cu_params->cuda_device_handle < 0) {
+        LOG_ERR("Invalid device handle");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    utils_init_once(&cu_is_initialized, init_cu_global_state);
+    if (Init_cu_global_state_failed) {
+        LOG_FATAL("Loading CUDA symbols failed");
+        return UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
+    }
+
+    cu_memory_provider_t *cu_provider =
+        umf_ba_global_alloc(sizeof(cu_memory_provider_t));
+    if (!cu_provider) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    // CUDA alloc functions doesn't allow to provide user alignment - get the
+    // minimum one from the driver
+    size_t min_alignment = 0;
+    CUmemAllocationProp allocProps = {0};
+    allocProps.location.type = CU_MEM_LOCATION_TYPE_DEVICE;
+    allocProps.type = CU_MEM_ALLOCATION_TYPE_PINNED;
+    allocProps.location.id = cu_params->cuda_device_handle;
+    CUresult cu_result = g_cu_ops.cuMemGetAllocationGranularity(
+        &min_alignment, &allocProps, CU_MEM_ALLOC_GRANULARITY_MINIMUM);
+    if (cu_result != CUDA_SUCCESS) {
+        umf_ba_global_free(cu_provider);
+        return cu2umf_result(cu_result);
+    }
+
+    cu_provider->context = cu_params->cuda_context_handle;
+    cu_provider->device = cu_params->cuda_device_handle;
+    cu_provider->memory_type = cu_params->memory_type;
+    cu_provider->min_alignment = min_alignment;
+
+    // If the memory type is shared (CUDA managed), the allocation flags must
+    // be set. NOTE: we do not check here if the flags are valid -
+    // this will be done by CUDA runtime.
+    if (cu_params->memory_type == UMF_MEMORY_TYPE_SHARED &&
+        cu_params->alloc_flags == 0) {
+        // the default setting is CU_MEM_ATTACH_GLOBAL
+        cu_provider->alloc_flags = CU_MEM_ATTACH_GLOBAL;
+    } else {
+        cu_provider->alloc_flags = cu_params->alloc_flags;
+    }
+
+    *provider = cu_provider;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t cu_memory_provider_finalize(void *provider) {
+    umf_ba_global_free(provider);
+    return UMF_RESULT_SUCCESS;
+}
+
+/*
+ * This function is used by the CUDA provider to make sure that
+ * the required context is set. If the current context is
+ * not the required one, it will be saved in restore_ctx.
+ */
+static inline umf_result_t set_context(CUcontext required_ctx,
+                                       CUcontext *restore_ctx) {
+    CUcontext current_ctx = NULL;
+    CUresult cu_result = g_cu_ops.cuCtxGetCurrent(&current_ctx);
+    if (cu_result != CUDA_SUCCESS) {
+        LOG_ERR("cuCtxGetCurrent() failed.");
+        return cu2umf_result(cu_result);
+    }
+    *restore_ctx = current_ctx;
+    if (current_ctx != required_ctx) {
+        cu_result = g_cu_ops.cuCtxSetCurrent(required_ctx);
+        if (cu_result != CUDA_SUCCESS) {
+            LOG_ERR("cuCtxSetCurrent() failed.");
+            return cu2umf_result(cu_result);
+        }
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t cu_memory_provider_alloc(void *provider, size_t size,
+                                             size_t alignment,
+                                             void **resultPtr) {
+    cu_memory_provider_t *cu_provider = (cu_memory_provider_t *)provider;
+
+    if (alignment > cu_provider->min_alignment) {
+        // alignment of CUDA allocations is controlled by the CUDA driver -
+        // currently UMF doesn't support alignment larger than default
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+
+    // Remember current context and set the one from the provider
+    CUcontext restore_ctx = NULL;
+    umf_result_t umf_result = set_context(cu_provider->context, &restore_ctx);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Failed to set CUDA context, ret = %d", umf_result);
+        return umf_result;
+    }
+
+    CUresult cu_result = CUDA_SUCCESS;
+    switch (cu_provider->memory_type) {
+    case UMF_MEMORY_TYPE_HOST: {
+        cu_result =
+            g_cu_ops.cuMemHostAlloc(resultPtr, size, cu_provider->alloc_flags);
+        break;
+    }
+    case UMF_MEMORY_TYPE_DEVICE: {
+        cu_result = g_cu_ops.cuMemAlloc((CUdeviceptr *)resultPtr, size);
+        break;
+    }
+    case UMF_MEMORY_TYPE_SHARED: {
+        cu_result = g_cu_ops.cuMemAllocManaged((CUdeviceptr *)resultPtr, size,
+                                               cu_provider->alloc_flags);
+        break;
+    }
+    default:
+        // this shouldn't happen as we check the memory_type settings during
+        // the initialization
+        LOG_ERR("unsupported USM memory type");
+        assert(false);
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    umf_result = set_context(restore_ctx, &restore_ctx);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Failed to restore CUDA context, ret = %d", umf_result);
+    }
+
+    umf_result = cu2umf_result(cu_result);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Failed to allocate memory, cu_result = %d, ret = %d",
+                cu_result, umf_result);
+        return umf_result;
+    }
+
+    // check the alignment
+    if (alignment > 0 && ((uintptr_t)(*resultPtr) % alignment) != 0) {
+        cu_memory_provider_free(provider, *resultPtr, size);
+        LOG_ERR("unsupported alignment size");
+        return UMF_RESULT_ERROR_INVALID_ALIGNMENT;
+    }
+    return umf_result;
+}
+
+static umf_result_t cu_memory_provider_free(void *provider, void *ptr,
+                                            size_t bytes) {
+    (void)bytes;
+
+    if (ptr == NULL) {
+        return UMF_RESULT_SUCCESS;
+    }
+
+    cu_memory_provider_t *cu_provider = (cu_memory_provider_t *)provider;
+
+    // Remember current context and set the one from the provider
+    CUcontext restore_ctx = NULL;
+    umf_result_t umf_result = set_context(cu_provider->context, &restore_ctx);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Failed to set CUDA context, ret = %d", umf_result);
+        return umf_result;
+    }
+
+    CUresult cu_result = CUDA_SUCCESS;
+    switch (cu_provider->memory_type) {
+    case UMF_MEMORY_TYPE_HOST: {
+        cu_result = g_cu_ops.cuMemFreeHost(ptr);
+        break;
+    }
+    case UMF_MEMORY_TYPE_SHARED:
+    case UMF_MEMORY_TYPE_DEVICE: {
+        cu_result = g_cu_ops.cuMemFree((CUdeviceptr)ptr);
+        break;
+    }
+    default:
+        // this shouldn't happen as we check the memory_type settings during
+        // the initialization
+        LOG_ERR("unsupported USM memory type");
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    umf_result = set_context(restore_ctx, &restore_ctx);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Failed to restore CUDA context, ret = %d", umf_result);
+    }
+
+    return cu2umf_result(cu_result);
+}
+
+static void cu_memory_provider_get_last_native_error(void *provider,
+                                                     const char **ppMessage,
+                                                     int32_t *pError) {
+    (void)provider;
+
+    if (ppMessage == NULL || pError == NULL) {
+        ASSERT(0);
+        return;
+    }
+
+    CUresult result;
+    size_t buf_size = 0;
+    const char *error_name = NULL;
+    const char *error_string = NULL;
+
+    // If the error code is not recognized,
+    // CUDA_ERROR_INVALID_VALUE will be returned
+    // and error_name will be set to the NULL address.
+    result = g_cu_ops.cuGetErrorName(TLS_last_native_error.native_error,
+                                     &error_name);
+    if (result == CUDA_SUCCESS && error_name != NULL) {
+        strncpy(TLS_last_native_error.msg_buff, error_name,
+                TLS_MSG_BUF_LEN - 1);
+        TLS_last_native_error.msg_buff[TLS_MSG_BUF_LEN - 1] = '\0';
+    } else {
+        strncpy(TLS_last_native_error.msg_buff, "cuGetErrorName() failed",
+                TLS_MSG_BUF_LEN - 1);
+        TLS_last_native_error.msg_buff[TLS_MSG_BUF_LEN - 1] = '\0';
+    }
+
+    buf_size = strlen(TLS_last_native_error.msg_buff);
+    strncat(TLS_last_native_error.msg_buff, " - ",
+            TLS_MSG_BUF_LEN - buf_size - 1);
+    buf_size = strlen(TLS_last_native_error.msg_buff);
+
+    // If the error code is not recognized,
+    // CUDA_ERROR_INVALID_VALUE will be returned
+    // and error_string will be set to the NULL address.
+    result = g_cu_ops.cuGetErrorString(TLS_last_native_error.native_error,
+                                       &error_string);
+    if (result == CUDA_SUCCESS && error_string != NULL) {
+        strncat(TLS_last_native_error.msg_buff, error_string,
+                TLS_MSG_BUF_LEN - buf_size - 1);
+    } else {
+        strncat(TLS_last_native_error.msg_buff, "cuGetErrorString() failed",
+                TLS_MSG_BUF_LEN - buf_size - 1);
+    }
+
+    *pError = TLS_last_native_error.native_error;
+    *ppMessage = TLS_last_native_error.msg_buff;
+}
+
+static umf_result_t cu_memory_provider_get_min_page_size(void *provider,
+                                                         const void *ptr,
+                                                         size_t *pageSize) {
+    (void)ptr;
+
+    cu_memory_provider_t *cu_provider = (cu_memory_provider_t *)provider;
+
+    CUmemAllocationProp allocProps = {0};
+    allocProps.location.type = CU_MEM_LOCATION_TYPE_DEVICE;
+    allocProps.type = CU_MEM_ALLOCATION_TYPE_PINNED;
+    allocProps.location.id = cu_provider->device;
+
+    CUresult cu_result = g_cu_ops.cuMemGetAllocationGranularity(
+        pageSize, &allocProps, CU_MEM_ALLOC_GRANULARITY_MINIMUM);
+
+    return cu2umf_result(cu_result);
+}
+
+static umf_result_t
+cu_memory_provider_get_recommended_page_size(void *provider, size_t size,
+                                             size_t *pageSize) {
+    (void)size;
+
+    cu_memory_provider_t *cu_provider = (cu_memory_provider_t *)provider;
+
+    CUmemAllocationProp allocProps = {0};
+    allocProps.location.type = CU_MEM_LOCATION_TYPE_DEVICE;
+    allocProps.type = CU_MEM_ALLOCATION_TYPE_PINNED;
+    allocProps.location.id = cu_provider->device;
+
+    CUresult cu_result = g_cu_ops.cuMemGetAllocationGranularity(
+        pageSize, &allocProps, CU_MEM_ALLOC_GRANULARITY_RECOMMENDED);
+
+    return cu2umf_result(cu_result);
+}
+
+static const char *cu_memory_provider_get_name(void *provider) {
+    (void)provider;
+    return "CUDA";
+}
+
+static umf_result_t cu_memory_provider_get_ipc_handle_size(void *provider,
+                                                           size_t *size) {
+    (void)provider;
+    *size = sizeof(cu_ipc_data_t);
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t cu_memory_provider_get_ipc_handle(void *provider,
+                                                      const void *ptr,
+                                                      size_t size,
+                                                      void *providerIpcData) {
+    (void)provider;
+    (void)size;
+
+    CUresult cu_result;
+    cu_ipc_data_t *cu_ipc_data = (cu_ipc_data_t *)providerIpcData;
+
+    cu_result = g_cu_ops.cuIpcGetMemHandle(cu_ipc_data, (CUdeviceptr)ptr);
+    if (cu_result != CUDA_SUCCESS) {
+        LOG_ERR("cuIpcGetMemHandle() failed.");
+        return cu2umf_result(cu_result);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t cu_memory_provider_put_ipc_handle(void *provider,
+                                                      void *providerIpcData) {
+    (void)provider;
+    (void)providerIpcData;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t cu_memory_provider_open_ipc_handle(void *provider,
+                                                       void *providerIpcData,
+                                                       void **ptr) {
+    cu_memory_provider_t *cu_provider = (cu_memory_provider_t *)provider;
+
+    CUresult cu_result;
+    cu_ipc_data_t *cu_ipc_data = (cu_ipc_data_t *)providerIpcData;
+
+    // Remember current context and set the one from the provider
+    CUcontext restore_ctx = NULL;
+    umf_result_t umf_result = set_context(cu_provider->context, &restore_ctx);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        return umf_result;
+    }
+
+    cu_result = g_cu_ops.cuIpcOpenMemHandle((CUdeviceptr *)ptr, *cu_ipc_data,
+                                            CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS);
+
+    if (cu_result != CUDA_SUCCESS) {
+        LOG_ERR("cuIpcOpenMemHandle() failed.");
+    }
+
+    umf_result = set_context(restore_ctx, &restore_ctx);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Failed to restore CUDA context, ret = %d", umf_result);
+    }
+
+    return cu2umf_result(cu_result);
+}
+
+static umf_result_t
+cu_memory_provider_close_ipc_handle(void *provider, void *ptr, size_t size) {
+    (void)provider;
+    (void)size;
+
+    CUresult cu_result;
+
+    cu_result = g_cu_ops.cuIpcCloseMemHandle((CUdeviceptr)ptr);
+    if (cu_result != CUDA_SUCCESS) {
+        LOG_ERR("cuIpcCloseMemHandle() failed.");
+        return cu2umf_result(cu_result);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_memory_provider_ops_t UMF_CUDA_MEMORY_PROVIDER_OPS = {
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
+    .initialize = cu_memory_provider_initialize,
+    .finalize = cu_memory_provider_finalize,
+    .alloc = cu_memory_provider_alloc,
+    .free = cu_memory_provider_free,
+    .get_last_native_error = cu_memory_provider_get_last_native_error,
+    .get_recommended_page_size = cu_memory_provider_get_recommended_page_size,
+    .get_min_page_size = cu_memory_provider_get_min_page_size,
+    .get_name = cu_memory_provider_get_name,
+    // 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_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,
+};
+
+const umf_memory_provider_ops_t *umfCUDAMemoryProviderOps(void) {
+    return &UMF_CUDA_MEMORY_PROVIDER_OPS;
+}
+
+#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_cuda_internal.h b/src/provider/provider_cuda_internal.h
new file mode 100644
index 000000000..bc3d79d4a
--- /dev/null
+++ b/src/provider/provider_cuda_internal.h
@@ -0,0 +1,10 @@
+/*
+ *
+ * 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
+ *
+ */
+
+void fini_cu_global_state(void);
diff --git a/src/provider/provider_devdax_memory.c b/src/provider/provider_devdax_memory.c
new file mode 100644
index 000000000..fdd8ad9b9
--- /dev/null
+++ b/src/provider/provider_devdax_memory.c
@@ -0,0 +1,668 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <umf.h>
+#include <umf/memory_provider_ops.h>
+#include <umf/providers/provider_devdax_memory.h>
+
+#include "utils_log.h"
+
+#if defined(_WIN32) || defined(UMF_NO_HWLOC)
+
+const umf_memory_provider_ops_t *umfDevDaxMemoryProviderOps(void) {
+    // not supported
+    LOG_ERR("DevDax memory provider is disabled!");
+    return NULL;
+}
+
+umf_result_t umfDevDaxMemoryProviderParamsCreate(
+    umf_devdax_memory_provider_params_handle_t *hParams, const char *path,
+    size_t size) {
+    (void)hParams;
+    (void)path;
+    (void)size;
+    LOG_ERR("DevDax memory provider is disabled!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfDevDaxMemoryProviderParamsDestroy(
+    umf_devdax_memory_provider_params_handle_t hParams) {
+    (void)hParams;
+    LOG_ERR("DevDax memory provider is disabled!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfDevDaxMemoryProviderParamsSetDeviceDax(
+    umf_devdax_memory_provider_params_handle_t hParams, const char *path,
+    size_t size) {
+    (void)hParams;
+    (void)path;
+    (void)size;
+    LOG_ERR("DevDax memory provider is disabled!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfDevDaxMemoryProviderParamsSetProtection(
+    umf_devdax_memory_provider_params_handle_t hParams, unsigned protection) {
+    (void)hParams;
+    (void)protection;
+    LOG_ERR("DevDax memory provider is disabled!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+#else // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+
+#include "base_alloc_global.h"
+#include "coarse.h"
+#include "libumf.h"
+#include "utils_common.h"
+#include "utils_concurrency.h"
+#include "utils_log.h"
+
+#define DEVDAX_PAGE_SIZE_2MB ((size_t)(2 * 1024 * 1024)) // == 2 MB
+
+#define TLS_MSG_BUF_LEN 1024
+
+typedef struct devdax_memory_provider_t {
+    char path[PATH_MAX]; // a path to the device DAX
+    size_t size;         // size of the file used for memory mapping
+    void *base;          // base address of memory mapping
+    size_t offset;       // offset in the file used for memory mapping
+    utils_mutex_t lock;  // lock of ptr and offset
+    unsigned protection; // combination of OS-specific protection flags
+    coarse_t *coarse;    // coarse library handle
+} devdax_memory_provider_t;
+
+// DevDax Memory provider settings struct
+typedef struct umf_devdax_memory_provider_params_t {
+    char *path;
+    size_t size;
+    unsigned protection;
+} umf_devdax_memory_provider_params_t;
+
+typedef struct devdax_last_native_error_t {
+    int32_t native_error;
+    int errno_value;
+    char msg_buff[TLS_MSG_BUF_LEN];
+} devdax_last_native_error_t;
+
+static __TLS devdax_last_native_error_t TLS_last_native_error;
+
+// helper values used only in the Native_error_str array
+#define _UMF_DEVDAX_RESULT_SUCCESS                                             \
+    (UMF_DEVDAX_RESULT_SUCCESS - UMF_DEVDAX_RESULT_SUCCESS)
+#define _UMF_DEVDAX_RESULT_ERROR_ALLOC_FAILED                                  \
+    (UMF_DEVDAX_RESULT_ERROR_ALLOC_FAILED - UMF_DEVDAX_RESULT_SUCCESS)
+#define _UMF_DEVDAX_RESULT_ERROR_ADDRESS_NOT_ALIGNED                           \
+    (UMF_DEVDAX_RESULT_ERROR_ADDRESS_NOT_ALIGNED - UMF_DEVDAX_RESULT_SUCCESS)
+#define _UMF_DEVDAX_RESULT_ERROR_FREE_FAILED                                   \
+    (UMF_DEVDAX_RESULT_ERROR_FREE_FAILED - UMF_DEVDAX_RESULT_SUCCESS)
+#define _UMF_DEVDAX_RESULT_ERROR_PURGE_FORCE_FAILED                            \
+    (UMF_DEVDAX_RESULT_ERROR_PURGE_FORCE_FAILED - UMF_DEVDAX_RESULT_SUCCESS)
+
+static const char *Native_error_str[] = {
+    [_UMF_DEVDAX_RESULT_SUCCESS] = "success",
+    [_UMF_DEVDAX_RESULT_ERROR_ALLOC_FAILED] = "memory allocation failed",
+    [_UMF_DEVDAX_RESULT_ERROR_ADDRESS_NOT_ALIGNED] =
+        "allocated address is not aligned",
+    [_UMF_DEVDAX_RESULT_ERROR_FREE_FAILED] = "memory deallocation failed",
+    [_UMF_DEVDAX_RESULT_ERROR_PURGE_FORCE_FAILED] = "force purging failed",
+};
+
+static void devdax_store_last_native_error(int32_t native_error,
+                                           int errno_value) {
+    TLS_last_native_error.native_error = native_error;
+    TLS_last_native_error.errno_value = errno_value;
+}
+
+static umf_result_t
+devdax_translate_params(const umf_devdax_memory_provider_params_t *in_params,
+                        devdax_memory_provider_t *provider) {
+    umf_result_t result;
+
+    result = utils_translate_mem_protection_flags(in_params->protection,
+                                                  &provider->protection);
+    if (result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("incorrect memory protection flags: %u", in_params->protection);
+        return result;
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t devdax_allocation_split_cb(void *provider, void *ptr,
+                                               size_t totalSize,
+                                               size_t firstSize);
+static umf_result_t devdax_allocation_merge_cb(void *provider, void *lowPtr,
+                                               void *highPtr, size_t totalSize);
+
+static umf_result_t devdax_initialize(const void *params, void **provider) {
+    umf_result_t ret;
+
+    if (params == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    const umf_devdax_memory_provider_params_t *in_params = params;
+
+    if (in_params->path == NULL) {
+        LOG_ERR("devdax path is missing");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (in_params->size == 0) {
+        LOG_ERR("devdax size is 0");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    devdax_memory_provider_t *devdax_provider =
+        umf_ba_global_alloc(sizeof(*devdax_provider));
+    if (!devdax_provider) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    memset(devdax_provider, 0, sizeof(*devdax_provider));
+
+    coarse_params_t coarse_params = {0};
+    coarse_params.provider = devdax_provider;
+    coarse_params.page_size = DEVDAX_PAGE_SIZE_2MB;
+    // The alloc callback is not available in case of the devdax provider
+    // because it is a fixed-size memory provider
+    // and the entire devdax memory is added as a single block
+    // to the coarse library.
+    coarse_params.cb.alloc = NULL;
+    coarse_params.cb.free = NULL; // not available for the devdax provider
+    coarse_params.cb.split = devdax_allocation_split_cb;
+    coarse_params.cb.merge = devdax_allocation_merge_cb;
+
+    coarse_t *coarse = NULL;
+    ret = coarse_new(&coarse_params, &coarse);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("coarse_new() failed");
+        goto err_free_devdax_provider;
+    }
+
+    devdax_provider->coarse = coarse;
+
+    ret = devdax_translate_params(in_params, devdax_provider);
+    if (ret != UMF_RESULT_SUCCESS) {
+        goto err_coarse_delete;
+    }
+
+    devdax_provider->size = in_params->size;
+    if (utils_copy_path(in_params->path, devdax_provider->path, PATH_MAX)) {
+        goto err_coarse_delete;
+    }
+
+    int fd = utils_devdax_open(in_params->path);
+    if (fd == -1) {
+        LOG_ERR("cannot open the device DAX: %s", in_params->path);
+        ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        goto err_coarse_delete;
+    }
+
+    bool is_dax = false;
+
+    // mmap /dev/dax with the MAP_SYNC
+    devdax_provider->base = utils_mmap_file(
+        NULL, devdax_provider->size, devdax_provider->protection, 0 /* flags */,
+        fd, 0 /* offset */, &is_dax);
+    utils_close_fd(fd);
+    if (devdax_provider->base == NULL) {
+        LOG_PDEBUG("mapping the devdax failed (path=%s, size=%zu)",
+                   in_params->path, devdax_provider->size);
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+        goto err_coarse_delete;
+    }
+
+    if (!is_dax) {
+        LOG_ERR("mapping the devdax with MAP_SYNC failed: %s", in_params->path);
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+        goto err_unmap_devdax;
+    }
+
+    LOG_DEBUG("devdax memory mapped (path=%s, size=%zu, addr=%p)",
+              in_params->path, devdax_provider->size, devdax_provider->base);
+
+    // add the entire devdax memory as a single block
+    ret = coarse_add_memory_fixed(coarse, devdax_provider->base,
+                                  devdax_provider->size);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("adding memory block failed");
+        goto err_unmap_devdax;
+    }
+
+    if (utils_mutex_init(&devdax_provider->lock) == NULL) {
+        LOG_ERR("lock init failed");
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+        goto err_unmap_devdax;
+    }
+
+    *provider = devdax_provider;
+
+    return UMF_RESULT_SUCCESS;
+
+err_unmap_devdax:
+    if (devdax_provider->base) {
+        utils_munmap(devdax_provider->base, devdax_provider->size);
+    }
+err_coarse_delete:
+    coarse_delete(devdax_provider->coarse);
+err_free_devdax_provider:
+    umf_ba_global_free(devdax_provider);
+    return ret;
+}
+
+static 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);
+    if (utils_munmap(devdax_provider->base, devdax_provider->size)) {
+        LOG_PERR("unmapping the devdax memory failed (path: %s, size: %zu)",
+                 devdax_provider->path, devdax_provider->size);
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    coarse_delete(devdax_provider->coarse);
+    umf_ba_global_free(devdax_provider);
+    return ret;
+}
+
+static umf_result_t devdax_alloc(void *provider, size_t size, size_t alignment,
+                                 void **resultPtr) {
+    devdax_memory_provider_t *devdax_provider =
+        (devdax_memory_provider_t *)provider;
+    return coarse_alloc(devdax_provider->coarse, size, alignment, resultPtr);
+}
+
+static void devdax_get_last_native_error(void *provider, const char **ppMessage,
+                                         int32_t *pError) {
+    (void)provider; // unused
+
+    if (ppMessage == NULL || pError == NULL) {
+        assert(0);
+        return;
+    }
+
+    *pError = TLS_last_native_error.native_error;
+    if (TLS_last_native_error.errno_value == 0) {
+        *ppMessage = Native_error_str[*pError - UMF_DEVDAX_RESULT_SUCCESS];
+        return;
+    }
+
+    const char *msg;
+    size_t len;
+    size_t pos = 0;
+
+    msg = Native_error_str[*pError - UMF_DEVDAX_RESULT_SUCCESS];
+    len = strlen(msg);
+    memcpy(TLS_last_native_error.msg_buff + pos, msg, len + 1);
+    pos += len;
+
+    msg = ": ";
+    len = strlen(msg);
+    memcpy(TLS_last_native_error.msg_buff + pos, msg, len + 1);
+    pos += len;
+
+    utils_strerror(TLS_last_native_error.errno_value,
+                   TLS_last_native_error.msg_buff + pos, TLS_MSG_BUF_LEN - pos);
+
+    *ppMessage = TLS_last_native_error.msg_buff;
+}
+
+static umf_result_t devdax_get_recommended_page_size(void *provider,
+                                                     size_t size,
+                                                     size_t *page_size) {
+    (void)provider; // unused
+    (void)size;     // unused
+
+    *page_size = DEVDAX_PAGE_SIZE_2MB;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t devdax_get_min_page_size(void *provider, const void *ptr,
+                                             size_t *page_size) {
+    (void)ptr; // unused
+
+    return devdax_get_recommended_page_size(provider, 0, page_size);
+}
+
+static umf_result_t devdax_purge_lazy(void *provider, void *ptr, size_t size) {
+    (void)provider; // unused
+    (void)ptr;      // unused
+    (void)size;     // unused
+    // purge_lazy is unsupported in case of the devdax memory provider,
+    // because the MADV_FREE operation can be applied
+    // only to private anonymous pages (see madvise(2)).
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+static umf_result_t devdax_purge_force(void *provider, void *ptr, size_t size) {
+    (void)provider; // unused
+    errno = 0;
+    if (utils_purge(ptr, size, UMF_PURGE_FORCE)) {
+        devdax_store_last_native_error(
+            UMF_DEVDAX_RESULT_ERROR_PURGE_FORCE_FAILED, errno);
+        LOG_PERR("force purging failed");
+        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    }
+    return UMF_RESULT_SUCCESS;
+}
+
+static const char *devdax_get_name(void *provider) {
+    (void)provider; // unused
+    return "DEVDAX";
+}
+
+static umf_result_t devdax_allocation_split(void *provider, void *ptr,
+                                            size_t totalSize,
+                                            size_t firstSize) {
+    devdax_memory_provider_t *devdax_provider =
+        (devdax_memory_provider_t *)provider;
+    return coarse_split(devdax_provider->coarse, ptr, totalSize, firstSize);
+}
+
+static umf_result_t devdax_allocation_split_cb(void *provider, void *ptr,
+                                               size_t totalSize,
+                                               size_t firstSize) {
+    (void)provider;
+    (void)ptr;
+    (void)totalSize;
+    (void)firstSize;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t devdax_allocation_merge(void *provider, void *lowPtr,
+                                            void *highPtr, size_t totalSize) {
+    devdax_memory_provider_t *devdax_provider =
+        (devdax_memory_provider_t *)provider;
+    return coarse_merge(devdax_provider->coarse, lowPtr, highPtr, totalSize);
+}
+
+static umf_result_t devdax_allocation_merge_cb(void *provider, void *lowPtr,
+                                               void *highPtr,
+                                               size_t totalSize) {
+    (void)provider;
+    (void)lowPtr;
+    (void)highPtr;
+    (void)totalSize;
+    return UMF_RESULT_SUCCESS;
+}
+
+typedef struct devdax_ipc_data_t {
+    char path[PATH_MAX]; // path to the /dev/dax
+    unsigned protection; // combination of OS-specific memory protection flags
+    // offset of the data (from the beginning of the devdax mapping) - see devdax_get_ipc_handle()
+    size_t offset;
+    size_t length; // length of the data
+} devdax_ipc_data_t;
+
+static umf_result_t devdax_get_ipc_handle_size(void *provider, size_t *size) {
+    (void)provider;
+
+    *size = sizeof(devdax_ipc_data_t);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t devdax_get_ipc_handle(void *provider, const void *ptr,
+                                          size_t size, void *providerIpcData) {
+    devdax_memory_provider_t *devdax_provider =
+        (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);
+    devdax_ipc_data->path[PATH_MAX - 1] = '\0';
+    devdax_ipc_data->protection = devdax_provider->protection;
+    devdax_ipc_data->offset =
+        (size_t)((uintptr_t)ptr - (uintptr_t)devdax_provider->base);
+    devdax_ipc_data->length = size;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t devdax_put_ipc_handle(void *provider,
+                                          void *providerIpcData) {
+    devdax_memory_provider_t *devdax_provider =
+        (devdax_memory_provider_t *)provider;
+    devdax_ipc_data_t *devdax_ipc_data = (devdax_ipc_data_t *)providerIpcData;
+
+    // verify the path of the /dev/dax
+    if (strncmp(devdax_ipc_data->path, devdax_provider->path, PATH_MAX)) {
+        LOG_ERR("devdax path mismatch (local: %s, ipc: %s)",
+                devdax_provider->path, devdax_ipc_data->path);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t devdax_open_ipc_handle(void *provider,
+                                           void *providerIpcData, void **ptr) {
+    (void)provider; // unused
+    *ptr = NULL;
+
+    devdax_ipc_data_t *devdax_ipc_data = (devdax_ipc_data_t *)providerIpcData;
+
+    int fd = utils_devdax_open(devdax_ipc_data->path);
+    if (fd == -1) {
+        LOG_PERR("opening the devdax (%s) failed", devdax_ipc_data->path);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    // It is just a workaround for case when
+    // devdax_alloc() was called with the size argument
+    // that is not a multiplier of DEVDAX_PAGE_SIZE_2MB.
+    size_t offset_aligned = devdax_ipc_data->offset;
+    size_t length_aligned = devdax_ipc_data->length;
+    utils_align_ptr_down_size_up((void **)&offset_aligned, &length_aligned,
+                                 DEVDAX_PAGE_SIZE_2MB);
+
+    bool is_dax = false;
+
+    // mmap /dev/dax with the MAP_SYNC
+    char *addr =
+        utils_mmap_file(NULL, length_aligned, devdax_ipc_data->protection,
+                        0 /* flags */, fd, offset_aligned, &is_dax);
+    (void)utils_close_fd(fd);
+    if (addr == NULL) {
+        LOG_PERR("devdax mapping failed (path: %s, size: %zu, protection: %i, "
+                 "fd: %i, offset: %zu)",
+                 devdax_ipc_data->path, length_aligned,
+                 devdax_ipc_data->protection, fd, offset_aligned);
+
+        devdax_store_last_native_error(UMF_DEVDAX_RESULT_ERROR_ALLOC_FAILED,
+                                       errno);
+        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    }
+
+    if (!is_dax) {
+        LOG_ERR("mapping the devdax with MAP_SYNC failed: %s",
+                devdax_ipc_data->path);
+
+        if (addr) {
+            utils_munmap(addr, length_aligned);
+        }
+
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    LOG_DEBUG("devdax mapped (path: %s, size: %zu, protection: %i, fd: %i, "
+              "offset: %zu) to address %p",
+              devdax_ipc_data->path, length_aligned,
+              devdax_ipc_data->protection, fd, offset_aligned, (void *)addr);
+
+    *ptr = addr;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t devdax_close_ipc_handle(void *provider, void *ptr,
+                                            size_t size) {
+    (void)provider; // unused
+    size = ALIGN_UP(size, DEVDAX_PAGE_SIZE_2MB);
+
+    errno = 0;
+    int ret = utils_munmap(ptr, size);
+    // ignore error when size == 0
+    if (ret && (size > 0)) {
+        devdax_store_last_native_error(UMF_DEVDAX_RESULT_ERROR_FREE_FAILED,
+                                       errno);
+        LOG_PERR("memory unmapping failed (ptr: %p, size: %zu)", ptr, size);
+
+        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t devdax_free(void *provider, void *ptr, size_t size) {
+    devdax_memory_provider_t *devdax_provider =
+        (devdax_memory_provider_t *)provider;
+    return coarse_free(devdax_provider->coarse, ptr, size);
+}
+
+static umf_memory_provider_ops_t UMF_DEVDAX_MEMORY_PROVIDER_OPS = {
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
+    .initialize = devdax_initialize,
+    .finalize = devdax_finalize,
+    .alloc = devdax_alloc,
+    .free = devdax_free,
+    .get_last_native_error = devdax_get_last_native_error,
+    .get_recommended_page_size = devdax_get_recommended_page_size,
+    .get_min_page_size = devdax_get_min_page_size,
+    .get_name = devdax_get_name,
+    .ext_purge_lazy = devdax_purge_lazy,
+    .ext_purge_force = devdax_purge_force,
+    .ext_allocation_merge = devdax_allocation_merge,
+    .ext_allocation_split = devdax_allocation_split,
+    .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;
+}
+
+umf_result_t umfDevDaxMemoryProviderParamsCreate(
+    umf_devdax_memory_provider_params_handle_t *hParams, const char *path,
+    size_t size) {
+    libumfInit();
+    if (hParams == NULL) {
+        LOG_ERR("DevDax Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (path == NULL) {
+        LOG_ERR("DevDax path is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_devdax_memory_provider_params_handle_t params =
+        umf_ba_global_alloc(sizeof(*params));
+    if (params == NULL) {
+        LOG_ERR(
+            "Allocating memory for the DevDax Memory Provider params failed");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    params->path = NULL;
+    params->size = 0;
+    params->protection = UMF_PROTECTION_READ | UMF_PROTECTION_WRITE;
+
+    umf_result_t res =
+        umfDevDaxMemoryProviderParamsSetDeviceDax(params, path, size);
+    if (res != UMF_RESULT_SUCCESS) {
+        umf_ba_global_free(params);
+        return res;
+    }
+
+    *hParams = params;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfDevDaxMemoryProviderParamsDestroy(
+    umf_devdax_memory_provider_params_handle_t hParams) {
+    if (hParams != NULL) {
+        umf_ba_global_free(hParams->path);
+        umf_ba_global_free(hParams);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfDevDaxMemoryProviderParamsSetDeviceDax(
+    umf_devdax_memory_provider_params_handle_t hParams, const char *path,
+    size_t size) {
+    if (hParams == NULL) {
+        LOG_ERR("DevDax Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (path == NULL) {
+        LOG_ERR("DevDax path is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    size_t path_len = strlen(path);
+    if (path_len == 0) {
+        LOG_ERR("DevDax path is empty");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    path_len += 1; // for the null terminator
+    char *new_path = umf_ba_global_alloc(path_len);
+    if (new_path == NULL) {
+        LOG_ERR("Allocating memory for the DevDax path failed");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    strncpy(new_path, path, path_len);
+
+    umf_ba_global_free(hParams->path);
+
+    hParams->path = new_path;
+    hParams->size = size;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfDevDaxMemoryProviderParamsSetProtection(
+    umf_devdax_memory_provider_params_handle_t hParams, unsigned protection) {
+    if (hParams == NULL) {
+        LOG_ERR("DevDax Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    // verify that protection contains only valid bits set
+    // (UMF_PROTECTION_MAX-1) - highest possible bit
+    // (UMF_PROTECTION_MAX-1) << 1 - next after highest possible bit
+    // ((UMF_PROTECTION_MAX-1) << 1) - 1 - all valid bits set
+    const unsigned VALID_FLAGS_ALL = ((UMF_PROTECTION_MAX - 1) << 1) - 1;
+    if (protection & ~VALID_FLAGS_ALL || protection == 0) {
+        LOG_ERR("Incorrect memory protection flags: %u", protection);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->protection = protection;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+#endif // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
diff --git a/src/provider/provider_file_memory.c b/src/provider/provider_file_memory.c
new file mode 100644
index 000000000..b4ff44f8a
--- /dev/null
+++ b/src/provider/provider_file_memory.c
@@ -0,0 +1,993 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <umf.h>
+#include <umf/memory_provider_ops.h>
+#include <umf/providers/provider_file_memory.h>
+
+#include "utils_log.h"
+
+#if defined(_WIN32) || defined(UMF_NO_HWLOC)
+
+const umf_memory_provider_ops_t *umfFileMemoryProviderOps(void) {
+    // not supported
+    LOG_ERR("File memory provider is disabled!");
+    return NULL;
+}
+
+umf_result_t umfFileMemoryProviderParamsCreate(
+    umf_file_memory_provider_params_handle_t *hParams, const char *path) {
+    (void)hParams;
+    (void)path;
+    LOG_ERR("File memory provider is disabled!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfFileMemoryProviderParamsDestroy(
+    umf_file_memory_provider_params_handle_t hParams) {
+    (void)hParams;
+    LOG_ERR("File memory provider is disabled!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfFileMemoryProviderParamsSetPath(
+    umf_file_memory_provider_params_handle_t hParams, const char *path) {
+    (void)hParams;
+    (void)path;
+    LOG_ERR("File memory provider is disabled!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfFileMemoryProviderParamsSetProtection(
+    umf_file_memory_provider_params_handle_t hParams, unsigned protection) {
+    (void)hParams;
+    (void)protection;
+    LOG_ERR("File memory provider is disabled!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfFileMemoryProviderParamsSetVisibility(
+    umf_file_memory_provider_params_handle_t hParams,
+    umf_memory_visibility_t visibility) {
+    (void)hParams;
+    (void)visibility;
+    LOG_ERR("File memory provider is disabled!");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+#else // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
+
+#include "base_alloc_global.h"
+#include "coarse.h"
+#include "critnib.h"
+#include "libumf.h"
+#include "utils_common.h"
+#include "utils_concurrency.h"
+#include "utils_log.h"
+
+#define FSDAX_PAGE_SIZE_2MB ((size_t)(2 * 1024 * 1024)) // == 2 MB
+
+#define TLS_MSG_BUF_LEN 1024
+
+typedef struct file_memory_provider_t {
+    utils_mutex_t lock; // lock for file parameters (size and offsets)
+
+    char path[PATH_MAX]; // a path to the file
+    bool is_fsdax;       // true if file is located on FSDAX
+    int fd;              // file descriptor for memory mapping
+    size_t size_fd;      // size of the file used for memory mappings
+    size_t offset_fd;    // offset in the file used for memory mappings
+
+    void *base_mmap;    // base address of the current memory mapping
+    size_t size_mmap;   // size of the current memory mapping
+    size_t offset_mmap; // data offset in the current memory mapping
+
+    unsigned protection; // combination of OS-specific protection flags
+    unsigned visibility; // memory visibility mode
+    size_t page_size;    // minimum page size
+
+    // IPC is enabled only for the UMF_MEM_MAP_SHARED visibility
+    bool IPC_enabled;
+
+    critnib *mmaps; // a critnib map storing mmap mappings (addr, size)
+
+    // A critnib map storing (ptr, fd_offset + 1) pairs. We add 1 to fd_offset
+    // in order to be able to store fd_offset equal 0, because
+    // critnib_get() returns value or NULL, so a value cannot equal 0.
+    // It is needed mainly in the ipc_get_handle and ipc_open_handle hooks
+    // to mmap a specific part of a file.
+    critnib *fd_offset_map;
+
+    coarse_t *coarse; // coarse library handle
+} file_memory_provider_t;
+
+// File Memory Provider settings struct
+typedef struct umf_file_memory_provider_params_t {
+    char *path;
+    unsigned protection;
+    umf_memory_visibility_t visibility;
+} umf_file_memory_provider_params_t;
+
+typedef struct file_last_native_error_t {
+    int32_t native_error;
+    int errno_value;
+    char msg_buff[TLS_MSG_BUF_LEN];
+} file_last_native_error_t;
+
+static __TLS file_last_native_error_t TLS_last_native_error;
+
+// helper values used only in the Native_error_str array
+#define _UMF_FILE_RESULT_SUCCESS                                               \
+    (UMF_FILE_RESULT_SUCCESS - UMF_FILE_RESULT_SUCCESS)
+#define _UMF_FILE_RESULT_ERROR_ALLOC_FAILED                                    \
+    (UMF_FILE_RESULT_ERROR_ALLOC_FAILED - UMF_FILE_RESULT_SUCCESS)
+#define _UMF_FILE_RESULT_ERROR_FREE_FAILED                                     \
+    (UMF_FILE_RESULT_ERROR_FREE_FAILED - UMF_FILE_RESULT_SUCCESS)
+#define _UMF_FILE_RESULT_ERROR_PURGE_FORCE_FAILED                              \
+    (UMF_FILE_RESULT_ERROR_PURGE_FORCE_FAILED - UMF_FILE_RESULT_SUCCESS)
+
+static const char *Native_error_str[] = {
+    [_UMF_FILE_RESULT_SUCCESS] = "success",
+    [_UMF_FILE_RESULT_ERROR_ALLOC_FAILED] = "memory allocation failed",
+    [_UMF_FILE_RESULT_ERROR_FREE_FAILED] = "memory deallocation failed",
+    [_UMF_FILE_RESULT_ERROR_PURGE_FORCE_FAILED] = "force purging failed",
+};
+
+static void file_store_last_native_error(int32_t native_error,
+                                         int errno_value) {
+    TLS_last_native_error.native_error = native_error;
+    TLS_last_native_error.errno_value = errno_value;
+}
+
+static umf_result_t
+file_translate_params(const umf_file_memory_provider_params_t *in_params,
+                      file_memory_provider_t *provider) {
+    umf_result_t result;
+
+    result = utils_translate_mem_protection_flags(in_params->protection,
+                                                  &provider->protection);
+    if (result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("incorrect memory protection flags: %u", in_params->protection);
+        return result;
+    }
+
+    result = utils_translate_mem_visibility_flag(in_params->visibility,
+                                                 &provider->visibility);
+    if (result != UMF_RESULT_SUCCESS) {
+        LOG_ERR("incorrect memory visibility flag: %u", in_params->visibility);
+        return result;
+    }
+
+    // IPC is enabled only for the UMF_MEM_MAP_SHARED visibility
+    provider->IPC_enabled = (in_params->visibility == UMF_MEM_MAP_SHARED);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t file_alloc_cb(void *provider, size_t size, size_t alignment,
+                                  void **resultPtr);
+static umf_result_t file_allocation_split_cb(void *provider, void *ptr,
+                                             size_t totalSize,
+                                             size_t firstSize);
+static umf_result_t file_allocation_merge_cb(void *provider, void *lowPtr,
+                                             void *highPtr, size_t totalSize);
+
+static umf_result_t file_initialize(const void *params, void **provider) {
+    umf_result_t ret;
+
+    if (params == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    const umf_file_memory_provider_params_t *in_params = params;
+
+    if (in_params->path == NULL) {
+        LOG_ERR("file path is missing");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    file_memory_provider_t *file_provider =
+        umf_ba_global_alloc(sizeof(*file_provider));
+    if (!file_provider) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    memset(file_provider, 0, sizeof(*file_provider));
+
+    ret = file_translate_params(in_params, file_provider);
+    if (ret != UMF_RESULT_SUCCESS) {
+        goto err_free_file_provider;
+    }
+
+    if (utils_copy_path(in_params->path, file_provider->path, PATH_MAX)) {
+        goto err_free_file_provider;
+    }
+
+    file_provider->fd = utils_file_open_or_create(in_params->path);
+    if (file_provider->fd == -1) {
+        LOG_ERR("cannot open the file: %s", in_params->path);
+        ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        goto err_free_file_provider;
+    }
+
+    if (utils_set_file_size(file_provider->fd, FSDAX_PAGE_SIZE_2MB)) {
+        LOG_ERR("cannot set size of the file: %s", in_params->path);
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+        goto err_close_fd;
+    }
+
+    file_provider->size_fd = FSDAX_PAGE_SIZE_2MB;
+
+    LOG_DEBUG("size of the file %s is: %zu", in_params->path,
+              file_provider->size_fd);
+
+    if (!(in_params->visibility & UMF_MEM_MAP_PRIVATE)) {
+        // check if file is located on FSDAX
+        void *addr = utils_mmap_file(
+            NULL, file_provider->size_fd, file_provider->protection,
+            file_provider->visibility, file_provider->fd, 0,
+            &file_provider->is_fsdax);
+        if (addr) {
+            utils_munmap(addr, file_provider->size_fd);
+        }
+    }
+
+    if (file_provider->is_fsdax) {
+        file_provider->page_size = FSDAX_PAGE_SIZE_2MB;
+    } else {
+        file_provider->page_size = utils_get_page_size();
+    }
+
+    coarse_params_t coarse_params = {0};
+    coarse_params.provider = file_provider;
+    coarse_params.page_size = file_provider->page_size;
+    coarse_params.cb.alloc = file_alloc_cb;
+    coarse_params.cb.free = NULL; // not available for the file provider
+    coarse_params.cb.split = file_allocation_split_cb;
+    coarse_params.cb.merge = file_allocation_merge_cb;
+
+    coarse_t *coarse = NULL;
+    ret = coarse_new(&coarse_params, &coarse);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("coarse_new() failed");
+        goto err_close_fd;
+    }
+
+    file_provider->coarse = coarse;
+
+    if (utils_mutex_init(&file_provider->lock) == NULL) {
+        LOG_ERR("lock init failed");
+        ret = UMF_RESULT_ERROR_UNKNOWN;
+        goto err_coarse_delete;
+    }
+
+    file_provider->fd_offset_map = critnib_new(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(NULL, NULL);
+    if (!file_provider->mmaps) {
+        LOG_ERR("creating the map of memory mappings failed");
+        ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        goto err_delete_fd_offset_map;
+    }
+
+    *provider = file_provider;
+
+    return UMF_RESULT_SUCCESS;
+
+err_delete_fd_offset_map:
+    critnib_delete(file_provider->fd_offset_map);
+err_mutex_destroy_not_free:
+    utils_mutex_destroy_not_free(&file_provider->lock);
+err_coarse_delete:
+    coarse_delete(file_provider->coarse);
+err_close_fd:
+    utils_close_fd(file_provider->fd);
+err_free_file_provider:
+    umf_ba_global_free(file_provider);
+    return ret;
+}
+
+static umf_result_t file_finalize(void *provider) {
+    file_memory_provider_t *file_provider = provider;
+
+    uintptr_t key = 0;
+    uintptr_t rkey = 0;
+    void *rvalue = NULL;
+    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, NULL);
+        key = rkey;
+    }
+
+    utils_mutex_destroy_not_free(&file_provider->lock);
+
+    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,
+                                      size_t size, size_t alignment) {
+    int prot = file_provider->protection;
+    int flag = file_provider->visibility;
+    int fd = file_provider->fd;
+    size_t size_fd = file_provider->size_fd;
+    size_t offset_fd = file_provider->offset_fd;
+    size_t page_size = file_provider->page_size;
+
+    assert(fd > 0);
+
+    // We have to increase size by alignment to be able to "cut out"
+    // the correctly aligned part of the memory
+    size_t extended_size = size + alignment;
+    if (extended_size < size) {
+        LOG_ERR("invalid size of allocation");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT; // arithmetic overflow
+    }
+
+    size_t rest = extended_size & (page_size - 1);
+    if (rest) {
+        extended_size += page_size - rest;
+    }
+    if (extended_size < size) {
+        LOG_ERR("invalid size of allocation");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT; // arithmetic overflow
+    }
+
+    // offset_fd has to be also page-aligned since it is the offset of mmap()
+    size_t aligned_offset_fd = offset_fd;
+    rest = aligned_offset_fd & (page_size - 1);
+    if (rest) {
+        aligned_offset_fd += page_size - rest;
+    }
+    if (aligned_offset_fd < offset_fd) {
+        LOG_ERR("arithmetic overflow of file offset");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT; // arithmetic overflow
+    }
+
+    if (aligned_offset_fd + extended_size > size_fd) {
+        size_t new_size_fd = aligned_offset_fd + extended_size;
+        if (utils_fallocate(fd, size_fd, new_size_fd - size_fd)) {
+            LOG_ERR("cannot grow the file size from %zu to %zu", size_fd,
+                    new_size_fd);
+            return UMF_RESULT_ERROR_UNKNOWN;
+        }
+
+        LOG_DEBUG("file size grown from %zu to %zu", size_fd, new_size_fd);
+        file_provider->size_fd = new_size_fd;
+    }
+
+    if (aligned_offset_fd > offset_fd) {
+        file_provider->offset_fd = aligned_offset_fd;
+    }
+
+    ASSERT_IS_ALIGNED(extended_size, page_size);
+    ASSERT_IS_ALIGNED(aligned_offset_fd, page_size);
+
+    void *ptr = utils_mmap_file(NULL, extended_size, prot, flag, fd,
+                                aligned_offset_fd, NULL);
+    if (ptr == NULL) {
+        LOG_PERR("memory mapping failed");
+        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    }
+
+    int ret = critnib_insert(file_provider->mmaps, (uintptr_t)ptr,
+                             (void *)(uintptr_t)extended_size, 0 /* update */);
+    if (ret) {
+        LOG_ERR("inserting a value to the map of memory mapping failed "
+                "(addr=%p, size=%zu)",
+                ptr, extended_size);
+    }
+
+    LOG_DEBUG(
+        "inserted a value to the map of memory mapping (addr=%p, size=%zu)",
+        ptr, extended_size);
+
+    // align the new pointer
+    uintptr_t aligned_ptr = ALIGN_UP_SAFE((uintptr_t)ptr, alignment);
+    size_t aligned_size = extended_size - (aligned_ptr - (uintptr_t)ptr);
+
+    file_provider->base_mmap = (void *)aligned_ptr;
+    file_provider->size_mmap = aligned_size;
+    file_provider->offset_mmap = 0;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t file_alloc_aligned(file_memory_provider_t *file_provider,
+                                       size_t size, size_t alignment,
+                                       void **out_addr,
+                                       size_t *alloc_offset_fd) {
+    assert(alloc_offset_fd);
+    assert(out_addr);
+
+    umf_result_t umf_result;
+
+    if (utils_mutex_lock(&file_provider->lock)) {
+        LOG_ERR("locking file data failed");
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    assert(file_provider->offset_mmap <= file_provider->size_mmap);
+
+    if (file_provider->size_mmap - file_provider->offset_mmap < size) {
+        umf_result = file_mmap_aligned(file_provider, size, alignment);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            utils_mutex_unlock(&file_provider->lock);
+            return umf_result;
+        }
+    }
+
+    void *base_mmap = file_provider->base_mmap;
+    assert(base_mmap);
+
+    uintptr_t new_aligned_ptr =
+        (uintptr_t)base_mmap + file_provider->offset_mmap;
+    if (alignment) {
+        uintptr_t rest = new_aligned_ptr & (alignment - 1);
+        if (rest) {
+            new_aligned_ptr += alignment - rest;
+        }
+        ASSERT_IS_ALIGNED(new_aligned_ptr, alignment);
+    }
+
+    size_t new_offset_mmap = new_aligned_ptr - (uintptr_t)base_mmap;
+    size_t new_offset_fd =
+        file_provider->offset_fd + new_offset_mmap - file_provider->offset_mmap;
+
+    // new_offset_mmap can be greater than file_provider->size_mmap
+    if (file_provider->size_mmap < size + new_offset_mmap) {
+        umf_result = file_mmap_aligned(file_provider, size, alignment);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            utils_mutex_unlock(&file_provider->lock);
+            return umf_result;
+        }
+
+        assert(file_provider->base_mmap);
+
+        // file_provider-> base_mmap, offset_mmap, offset_fd
+        // were updated by file_mmap_aligned():
+        new_aligned_ptr = (uintptr_t)file_provider->base_mmap;
+        new_offset_mmap = 0; // == file_provider->offset_mmap
+        new_offset_fd = file_provider->offset_fd;
+
+        ASSERT_IS_ALIGNED(new_aligned_ptr, alignment);
+    }
+
+    *alloc_offset_fd = new_offset_fd;
+
+    file_provider->offset_fd = new_offset_fd + size;
+    file_provider->offset_mmap = new_offset_mmap + size;
+
+    *out_addr = (void *)new_aligned_ptr;
+
+    utils_mutex_unlock(&file_provider->lock);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t file_alloc(void *provider, size_t size, size_t alignment,
+                               void **resultPtr) {
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    return coarse_alloc(file_provider->coarse, size, alignment, resultPtr);
+}
+
+static umf_result_t file_alloc_cb(void *provider, size_t size, size_t alignment,
+                                  void **resultPtr) {
+    umf_result_t umf_result;
+    int ret;
+
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+
+    *resultPtr = NULL;
+
+    // alignment must be a power of two and a multiple or a divider of the page size
+    if (alignment && ((alignment & (alignment - 1)) ||
+                      ((alignment % file_provider->page_size) &&
+                       (file_provider->page_size % alignment)))) {
+        LOG_ERR("wrong alignment: %zu (not a power of 2 or a multiple or a "
+                "divider of the page size (%zu))",
+                alignment, file_provider->page_size);
+        return UMF_RESULT_ERROR_INVALID_ALIGNMENT;
+    }
+
+    if (IS_NOT_ALIGNED(alignment, file_provider->page_size)) {
+        alignment = ALIGN_UP(alignment, file_provider->page_size);
+    }
+
+    void *addr = NULL;
+    size_t alloc_offset_fd; // needed for critnib_insert()
+    umf_result = file_alloc_aligned(file_provider, size, alignment, &addr,
+                                    &alloc_offset_fd);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        file_store_last_native_error(UMF_FILE_RESULT_ERROR_ALLOC_FAILED, 0);
+        LOG_ERR("memory allocation failed");
+        return umf_result;
+    }
+
+    // store (offset_fd + 1) to be able to store offset_fd == 0
+    ret = critnib_insert(file_provider->fd_offset_map, (uintptr_t)addr,
+                         (void *)(uintptr_t)(alloc_offset_fd + 1),
+                         0 /* update */);
+    if (ret) {
+        LOG_ERR("inserting a value to the file descriptor offset map failed "
+                "(addr=%p, offset=%zu)",
+                addr, alloc_offset_fd);
+        // We cannot undo the file_alloc_aligned() call here,
+        // because the file memory provider does not support the free operation.
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    LOG_DEBUG("inserted a value to the file descriptor offset map (addr=%p, "
+              "offset=%zu)",
+              addr, alloc_offset_fd);
+
+    *resultPtr = addr;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static void file_get_last_native_error(void *provider, const char **ppMessage,
+                                       int32_t *pError) {
+    (void)provider; // unused
+
+    if (ppMessage == NULL || pError == NULL) {
+        assert(0);
+        return;
+    }
+
+    *pError = TLS_last_native_error.native_error;
+    if (TLS_last_native_error.errno_value == 0) {
+        *ppMessage = Native_error_str[*pError - UMF_FILE_RESULT_SUCCESS];
+        return;
+    }
+
+    const char *msg;
+    size_t len;
+    size_t pos = 0;
+
+    msg = Native_error_str[*pError - UMF_FILE_RESULT_SUCCESS];
+    len = strlen(msg);
+    memcpy(TLS_last_native_error.msg_buff + pos, msg, len + 1);
+    pos += len;
+
+    msg = ": ";
+    len = strlen(msg);
+    memcpy(TLS_last_native_error.msg_buff + pos, msg, len + 1);
+    pos += len;
+
+    utils_strerror(TLS_last_native_error.errno_value,
+                   TLS_last_native_error.msg_buff + pos, TLS_MSG_BUF_LEN - pos);
+
+    *ppMessage = TLS_last_native_error.msg_buff;
+}
+
+static umf_result_t file_get_recommended_page_size(void *provider, size_t size,
+                                                   size_t *page_size) {
+    (void)provider; // unused
+    (void)size;     // unused
+
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    *page_size = file_provider->page_size;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t file_get_min_page_size(void *provider, const void *ptr,
+                                           size_t *page_size) {
+    (void)ptr; // unused
+
+    return file_get_recommended_page_size(provider, 0, page_size);
+}
+
+static umf_result_t file_purge_lazy(void *provider, void *ptr, size_t size) {
+    (void)provider; // unused
+    (void)ptr;      // unused
+    (void)size;     // unused
+    // purge_lazy is unsupported in case of the file memory provider,
+    // because the MADV_FREE operation can be applied
+    // only to private anonymous pages (see madvise(2)).
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+static umf_result_t file_purge_force(void *provider, void *ptr, size_t size) {
+    (void)provider; // unused
+
+    errno = 0;
+    if (utils_purge(ptr, size, UMF_PURGE_FORCE)) {
+        file_store_last_native_error(UMF_FILE_RESULT_ERROR_PURGE_FORCE_FAILED,
+                                     errno);
+        LOG_PERR("force purging failed");
+        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    }
+    return UMF_RESULT_SUCCESS;
+}
+
+static const char *file_get_name(void *provider) {
+    (void)provider; // unused
+    return "FILE";
+}
+
+static umf_result_t file_allocation_split(void *provider, void *ptr,
+                                          size_t totalSize, size_t firstSize) {
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    return coarse_split(file_provider->coarse, ptr, totalSize, firstSize);
+}
+
+static umf_result_t file_allocation_split_cb(void *provider, void *ptr,
+                                             size_t totalSize,
+                                             size_t firstSize) {
+    (void)totalSize;
+
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    if (file_provider->fd <= 0) {
+        return UMF_RESULT_SUCCESS;
+    }
+
+    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)",
+                ptr);
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    LOG_DEBUG("split the value from the file descriptor offset map (addr=%p) "
+              "from size %zu to %zu + %zu",
+              ptr, totalSize, firstSize, totalSize - firstSize);
+
+    uintptr_t new_key = (uintptr_t)ptr + firstSize;
+    void *new_value = (void *)((uintptr_t)value + firstSize);
+    int ret = critnib_insert(file_provider->fd_offset_map, new_key, new_value,
+                             0 /* update */);
+    if (ret) {
+        LOG_ERR("inserting a value to the file descriptor offset map failed "
+                "(addr=%p, offset=%zu)",
+                (void *)new_key, (size_t)new_value - 1);
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    LOG_DEBUG("inserted a value to the file descriptor offset map (addr=%p, "
+              "offset=%zu)",
+              (void *)new_key, (size_t)new_value - 1);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t file_allocation_merge(void *provider, void *lowPtr,
+                                          void *highPtr, size_t totalSize) {
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    return coarse_merge(file_provider->coarse, lowPtr, highPtr, totalSize);
+}
+
+static umf_result_t file_allocation_merge_cb(void *provider, void *lowPtr,
+                                             void *highPtr, size_t totalSize) {
+    (void)lowPtr;
+    (void)totalSize;
+
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    if (file_provider->fd <= 0) {
+        return UMF_RESULT_SUCCESS;
+    }
+
+    void *value =
+        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)",
+                highPtr);
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    LOG_DEBUG("removed a value from the file descriptor offset map (addr=%p) - "
+              "merged with %p",
+              highPtr, lowPtr);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+typedef struct file_ipc_data_t {
+    char path[PATH_MAX];
+    size_t offset_fd;
+    size_t size;
+    unsigned protection; // combination of OS-specific protection flags
+    unsigned visibility; // memory visibility mode
+} file_ipc_data_t;
+
+static umf_result_t file_get_ipc_handle_size(void *provider, size_t *size) {
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    if (!file_provider->IPC_enabled) {
+        LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    *size = sizeof(file_ipc_data_t);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t file_get_ipc_handle(void *provider, const void *ptr,
+                                        size_t size, void *providerIpcData) {
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    if (!file_provider->IPC_enabled) {
+        LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    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;
+    }
+
+    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);
+    file_ipc_data->path[PATH_MAX - 1] = '\0';
+    file_ipc_data->protection = file_provider->protection;
+    file_ipc_data->visibility = file_provider->visibility;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t file_put_ipc_handle(void *provider, void *providerIpcData) {
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    if (!file_provider->IPC_enabled) {
+        LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    file_ipc_data_t *file_ipc_data = (file_ipc_data_t *)providerIpcData;
+
+    if (strncmp(file_ipc_data->path, file_provider->path, PATH_MAX)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t file_open_ipc_handle(void *provider, void *providerIpcData,
+                                         void **ptr) {
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    if (!file_provider->IPC_enabled) {
+        LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    file_ipc_data_t *file_ipc_data = (file_ipc_data_t *)providerIpcData;
+    umf_result_t ret = UMF_RESULT_SUCCESS;
+    int fd;
+
+    size_t offset_aligned = file_ipc_data->offset_fd;
+    size_t size_aligned = file_ipc_data->size;
+
+    if (file_provider->is_fsdax) {
+        // It is just a workaround for case when
+        // file_alloc() was called with the size argument
+        // that is not a multiplier of FSDAX_PAGE_SIZE_2MB.
+        utils_align_ptr_down_size_up((void **)&offset_aligned, &size_aligned,
+                                     FSDAX_PAGE_SIZE_2MB);
+    }
+
+    fd = utils_file_open(file_ipc_data->path);
+    if (fd == -1) {
+        LOG_PERR("opening the file to be mapped (%s) failed",
+                 file_ipc_data->path);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    char *addr =
+        utils_mmap_file(NULL, size_aligned, file_ipc_data->protection,
+                        file_ipc_data->visibility, fd, offset_aligned, NULL);
+    (void)utils_close_fd(fd);
+    if (addr == NULL) {
+        file_store_last_native_error(UMF_FILE_RESULT_ERROR_ALLOC_FAILED, errno);
+        LOG_PERR("file mapping failed (path: %s, size: %zu, protection: %u, "
+                 "visibility: %u, fd: %i, offset: %zu)",
+                 file_ipc_data->path, size_aligned, file_ipc_data->protection,
+                 file_ipc_data->visibility, fd, offset_aligned);
+        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    }
+
+    LOG_DEBUG("file mapped (path: %s, size: %zu, protection: %u, visibility: "
+              "%u, fd: %i, offset: %zu) at address %p",
+              file_ipc_data->path, size_aligned, file_ipc_data->protection,
+              file_ipc_data->visibility, fd, offset_aligned, (void *)addr);
+
+    *ptr = addr;
+
+    return ret;
+}
+
+static umf_result_t file_close_ipc_handle(void *provider, void *ptr,
+                                          size_t size) {
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    if (!file_provider->IPC_enabled) {
+        LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (file_provider->is_fsdax) {
+        // It is just a workaround for case when
+        // file_alloc() was called with the size argument
+        // that is not a multiplier of FSDAX_PAGE_SIZE_2MB.
+        utils_align_ptr_down_size_up(&ptr, &size, FSDAX_PAGE_SIZE_2MB);
+    }
+
+    errno = 0;
+    int ret = utils_munmap(ptr, size);
+    // ignore error when size == 0
+    if (ret && (size > 0)) {
+        file_store_last_native_error(UMF_FILE_RESULT_ERROR_FREE_FAILED, errno);
+        LOG_PERR("memory unmapping failed");
+
+        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t file_free(void *provider, void *ptr, size_t size) {
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    return coarse_free(file_provider->coarse, ptr, size);
+}
+
+static umf_memory_provider_ops_t UMF_FILE_MEMORY_PROVIDER_OPS = {
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
+    .initialize = file_initialize,
+    .finalize = file_finalize,
+    .alloc = file_alloc,
+    .free = file_free,
+    .get_last_native_error = file_get_last_native_error,
+    .get_recommended_page_size = file_get_recommended_page_size,
+    .get_min_page_size = file_get_min_page_size,
+    .get_name = file_get_name,
+    .ext_purge_lazy = file_purge_lazy,
+    .ext_purge_force = file_purge_force,
+    .ext_allocation_merge = file_allocation_merge,
+    .ext_allocation_split = file_allocation_split,
+    .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;
+}
+
+umf_result_t umfFileMemoryProviderParamsCreate(
+    umf_file_memory_provider_params_handle_t *hParams, const char *path) {
+    libumfInit();
+    if (hParams == NULL) {
+        LOG_ERR("File Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (path == NULL) {
+        LOG_ERR("File path is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_file_memory_provider_params_handle_t params =
+        umf_ba_global_alloc(sizeof(*params));
+    if (params == NULL) {
+        LOG_ERR("allocating memory for File Memory Provider params failed");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    params->path = NULL;
+    params->protection = UMF_PROTECTION_READ | UMF_PROTECTION_WRITE;
+    params->visibility = UMF_MEM_MAP_PRIVATE;
+
+    umf_result_t res = umfFileMemoryProviderParamsSetPath(params, path);
+    if (res != UMF_RESULT_SUCCESS) {
+        umf_ba_global_free(params);
+        return res;
+    }
+
+    *hParams = params;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfFileMemoryProviderParamsDestroy(
+    umf_file_memory_provider_params_handle_t hParams) {
+    if (hParams != NULL) {
+        umf_ba_global_free(hParams->path);
+        umf_ba_global_free(hParams);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfFileMemoryProviderParamsSetPath(
+    umf_file_memory_provider_params_handle_t hParams, const char *path) {
+    if (hParams == NULL) {
+        LOG_ERR("File Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (path == NULL) {
+        LOG_ERR("File path is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    size_t len = strlen(path);
+    if (len == 0) {
+        LOG_ERR("File path is empty");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    len += 1; // for the null terminator
+    char *new_path = NULL;
+    new_path = umf_ba_global_alloc(len);
+    if (new_path == NULL) {
+        LOG_ERR("allocating memory for the file path failed");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    strncpy(new_path, path, len);
+
+    umf_ba_global_free(hParams->path);
+    hParams->path = new_path;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfFileMemoryProviderParamsSetProtection(
+    umf_file_memory_provider_params_handle_t hParams, unsigned protection) {
+    if (hParams == NULL) {
+        LOG_ERR("File Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->protection = protection;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfFileMemoryProviderParamsSetVisibility(
+    umf_file_memory_provider_params_handle_t hParams,
+    umf_memory_visibility_t visibility) {
+    if (hParams == NULL) {
+        LOG_ERR("File Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->visibility = visibility;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+#endif // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
diff --git a/src/provider/provider_fixed_memory.c b/src/provider/provider_fixed_memory.c
new file mode 100644
index 000000000..c30044946
--- /dev/null
+++ b/src/provider/provider_fixed_memory.c
@@ -0,0 +1,372 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <umf.h>
+#include <umf/memory_provider_ops.h>
+#include <umf/providers/provider_fixed_memory.h>
+
+#include "base_alloc_global.h"
+#include "coarse.h"
+#include "libumf.h"
+#include "provider_ctl_stats_type.h"
+#include "utils_common.h"
+#include "utils_concurrency.h"
+#include "utils_log.h"
+
+#define TLS_MSG_BUF_LEN 1024
+
+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
+typedef struct umf_fixed_memory_provider_params_t {
+    void *ptr;
+    size_t size;
+} umf_fixed_memory_provider_params_t;
+
+typedef struct fixed_last_native_error_t {
+    int32_t native_error;
+    int errno_value;
+    char msg_buff[TLS_MSG_BUF_LEN];
+} fixed_last_native_error_t;
+
+static __TLS fixed_last_native_error_t TLS_last_native_error;
+
+// helper values used only in the Native_error_str array
+#define _UMF_FIXED_RESULT_SUCCESS                                              \
+    (UMF_FIXED_RESULT_SUCCESS - UMF_FIXED_RESULT_SUCCESS)
+#define _UMF_FIXED_RESULT_ERROR_PURGE_FORCE_FAILED                             \
+    (UMF_FIXED_RESULT_ERROR_PURGE_FORCE_FAILED - UMF_FIXED_RESULT_SUCCESS)
+
+#define CTL_PROVIDER_TYPE fixed_memory_provider_t
+#include "provider_ctl_stats_impl.h"
+
+struct ctl fixed_memory_ctl_root;
+static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT;
+
+static 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"};
+
+static void fixed_store_last_native_error(int32_t native_error,
+                                          int errno_value) {
+    TLS_last_native_error.native_error = native_error;
+    TLS_last_native_error.errno_value = errno_value;
+}
+
+static umf_result_t fixed_allocation_split_cb(void *provider, void *ptr,
+                                              size_t totalSize,
+                                              size_t firstSize) {
+    (void)provider;
+    (void)ptr;
+    (void)totalSize;
+    (void)firstSize;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t fixed_allocation_merge_cb(void *provider, void *lowPtr,
+                                              void *highPtr, size_t totalSize) {
+    (void)provider;
+    (void)lowPtr;
+    (void)highPtr;
+    (void)totalSize;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t fixed_initialize(const void *params, void **provider) {
+    umf_result_t ret;
+
+    if (params == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    const umf_fixed_memory_provider_params_t *in_params = params;
+
+    fixed_memory_provider_t *fixed_provider =
+        umf_ba_global_alloc(sizeof(*fixed_provider));
+    if (!fixed_provider) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    memset(fixed_provider, 0, sizeof(*fixed_provider));
+
+    coarse_params_t coarse_params = {0};
+    coarse_params.provider = fixed_provider;
+    coarse_params.page_size = utils_get_page_size();
+    // The alloc callback is not available in case of the fixed provider
+    // because it is a fixed-size memory provider
+    // and the entire memory is added as a single block
+    // to the coarse library.
+    coarse_params.cb.alloc = NULL;
+    coarse_params.cb.free = NULL; // not available for the fixed provider
+    coarse_params.cb.split = fixed_allocation_split_cb;
+    coarse_params.cb.merge = fixed_allocation_merge_cb;
+
+    coarse_t *coarse = NULL;
+    ret = coarse_new(&coarse_params, &coarse);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("coarse_new() failed");
+        goto err_free_fixed_provider;
+    }
+
+    fixed_provider->coarse = coarse;
+
+    fixed_provider->base = in_params->ptr;
+    fixed_provider->size = in_params->size;
+
+    // add the entire memory as a single block
+    ret = coarse_add_memory_fixed(coarse, fixed_provider->base,
+                                  fixed_provider->size);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("adding memory block failed");
+        goto err_coarse_delete;
+    }
+
+    *provider = fixed_provider;
+
+    return UMF_RESULT_SUCCESS;
+
+err_coarse_delete:
+    coarse_delete(fixed_provider->coarse);
+err_free_fixed_provider:
+    umf_ba_global_free(fixed_provider);
+    return ret;
+}
+
+static umf_result_t fixed_finalize(void *provider) {
+    fixed_memory_provider_t *fixed_provider = provider;
+    coarse_delete(fixed_provider->coarse);
+    umf_ba_global_free(fixed_provider);
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t fixed_alloc(void *provider, size_t size, size_t alignment,
+                                void **resultPtr) {
+    fixed_memory_provider_t *fixed_provider =
+        (fixed_memory_provider_t *)provider;
+
+    umf_result_t ret =
+        coarse_alloc(fixed_provider->coarse, size, alignment, resultPtr);
+
+    if (ret == UMF_RESULT_SUCCESS) {
+        provider_ctl_stats_alloc(fixed_provider, size);
+    }
+
+    return ret;
+}
+
+static void fixed_get_last_native_error(void *provider, const char **ppMessage,
+                                        int32_t *pError) {
+    (void)provider; // unused
+
+    if (ppMessage == NULL || pError == NULL) {
+        assert(0);
+        return;
+    }
+
+    *pError = TLS_last_native_error.native_error;
+    if (TLS_last_native_error.errno_value == 0) {
+        *ppMessage = Native_error_str[*pError - UMF_FIXED_RESULT_SUCCESS];
+        return;
+    }
+
+    const char *msg;
+    size_t len;
+    size_t pos = 0;
+
+    msg = Native_error_str[*pError - UMF_FIXED_RESULT_SUCCESS];
+    len = strlen(msg);
+    memcpy(TLS_last_native_error.msg_buff + pos, msg, len + 1);
+    pos += len;
+
+    msg = ": ";
+    len = strlen(msg);
+    memcpy(TLS_last_native_error.msg_buff + pos, msg, len + 1);
+    pos += len;
+
+    utils_strerror(TLS_last_native_error.errno_value,
+                   TLS_last_native_error.msg_buff + pos, TLS_MSG_BUF_LEN - pos);
+
+    *ppMessage = TLS_last_native_error.msg_buff;
+}
+
+static umf_result_t fixed_get_recommended_page_size(void *provider, size_t size,
+                                                    size_t *page_size) {
+    (void)provider; // unused
+    (void)size;     // unused
+
+    *page_size = utils_get_page_size();
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t fixed_get_min_page_size(void *provider, const void *ptr,
+                                            size_t *page_size) {
+    (void)ptr; // unused
+
+    return fixed_get_recommended_page_size(provider, 0, page_size);
+}
+
+static umf_result_t fixed_purge_lazy(void *provider, void *ptr, size_t size) {
+    (void)provider; // unused
+    (void)ptr;      // unused
+    (void)size;     // unused
+    // purge_lazy is unsupported in case of the fixed memory provider
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+static umf_result_t fixed_purge_force(void *provider, void *ptr, size_t size) {
+    (void)provider; // unused
+    errno = 0;
+    if (utils_purge(ptr, size, UMF_PURGE_FORCE)) {
+        fixed_store_last_native_error(UMF_FIXED_RESULT_ERROR_PURGE_FORCE_FAILED,
+                                      errno);
+        LOG_PERR("force purging failed");
+        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    }
+    return UMF_RESULT_SUCCESS;
+}
+
+static const char *fixed_get_name(void *provider) {
+    (void)provider; // unused
+    return "FIXED";
+}
+
+static umf_result_t fixed_allocation_split(void *provider, void *ptr,
+                                           size_t totalSize, size_t firstSize) {
+    fixed_memory_provider_t *fixed_provider =
+        (fixed_memory_provider_t *)provider;
+    return coarse_split(fixed_provider->coarse, ptr, totalSize, firstSize);
+}
+
+static umf_result_t fixed_allocation_merge(void *provider, void *lowPtr,
+                                           void *highPtr, size_t totalSize) {
+    fixed_memory_provider_t *fixed_provider =
+        (fixed_memory_provider_t *)provider;
+    return coarse_merge(fixed_provider->coarse, lowPtr, highPtr, totalSize);
+}
+
+static umf_result_t fixed_free(void *provider, void *ptr, size_t size) {
+    fixed_memory_provider_t *fixed_provider =
+        (fixed_memory_provider_t *)provider;
+
+    umf_result_t ret = coarse_free(fixed_provider->coarse, ptr, size);
+
+    if (ret == UMF_RESULT_SUCCESS) {
+        provider_ctl_stats_free(fixed_provider, size);
+    }
+
+    return ret;
+}
+
+static umf_result_t fixed_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 = {
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
+    .initialize = fixed_initialize,
+    .finalize = fixed_finalize,
+    .alloc = fixed_alloc,
+    .free = fixed_free,
+    .get_last_native_error = fixed_get_last_native_error,
+    .get_recommended_page_size = fixed_get_recommended_page_size,
+    .get_min_page_size = fixed_get_min_page_size,
+    .get_name = fixed_get_name,
+    .ext_purge_lazy = fixed_purge_lazy,
+    .ext_purge_force = fixed_purge_force,
+    .ext_allocation_merge = fixed_allocation_merge,
+    .ext_allocation_split = fixed_allocation_split,
+    .ext_get_ipc_handle_size = NULL,
+    .ext_get_ipc_handle = NULL,
+    .ext_put_ipc_handle = NULL,
+    .ext_open_ipc_handle = NULL,
+    .ext_close_ipc_handle = NULL,
+    .ext_ctl = fixed_ctl};
+
+const umf_memory_provider_ops_t *umfFixedMemoryProviderOps(void) {
+    return &UMF_FIXED_MEMORY_PROVIDER_OPS;
+}
+
+umf_result_t umfFixedMemoryProviderParamsCreate(
+    umf_fixed_memory_provider_params_handle_t *hParams, void *ptr,
+    size_t size) {
+    libumfInit();
+    if (hParams == NULL) {
+        LOG_ERR("Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_fixed_memory_provider_params_handle_t params =
+        umf_ba_global_alloc(sizeof(*params));
+    if (params == NULL) {
+        LOG_ERR("Allocating memory for the Memory Provider params failed");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    umf_result_t ret = umfFixedMemoryProviderParamsSetMemory(params, ptr, size);
+    if (ret != UMF_RESULT_SUCCESS) {
+        umf_ba_global_free(params);
+        return ret;
+    }
+
+    *hParams = params;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfFixedMemoryProviderParamsDestroy(
+    umf_fixed_memory_provider_params_handle_t hParams) {
+    if (hParams != NULL) {
+        umf_ba_global_free(hParams);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfFixedMemoryProviderParamsSetMemory(
+    umf_fixed_memory_provider_params_handle_t hParams, void *ptr, size_t size) {
+
+    if (hParams == NULL) {
+        LOG_ERR("Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (ptr == NULL) {
+        LOG_ERR("Memory pointer is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (size == 0) {
+        LOG_ERR("Size must be greater than 0");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->ptr = ptr;
+    hParams->size = size;
+    return UMF_RESULT_SUCCESS;
+}
diff --git a/src/provider/provider_level_zero.c b/src/provider/provider_level_zero.c
index 3f7340556..ca91ac2a0 100644
--- a/src/provider/provider_level_zero.c
+++ b/src/provider/provider_level_zero.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -14,19 +14,65 @@
 #include <umf/memory_provider_ops.h>
 #include <umf/providers/provider_level_zero.h>
 
+#include "provider_level_zero_internal.h"
+#include "utils_load_library.h"
+#include "utils_log.h"
+
+static void *ze_lib_handle = NULL;
+
+void fini_ze_global_state(void) {
+    if (ze_lib_handle) {
+        utils_close_library(ze_lib_handle);
+        ze_lib_handle = NULL;
+    }
+}
+
+#if UMF_BUILD_LEVEL_ZERO_PROVIDER
+
 #include "base_alloc_global.h"
+#include "libumf.h"
 #include "utils_assert.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
-#include "utils_load_library.h"
 #include "utils_log.h"
 #include "utils_sanitizers.h"
 #include "ze_api.h"
 
+// Level Zero Memory Provider settings struct
+typedef struct umf_level_zero_memory_provider_params_t {
+    ze_context_handle_t
+        level_zero_context_handle; ///< Handle to the Level Zero context
+    ze_device_handle_t
+        level_zero_device_handle; ///< Handle to the Level Zero device
+
+    umf_usm_memory_type_t memory_type; ///< Allocation memory type
+
+    ze_device_handle_t *
+        resident_device_handles; ///< Array of devices for which the memory should be made resident
+    uint32_t
+        resident_device_count; ///< Number of devices for which the memory should be made resident
+
+    umf_level_zero_memory_provider_free_policy_t
+        freePolicy; ///< Memory free policy
+
+    uint32_t device_ordinal;
+} umf_level_zero_memory_provider_params_t;
+
 typedef struct ze_memory_provider_t {
     ze_context_handle_t context;
     ze_device_handle_t device;
     ze_memory_type_t memory_type;
+
+    ze_device_handle_t *resident_device_handles;
+    uint32_t resident_device_count;
+
+    ze_device_properties_t device_properties;
+
+    ze_driver_memory_free_policy_ext_flags_t freePolicyFlags;
+
+    size_t min_page_size;
+
+    uint32_t device_ordinal;
 } ze_memory_provider_t;
 
 typedef struct ze_ops_t {
@@ -48,98 +94,282 @@ typedef struct ze_ops_t {
                                       ze_ipc_mem_handle_t,
                                       ze_ipc_memory_flags_t, void **);
     ze_result_t (*zeMemCloseIpcHandle)(ze_context_handle_t, void *);
+    ze_result_t (*zeContextMakeMemoryResident)(ze_context_handle_t,
+                                               ze_device_handle_t, void *,
+                                               size_t);
+    ze_result_t (*zeDeviceGetProperties)(ze_device_handle_t,
+                                         ze_device_properties_t *);
+    ze_result_t (*zeMemFreeExt)(ze_context_handle_t,
+                                ze_memory_free_ext_desc_t *, void *);
+    ze_result_t (*zeMemGetAllocProperties)(ze_context_handle_t, const void *,
+                                           ze_memory_allocation_properties_t *,
+                                           ze_device_handle_t *);
 } ze_ops_t;
 
 static ze_ops_t g_ze_ops;
 static UTIL_ONCE_FLAG ze_is_initialized = UTIL_ONCE_FLAG_INIT;
 static bool Init_ze_global_state_failed;
+static __TLS ze_result_t TLS_last_native_error;
+
+static void store_last_native_error(int32_t native_error) {
+    TLS_last_native_error = native_error;
+}
+
+static umf_result_t ze2umf_result(ze_result_t result) {
+    switch (result) {
+    case ZE_RESULT_SUCCESS:
+        return UMF_RESULT_SUCCESS;
+    case ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY:
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    case ZE_RESULT_ERROR_INVALID_ARGUMENT:
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    default:
+        store_last_native_error(result);
+        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    }
+}
+
+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
-    // check if Level Zero shared library is already loaded
-    // we pass 0 as a handle to search the global symbol table
+    // The Level Zero shared library should be already loaded by the user
+    // of the Level Zero provider. UMF just want to reuse it
+    // and increase the reference count to the Level Zero shared library.
+    void *lib_handle =
+        utils_open_library(lib_name, UMF_UTIL_OPEN_LIBRARY_NO_LOAD);
+    if (!lib_handle) {
+        LOG_FATAL("Failed to open Level Zero shared library");
+        Init_ze_global_state_failed = true;
+        return;
+    }
+
     *(void **)&g_ze_ops.zeMemAllocHost =
-        util_get_symbol_addr(0, "zeMemAllocHost", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemAllocHost", lib_name);
     *(void **)&g_ze_ops.zeMemAllocDevice =
-        util_get_symbol_addr(0, "zeMemAllocDevice", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemAllocDevice", lib_name);
     *(void **)&g_ze_ops.zeMemAllocShared =
-        util_get_symbol_addr(0, "zeMemAllocShared", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemAllocShared", lib_name);
     *(void **)&g_ze_ops.zeMemFree =
-        util_get_symbol_addr(0, "zeMemFree", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemFree", lib_name);
     *(void **)&g_ze_ops.zeMemGetIpcHandle =
-        util_get_symbol_addr(0, "zeMemGetIpcHandle", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemGetIpcHandle", lib_name);
     *(void **)&g_ze_ops.zeMemPutIpcHandle =
-        util_get_symbol_addr(0, "zeMemPutIpcHandle", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemPutIpcHandle", lib_name);
     *(void **)&g_ze_ops.zeMemOpenIpcHandle =
-        util_get_symbol_addr(0, "zeMemOpenIpcHandle", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemOpenIpcHandle", lib_name);
     *(void **)&g_ze_ops.zeMemCloseIpcHandle =
-        util_get_symbol_addr(0, "zeMemCloseIpcHandle", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemCloseIpcHandle", lib_name);
+    *(void **)&g_ze_ops.zeContextMakeMemoryResident = utils_get_symbol_addr(
+        lib_handle, "zeContextMakeMemoryResident", lib_name);
+    *(void **)&g_ze_ops.zeDeviceGetProperties =
+        utils_get_symbol_addr(lib_handle, "zeDeviceGetProperties", lib_name);
+    *(void **)&g_ze_ops.zeMemFreeExt =
+        utils_get_symbol_addr(lib_handle, "zeMemFreeExt", lib_name);
+    *(void **)&g_ze_ops.zeMemGetAllocProperties =
+        utils_get_symbol_addr(lib_handle, "zeMemGetAllocProperties", lib_name);
 
     if (!g_ze_ops.zeMemAllocHost || !g_ze_ops.zeMemAllocDevice ||
         !g_ze_ops.zeMemAllocShared || !g_ze_ops.zeMemFree ||
         !g_ze_ops.zeMemGetIpcHandle || !g_ze_ops.zeMemOpenIpcHandle ||
-        !g_ze_ops.zeMemCloseIpcHandle) {
+        !g_ze_ops.zeMemCloseIpcHandle ||
+        !g_ze_ops.zeContextMakeMemoryResident ||
+        !g_ze_ops.zeDeviceGetProperties || !g_ze_ops.zeMemGetAllocProperties) {
         // g_ze_ops.zeMemPutIpcHandle can be NULL because it was introduced
         // starting from Level Zero 1.6
-        LOG_ERR("Required Level Zero symbols not found.");
+        LOG_FATAL("Required Level Zero symbols not found.");
         Init_ze_global_state_failed = true;
+        utils_close_library(lib_handle);
+        return;
     }
+    ze_lib_handle = lib_handle;
 }
 
-umf_result_t ze_memory_provider_initialize(void *params, void **provider) {
-    if (provider == NULL || params == NULL) {
+umf_result_t umfLevelZeroMemoryProviderParamsCreate(
+    umf_level_zero_memory_provider_params_handle_t *hParams) {
+    libumfInit();
+    if (!hParams) {
+        LOG_ERR("Level Zero memory provider params handle is NULL");
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    level_zero_memory_provider_params_t *ze_params =
-        (level_zero_memory_provider_params_t *)params;
+    umf_level_zero_memory_provider_params_t *params =
+        umf_ba_global_alloc(sizeof(umf_level_zero_memory_provider_params_t));
+    if (!params) {
+        LOG_ERR("Cannot allocate memory for Level Zero memory provider params");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
 
-    util_init_once(&ze_is_initialized, init_ze_global_state);
-    if (Init_ze_global_state_failed) {
-        LOG_ERR("Loading Level Zero symbols failed");
-        return UMF_RESULT_ERROR_UNKNOWN;
+    // Assign default values
+    params->level_zero_context_handle = NULL;
+    params->level_zero_device_handle = NULL;
+    params->memory_type = UMF_MEMORY_TYPE_UNKNOWN;
+    params->resident_device_handles = NULL;
+    params->resident_device_count = 0;
+    params->freePolicy = UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFAULT;
+    params->device_ordinal = 0;
+
+    *hParams = params;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfLevelZeroMemoryProviderParamsDestroy(
+    umf_level_zero_memory_provider_params_handle_t hParams) {
+    umf_ba_global_free(hParams);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfLevelZeroMemoryProviderParamsSetContext(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    ze_context_handle_t hContext) {
+    if (!hParams) {
+        LOG_ERR("Level Zero memory provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    ze_memory_provider_t *ze_provider =
-        umf_ba_global_alloc(sizeof(ze_memory_provider_t));
-    if (!ze_provider) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    if (!hContext) {
+        LOG_ERR("Level Zero context handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    ze_provider->context = ze_params->level_zero_context_handle;
-    ze_provider->device = ze_params->level_zero_device_handle;
-    ze_provider->memory_type = (ze_memory_type_t)ze_params->memory_type;
+    hParams->level_zero_context_handle = hContext;
 
-    *provider = ze_provider;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfLevelZeroMemoryProviderParamsSetDevice(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    ze_device_handle_t hDevice) {
+    if (!hParams) {
+        LOG_ERR("Level Zero memory provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->level_zero_device_handle = hDevice;
 
     return UMF_RESULT_SUCCESS;
 }
 
-void ze_memory_provider_finalize(void *provider) {
-    assert(provider);
+umf_result_t umfLevelZeroMemoryProviderParamsSetMemoryType(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    umf_usm_memory_type_t memoryType) {
+    if (!hParams) {
+        LOG_ERR("Level Zero memory provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
 
-    util_init_once(&ze_is_initialized, init_ze_global_state);
-    umf_ba_global_free(provider);
+    hParams->memory_type = memoryType;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    uint32_t deviceOrdinal) {
+    if (!hParams) {
+        LOG_ERR("Level Zero memory provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    hParams->device_ordinal = deviceOrdinal;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfLevelZeroMemoryProviderParamsSetResidentDevices(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    ze_device_handle_t *hDevices, uint32_t deviceCount) {
+    if (!hParams) {
+        LOG_ERR("Level Zero memory provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (deviceCount && !hDevices) {
+        LOG_ERR("Resident devices array is NULL, but deviceCount is not zero");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->resident_device_handles = hDevices;
+    hParams->resident_device_count = deviceCount;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfLevelZeroMemoryProviderParamsSetFreePolicy(
+    umf_level_zero_memory_provider_params_handle_t hParams,
+    umf_level_zero_memory_provider_free_policy_t policy) {
+    if (!hParams) {
+        LOG_ERR("Level Zero memory provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->freePolicy = policy;
+    return UMF_RESULT_SUCCESS;
+}
+
+static ze_driver_memory_free_policy_ext_flags_t
+umfFreePolicyToZePolicy(umf_level_zero_memory_provider_free_policy_t policy) {
+    switch (policy) {
+    case UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFAULT:
+        return 0;
+    case UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_BLOCKING_FREE:
+        return ZE_DRIVER_MEMORY_FREE_POLICY_EXT_FLAG_BLOCKING_FREE;
+    case UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFER_FREE:
+        return ZE_DRIVER_MEMORY_FREE_POLICY_EXT_FLAG_DEFER_FREE;
+    default:
+        return 0;
+    }
+}
+static bool use_relaxed_allocation(ze_memory_provider_t *ze_provider,
+                                   size_t size) {
+    assert(ze_provider);
+    assert(ze_provider->device);
+    assert(ze_provider->device_properties.maxMemAllocSize > 0);
 
-    // portable version of "ze_is_initialized = UTIL_ONCE_FLAG_INIT;"
-    static UTIL_ONCE_FLAG is_initialized = UTIL_ONCE_FLAG_INIT;
-    memcpy(&ze_is_initialized, &is_initialized, sizeof(ze_is_initialized));
+    return size > ze_provider->device_properties.maxMemAllocSize;
 }
 
+static ze_relaxed_allocation_limits_exp_desc_t relaxed_device_allocation_desc =
+    {.stype = ZE_STRUCTURE_TYPE_RELAXED_ALLOCATION_LIMITS_EXP_DESC,
+     .pNext = NULL,
+     .flags = ZE_RELAXED_ALLOCATION_LIMITS_EXP_FLAG_MAX_SIZE};
+
 static umf_result_t ze_memory_provider_alloc(void *provider, size_t size,
                                              size_t alignment,
                                              void **resultPtr) {
-    assert(provider);
-    assert(resultPtr);
-
     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,
@@ -151,11 +381,12 @@ static umf_result_t ze_memory_provider_alloc(void *provider, size_t size,
     }
     case UMF_MEMORY_TYPE_DEVICE: {
         ze_device_mem_alloc_desc_t dev_desc = {
-            .stype = ZE_STRUCTURE_TYPE_HOST_MEM_ALLOC_DESC,
-            .pNext = NULL,
+            .stype = ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC,
+            .pNext = use_relaxed_allocation(ze_provider, size)
+                         ? &relaxed_device_allocation_desc
+                         : NULL,
             .flags = 0,
-            .ordinal = 0 // TODO
-        };
+            .ordinal = ze_provider->device_ordinal};
         ze_result = g_ze_ops.zeMemAllocDevice(ze_provider->context, &dev_desc,
                                               size, alignment,
                                               ze_provider->device, resultPtr);
@@ -168,58 +399,222 @@ static umf_result_t ze_memory_provider_alloc(void *provider, size_t size,
             .flags = 0};
         ze_device_mem_alloc_desc_t dev_desc = {
             .stype = ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC,
-            .pNext = NULL,
+            .pNext = use_relaxed_allocation(ze_provider, size)
+                         ? &relaxed_device_allocation_desc
+                         : NULL,
             .flags = 0,
-            .ordinal = 0 // TODO
-        };
+            .ordinal = ze_provider->device_ordinal};
         ze_result = g_ze_ops.zeMemAllocShared(ze_provider->context, &dev_desc,
                                               &host_desc, size, alignment,
                                               ze_provider->device, resultPtr);
         break;
     }
     default:
-        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+        // this shouldn't happen as we check the memory_type settings during
+        // the initialization
+        LOG_ERR("unsupported USM memory type");
+        return UMF_RESULT_ERROR_UNKNOWN;
     }
 
-    // TODO add error reporting
-    return (ze_result == ZE_RESULT_SUCCESS)
-               ? UMF_RESULT_SUCCESS
-               : UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    if (ze_result != ZE_RESULT_SUCCESS) {
+        return ze2umf_result(ze_result);
+    }
+
+    for (uint32_t i = 0; i < ze_provider->resident_device_count; i++) {
+        ze_result = g_ze_ops.zeContextMakeMemoryResident(
+            ze_provider->context, ze_provider->resident_device_handles[i],
+            *resultPtr, size);
+        if (ze_result != ZE_RESULT_SUCCESS) {
+            return ze2umf_result(ze_result);
+        }
+    }
+
+    return ze2umf_result(ze_result);
 }
 
 static umf_result_t ze_memory_provider_free(void *provider, void *ptr,
                                             size_t bytes) {
     (void)bytes;
 
-    assert(provider);
+    if (ptr == NULL) {
+        return UMF_RESULT_SUCCESS;
+    }
+
+    ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)provider;
+
+    if (ze_provider->freePolicyFlags == 0) {
+        return ze2umf_result(g_ze_ops.zeMemFree(ze_provider->context, ptr));
+    }
+
+    ze_memory_free_ext_desc_t desc = {
+        .stype = ZE_STRUCTURE_TYPE_MEMORY_FREE_EXT_DESC,
+        .pNext = NULL,
+        .freePolicy = ze_provider->freePolicyFlags};
+
+    return ze2umf_result(
+        g_ze_ops.zeMemFreeExt(ze_provider->context, &desc, ptr));
+}
+
+static umf_result_t query_min_page_size(ze_memory_provider_t *ze_provider,
+                                        size_t *min_page_size) {
+    assert(min_page_size);
+
+    LOG_DEBUG("Querying minimum page size");
+
+    void *ptr;
+    umf_result_t result = ze_memory_provider_alloc(ze_provider, 1, 0, &ptr);
+    if (result != UMF_RESULT_SUCCESS) {
+        return result;
+    }
+
+    ze_memory_allocation_properties_t properties = {
+        .stype = ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES};
+    ze_result_t ze_result = g_ze_ops.zeMemGetAllocProperties(
+        ze_provider->context, ptr, &properties, NULL);
+
+    *min_page_size = properties.pageSize;
+
+    ze_memory_provider_free(ze_provider, ptr, 1);
+
+    return ze2umf_result(ze_result);
+}
+
+static umf_result_t ze_memory_provider_finalize(void *provider) {
     ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)provider;
-    ze_result_t ze_result = g_ze_ops.zeMemFree(ze_provider->context, ptr);
+    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(const void *params,
+                                                  void **provider) {
+    if (params == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    const umf_level_zero_memory_provider_params_t *ze_params = params;
+
+    if (!ze_params->level_zero_context_handle) {
+        LOG_ERR("Level Zero context handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if ((ze_params->memory_type == UMF_MEMORY_TYPE_HOST) ==
+        (ze_params->level_zero_device_handle != NULL)) {
+        LOG_ERR("Level Zero device handle should be set only for device and "
+                "shared memory types");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if ((bool)ze_params->resident_device_count &&
+        (ze_params->resident_device_handles == NULL)) {
+        LOG_ERR("Resident devices handles array is NULL, but device_count is "
+                "not zero");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    utils_init_once(&ze_is_initialized, init_ze_global_state);
+    if (Init_ze_global_state_failed) {
+        LOG_FATAL("Loading Level Zero symbols failed");
+        return UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
+    }
+
+    ze_memory_provider_t *ze_provider =
+        umf_ba_global_alloc(sizeof(ze_memory_provider_t));
+    if (!ze_provider) {
+        LOG_ERR("Cannot allocate memory for Level Zero Memory Provider");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    ze_provider->context = ze_params->level_zero_context_handle;
+    ze_provider->device = ze_params->level_zero_device_handle;
+    ze_provider->memory_type = umf2ze_memory_type(ze_params->memory_type);
+    ze_provider->freePolicyFlags =
+        umfFreePolicyToZePolicy(ze_params->freePolicy);
+    ze_provider->min_page_size = 0;
+    ze_provider->device_ordinal = ze_params->device_ordinal;
+
+    memset(&ze_provider->device_properties, 0,
+           sizeof(ze_provider->device_properties));
+    ze_provider->device_properties.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;
+
+    if (ze_provider->device) {
+        umf_result_t ret = ze2umf_result(g_ze_ops.zeDeviceGetProperties(
+            ze_provider->device, &ze_provider->device_properties));
+
+        if (ret != UMF_RESULT_SUCCESS) {
+            LOG_ERR("Cannot get device properties");
+            umf_ba_global_free(ze_provider);
+            return ret;
+        }
+    }
+
+    if (ze_params->resident_device_count) {
+        ze_provider->resident_device_handles = umf_ba_global_alloc(
+            sizeof(ze_device_handle_t) * ze_params->resident_device_count);
+        if (!ze_provider->resident_device_handles) {
+            LOG_ERR("Cannot allocate memory for resident devices");
+            umf_ba_global_free(ze_provider);
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        }
+
+        ze_provider->resident_device_count = ze_params->resident_device_count;
+
+        for (uint32_t i = 0; i < ze_provider->resident_device_count; i++) {
+            ze_provider->resident_device_handles[i] =
+                ze_params->resident_device_handles[i];
+        }
+    } else {
+        ze_provider->resident_device_handles = NULL;
+        ze_provider->resident_device_count = 0;
+    }
+
+    umf_result_t result =
+        query_min_page_size(ze_provider, &ze_provider->min_page_size);
+    if (result != UMF_RESULT_SUCCESS) {
+        ze_memory_provider_finalize(ze_provider);
+        return result;
+    }
 
-    // TODO add error reporting
-    return (ze_result == ZE_RESULT_SUCCESS)
-               ? UMF_RESULT_SUCCESS
-               : UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    *provider = ze_provider;
+
+    return UMF_RESULT_SUCCESS;
 }
 
-void ze_memory_provider_get_last_native_error(void *provider,
-                                              const char **ppMessage,
-                                              int32_t *pError) {
+static void ze_memory_provider_get_last_native_error(void *provider,
+                                                     const char **ppMessage,
+                                                     int32_t *pError) {
     (void)provider;
-    (void)ppMessage;
 
-    // TODO
-    assert(pError);
-    *pError = 0;
+    if (ppMessage == NULL || pError == NULL) {
+        ASSERT(0);
+        return;
+    }
+
+    *pError = TLS_last_native_error;
 }
 
 static umf_result_t ze_memory_provider_get_min_page_size(void *provider,
-                                                         void *ptr,
+                                                         const void *ptr,
                                                          size_t *pageSize) {
-    (void)provider;
-    (void)ptr;
+    ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)provider;
+
+    if (!ptr) {
+        *pageSize = ze_provider->min_page_size;
+        return UMF_RESULT_SUCCESS;
+    }
+
+    ze_memory_allocation_properties_t properties = {
+        .stype = ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES};
+    ze_result_t ze_result = g_ze_ops.zeMemGetAllocProperties(
+        ze_provider->context, ptr, &properties, NULL);
+    if (ze_result != ZE_RESULT_SUCCESS) {
+        return ze2umf_result(ze_result);
+    }
+
+    *pageSize = properties.pageSize;
 
-    // TODO
-    *pageSize = 1024 * 64;
     return UMF_RESULT_SUCCESS;
 }
 
@@ -246,15 +641,11 @@ static umf_result_t ze_memory_provider_purge_force(void *provider, void *ptr,
 static umf_result_t
 ze_memory_provider_get_recommended_page_size(void *provider, size_t size,
                                              size_t *pageSize) {
-    (void)provider;
     (void)size;
-
-    // TODO
-    *pageSize = 1024 * 64;
-    return UMF_RESULT_SUCCESS;
+    return ze_memory_provider_get_min_page_size(provider, NULL, pageSize);
 }
 
-const char *ze_memory_provider_get_name(void *provider) {
+static const char *ze_memory_provider_get_name(void *provider) {
     (void)provider;
     return "LEVEL_ZERO";
 }
@@ -293,7 +684,7 @@ typedef struct ze_ipc_data_t {
 static umf_result_t ze_memory_provider_get_ipc_handle_size(void *provider,
                                                            size_t *size) {
     (void)provider;
-    ASSERT(size != NULL);
+
     *size = sizeof(ze_ipc_data_t);
     return UMF_RESULT_SUCCESS;
 }
@@ -302,9 +693,8 @@ static umf_result_t ze_memory_provider_get_ipc_handle(void *provider,
                                                       const void *ptr,
                                                       size_t size,
                                                       void *providerIpcData) {
-    ASSERT(ptr != NULL);
-    ASSERT(providerIpcData != NULL);
     (void)size;
+
     ze_result_t ze_result;
     ze_ipc_data_t *ze_ipc_data = (ze_ipc_data_t *)providerIpcData;
     struct ze_memory_provider_t *ze_provider =
@@ -314,7 +704,7 @@ static umf_result_t ze_memory_provider_get_ipc_handle(void *provider,
                                            &ze_ipc_data->ze_handle);
     if (ze_result != ZE_RESULT_SUCCESS) {
         LOG_ERR("zeMemGetIpcHandle() failed.");
-        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+        return ze2umf_result(ze_result);
     }
 
     ze_ipc_data->pid = utils_getpid();
@@ -324,8 +714,6 @@ static umf_result_t ze_memory_provider_get_ipc_handle(void *provider,
 
 static umf_result_t ze_memory_provider_put_ipc_handle(void *provider,
                                                       void *providerIpcData) {
-    ASSERT(provider != NULL);
-    ASSERT(providerIpcData != NULL);
     ze_result_t ze_result;
     struct ze_memory_provider_t *ze_provider =
         (struct ze_memory_provider_t *)provider;
@@ -342,7 +730,7 @@ static umf_result_t ze_memory_provider_put_ipc_handle(void *provider,
                                            ze_ipc_data->ze_handle);
     if (ze_result != ZE_RESULT_SUCCESS) {
         LOG_ERR("zeMemPutIpcHandle() failed.");
-        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+        return ze2umf_result(ze_result);
     }
     return UMF_RESULT_SUCCESS;
 }
@@ -350,9 +738,6 @@ static umf_result_t ze_memory_provider_put_ipc_handle(void *provider,
 static umf_result_t ze_memory_provider_open_ipc_handle(void *provider,
                                                        void *providerIpcData,
                                                        void **ptr) {
-    ASSERT(provider != NULL);
-    ASSERT(providerIpcData != NULL);
-    ASSERT(ptr != NULL);
     ze_result_t ze_result;
     ze_ipc_data_t *ze_ipc_data = (ze_ipc_data_t *)providerIpcData;
     struct ze_memory_provider_t *ze_provider =
@@ -379,7 +764,7 @@ static umf_result_t ze_memory_provider_open_ipc_handle(void *provider,
     }
     if (ze_result != ZE_RESULT_SUCCESS) {
         LOG_ERR("zeMemOpenIpcHandle() failed.");
-        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+        return ze2umf_result(ze_result);
     }
 
     return UMF_RESULT_SUCCESS;
@@ -387,9 +772,8 @@ static umf_result_t ze_memory_provider_open_ipc_handle(void *provider,
 
 static umf_result_t
 ze_memory_provider_close_ipc_handle(void *provider, void *ptr, size_t size) {
-    ASSERT(provider != NULL);
-    ASSERT(ptr != NULL);
     (void)size;
+
     ze_result_t ze_result;
     struct ze_memory_provider_t *ze_provider =
         (struct ze_memory_provider_t *)provider;
@@ -397,14 +781,14 @@ ze_memory_provider_close_ipc_handle(void *provider, void *ptr, size_t size) {
     ze_result = g_ze_ops.zeMemCloseIpcHandle(ze_provider->context, ptr);
     if (ze_result != ZE_RESULT_SUCCESS) {
         LOG_ERR("zeMemCloseIpcHandle() failed.");
-        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+        return ze2umf_result(ze_result);
     }
 
     return UMF_RESULT_SUCCESS;
 }
 
-static struct umf_memory_provider_ops_t UMF_LEVEL_ZERO_MEMORY_PROVIDER_OPS = {
-    .version = UMF_VERSION_CURRENT,
+static umf_memory_provider_ops_t UMF_LEVEL_ZERO_MEMORY_PROVIDER_OPS = {
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = ze_memory_provider_initialize,
     .finalize = ze_memory_provider_finalize,
     .alloc = ze_memory_provider_alloc,
@@ -413,17 +797,101 @@ static struct 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;
 }
+
+#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_level_zero_internal.h b/src/provider/provider_level_zero_internal.h
new file mode 100644
index 000000000..7da299ffd
--- /dev/null
+++ b/src/provider/provider_level_zero_internal.h
@@ -0,0 +1,10 @@
+/*
+ *
+ * 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
+ *
+ */
+
+void fini_ze_global_state(void);
diff --git a/src/provider/provider_os_memory.c b/src/provider/provider_os_memory.c
index 00251e53b..7bcc0e4d2 100644
--- a/src/provider/provider_os_memory.c
+++ b/src/provider/provider_os_memory.c
@@ -1,33 +1,140 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 */
 
 #include <assert.h>
+#include <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)
+
+const umf_memory_provider_ops_t *umfOsMemoryProviderOps(void) { return NULL; }
+
+umf_result_t umfOsMemoryProviderParamsCreate(
+    umf_os_memory_provider_params_handle_t *hParams) {
+    (void)hParams;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfOsMemoryProviderParamsDestroy(
+    umf_os_memory_provider_params_handle_t hParams) {
+    (void)hParams;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfOsMemoryProviderParamsSetProtection(
+    umf_os_memory_provider_params_handle_t hParams, unsigned protection) {
+    (void)hParams;
+    (void)protection;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfOsMemoryProviderParamsSetVisibility(
+    umf_os_memory_provider_params_handle_t hParams,
+    umf_memory_visibility_t visibility) {
+    (void)hParams;
+    (void)visibility;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfOsMemoryProviderParamsSetShmName(
+    umf_os_memory_provider_params_handle_t hParams, const char *shm_name) {
+    (void)hParams;
+    (void)shm_name;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfOsMemoryProviderParamsSetNumaList(
+    umf_os_memory_provider_params_handle_t hParams, unsigned *numa_list,
+    unsigned numa_list_len) {
+    (void)hParams;
+    (void)numa_list;
+    (void)numa_list_len;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfOsMemoryProviderParamsSetNumaMode(
+    umf_os_memory_provider_params_handle_t hParams, umf_numa_mode_t numa_mode) {
+    (void)hParams;
+    (void)numa_mode;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfOsMemoryProviderParamsSetPartSize(
+    umf_os_memory_provider_params_handle_t hParams, size_t part_size) {
+    (void)hParams;
+    (void)part_size;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+umf_result_t umfOsMemoryProviderParamsSetPartitions(
+    umf_os_memory_provider_params_handle_t hParams,
+    umf_numa_split_partition_t *partitions, unsigned partitions_len) {
+    (void)hParams;
+    (void)partitions;
+    (void)partitions_len;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+#else // !defined(UMF_NO_HWLOC)
 
 #include "base_alloc_global.h"
 #include "critnib.h"
+#include "libumf.h"
 #include "provider_os_memory_internal.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
 #include "utils_log.h"
 
-#include <umf.h>
-#include <umf/memory_provider_ops.h>
-#include <umf/providers/provider_os_memory.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
 
+typedef struct umf_os_memory_provider_params_t {
+    // Combination of 'umf_mem_protection_flags_t' flags
+    unsigned protection;
+    /// memory visibility mode
+    umf_memory_visibility_t visibility;
+    /// (optional) a name of a shared memory file (valid only in case of the shared memory visibility)
+    char *shm_name;
+
+    // NUMA config
+    /// ordered list of numa nodes
+    unsigned *numa_list;
+    /// length of numa_list
+    unsigned numa_list_len;
+
+    /// Describes how node list is interpreted
+    umf_numa_mode_t numa_mode;
+    /// part size for interleave mode - 0 means default (system specific)
+    /// It might be rounded up because of HW constraints
+    size_t part_size;
+
+    /// ordered list of the partitions for the split mode
+    umf_numa_split_partition_t *partitions;
+    /// len of the partitions array
+    unsigned partitions_len;
+} umf_os_memory_provider_params_t;
+
 typedef struct os_last_native_error_t {
     int32_t native_error;
     int errno_value;
@@ -66,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;
@@ -129,36 +264,12 @@ 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;
 }
 
-umf_result_t os_translate_flags(unsigned in_flags, unsigned max,
-                                umf_result_t (*translate_flag)(unsigned,
-                                                               unsigned *),
-                                unsigned *out_flags) {
-    unsigned out_f = 0;
-    for (unsigned n = 1; n < max; n <<= 1) {
-        if (in_flags & n) {
-            unsigned flag;
-            umf_result_t result = translate_flag(n, &flag);
-            if (result != UMF_RESULT_SUCCESS) {
-                return result;
-            }
-            out_f |= flag;
-            in_flags &= ~n; // clear this bit
-        }
-    }
-
-    if (in_flags != 0) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    *out_flags = out_f;
-    return UMF_RESULT_SUCCESS;
-}
-
 static umf_result_t validate_numa_mode(umf_numa_mode_t mode,
                                        int nodemaskEmpty) {
     switch (mode) {
@@ -211,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;
     }
@@ -261,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;
 
@@ -284,18 +396,18 @@ create_fd_for_mmap(umf_os_memory_provider_params_t *in_params,
                                        provider->shm_name)) {
             LOG_ERR("invalid name of a shared memory file: %s",
                     in_params->shm_name);
-            return -1;
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
         }
 
         /* create a new shared memory file */
         provider->fd =
-            os_shm_create(in_params->shm_name, provider->max_size_fd);
+            utils_shm_create(in_params->shm_name, provider->max_size_fd);
         if (provider->fd == -1) {
             LOG_ERR("creating a shared memory file /dev/shm/%s of size %zu for "
                     "memory mapping failed",
                     in_params->shm_name, provider->max_size_fd);
             provider->shm_name[0] = '\0'; // zero shm_name
-            return -1;
+            return UMF_RESULT_ERROR_UNKNOWN;
         }
 
         LOG_DEBUG("created the shared memory file /dev/shm/%s of size %zu",
@@ -304,14 +416,14 @@ create_fd_for_mmap(umf_os_memory_provider_params_t *in_params,
         return UMF_RESULT_SUCCESS;
     }
 
-    provider->fd = os_create_anonymous_fd();
+    provider->fd = utils_create_anonymous_fd();
     if (provider->fd <= 0) {
         LOG_ERR(
             "creating an anonymous file descriptor for memory mapping failed");
         return UMF_RESULT_ERROR_UNKNOWN;
     }
 
-    int ret = os_set_file_size(provider->fd, provider->max_size_fd);
+    int ret = utils_set_file_size(provider->fd, provider->max_size_fd);
     if (ret) {
         LOG_ERR("setting size %zu of an anonymous file failed",
                 provider->max_size_fd);
@@ -332,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;
@@ -359,6 +471,23 @@ validatePartitions(umf_os_memory_provider_params_t *params) {
     return UMF_RESULT_SUCCESS;
 }
 
+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,
+                 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) {
+        LOG_ERR("partition size (%zu) is too big, cannot align with a page "
+                "size (%zu)",
+                params->part_size, page_size);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    return UMF_RESULT_SUCCESS;
+}
+
 static void free_bitmaps(os_memory_provider_t *provider) {
     for (unsigned i = 0; i < provider->nodeset_len; i++) {
         hwloc_bitmap_free(provider->nodeset[i]);
@@ -368,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;
     }
@@ -409,24 +538,28 @@ 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 = os_translate_mem_protection_flags(in_params->protection,
-                                               &provider->protection);
+    result = utils_translate_mem_protection_flags(in_params->protection,
+                                                  &provider->protection);
     if (result != UMF_RESULT_SUCCESS) {
         LOG_ERR("incorrect memory protection flags: %u", in_params->protection);
         return result;
     }
 
-    result = os_translate_mem_visibility_flag(in_params->visibility,
-                                              &provider->visibility);
+    result = utils_translate_mem_visibility_flag(in_params->visibility,
+                                                 &provider->visibility);
     if (result != UMF_RESULT_SUCCESS) {
         LOG_ERR("incorrect memory visibility flag: %u", in_params->visibility);
         return result;
     }
 
+    // IPC API requires in_params->visibility == UMF_MEM_MAP_SHARED
+    provider->IPC_enabled = (in_params->visibility == UMF_MEM_MAP_SHARED);
+
     // NUMA config
     int emptyNodeset = in_params->numa_list_len == 0;
     result = validate_numa_mode(in_params->numa_mode, emptyNodeset);
@@ -442,6 +575,14 @@ static umf_result_t translate_params(umf_os_memory_provider_params_t *in_params,
         return result;
     }
 
+    if (in_params->numa_mode == UMF_NUMA_MODE_INTERLEAVE) {
+        result = validatePartSize(provider, in_params);
+        if (result != UMF_RESULT_SUCCESS) {
+            LOG_ERR("incorrect partition size: %zu", in_params->part_size);
+            return result;
+        }
+    }
+
     int is_dedicated_node_bind = dedicated_node_bind(in_params);
     provider->numa_policy =
         translate_numa_mode(in_params->numa_mode, is_dedicated_node_bind);
@@ -466,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 (provider == NULL || params == NULL) {
+    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) {
@@ -508,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;
@@ -526,7 +666,7 @@ static umf_result_t os_initialize(void *params, void **provider) {
     }
 
     if (os_provider->fd > 0) {
-        if (util_mutex_init(&os_provider->lock_fd) == NULL) {
+        if (utils_mutex_init(&os_provider->lock_fd) == NULL) {
             LOG_ERR("initializing the file size lock failed");
             ret = UMF_RESULT_ERROR_UNKNOWN;
             goto err_destroy_bitmaps;
@@ -562,16 +702,11 @@ static umf_result_t os_initialize(void *params, void **provider) {
     return ret;
 }
 
-static void os_finalize(void *provider) {
-    if (provider == NULL) {
-        assert(0);
-        return;
-    }
-
+static umf_result_t os_finalize(void *provider) {
     os_memory_provider_t *os_provider = provider;
 
     if (os_provider->fd > 0) {
-        util_mutex_destroy_not_free(&os_provider->lock_fd);
+        utils_mutex_destroy_not_free(&os_provider->lock_fd);
     }
 
     critnib_delete(os_provider->fd_offset_map);
@@ -587,11 +722,9 @@ static void os_finalize(void *provider) {
     }
     hwloc_topology_destroy(os_provider->topo);
     umf_ba_global_free(os_provider);
+    return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t os_get_min_page_size(void *provider, void *ptr,
-                                         size_t *page_size);
-
 // TODO: this function should be re-enabled when CTL is implemented
 #if 0
 static void print_numa_nodes(os_memory_provider_t *os_provider, void *addr,
@@ -634,11 +767,11 @@ static inline void assert_is_page_aligned(uintptr_t ptr, size_t page_size) {
     (void)page_size; // unused in Release build
 }
 
-static int os_mmap_aligned(void *hint_addr, size_t length, size_t alignment,
-                           size_t page_size, int prot, int flag, int fd,
-                           size_t max_fd_size, os_mutex_t *lock_fd,
-                           void **out_addr, size_t *fd_size,
-                           size_t *fd_offset) {
+static int utils_mmap_aligned(void *hint_addr, size_t length, size_t alignment,
+                              size_t page_size, int prot, int flag, int fd,
+                              size_t max_fd_size, utils_mutex_t *lock_fd,
+                              void **out_addr, size_t *fd_size,
+                              size_t *fd_offset) {
     assert(out_addr);
 
     size_t extended_length = length;
@@ -654,23 +787,24 @@ static int os_mmap_aligned(void *hint_addr, size_t length, size_t alignment,
     *fd_offset = 0;
 
     if (fd > 0) {
-        if (util_mutex_lock(lock_fd)) {
+        if (utils_mutex_lock(lock_fd)) {
             LOG_ERR("locking file size failed");
             return -1;
         }
 
         if (*fd_size + extended_length > max_fd_size) {
-            util_mutex_unlock(lock_fd);
+            utils_mutex_unlock(lock_fd);
             LOG_ERR("cannot grow a file size beyond %zu", max_fd_size);
             return -1;
         }
 
         *fd_offset = *fd_size;
         *fd_size += extended_length;
-        util_mutex_unlock(lock_fd);
+        utils_mutex_unlock(lock_fd);
     }
 
-    void *ptr = os_mmap(hint_addr, extended_length, prot, flag, fd, *fd_offset);
+    void *ptr =
+        utils_mmap(hint_addr, extended_length, prot, flag, fd, *fd_offset);
     if (ptr == NULL) {
         LOG_PDEBUG("memory mapping failed");
         return -1;
@@ -689,7 +823,7 @@ static int os_mmap_aligned(void *hint_addr, size_t length, size_t alignment,
 
         size_t head_len = aligned_addr - addr;
         if (head_len > 0) {
-            os_munmap(ptr, head_len);
+            utils_munmap(ptr, head_len);
         }
 
         // tail address has to page-aligned
@@ -703,7 +837,7 @@ static int os_mmap_aligned(void *hint_addr, size_t length, size_t alignment,
 
         size_t tail_len = (addr + extended_length) - tail;
         if (tail_len > 0) {
-            os_munmap((void *)tail, tail_len);
+            utils_munmap((void *)tail, tail_len);
         }
 
         *out_addr = (void *)aligned_addr;
@@ -827,19 +961,19 @@ static membind_t membindFirst(os_memory_provider_t *provider, void *addr,
     membind_t membind;
     memset(&membind, 0, sizeof(membind));
 
-    membind.alloc_size = ALIGN_UP(size, page_size);
+    membind.alloc_size = size;
     membind.page_size = page_size;
     membind.addr = addr;
     membind.pages = membind.alloc_size / membind.page_size;
     if (provider->nodeset_len == 1) {
-        membind.bind_size = ALIGN_UP(size, membind.page_size);
+        membind.bind_size = size;
         membind.bitmap = provider->nodeset[0];
         return membind;
     }
 
     if (provider->mode == UMF_NUMA_MODE_INTERLEAVE) {
         assert(provider->part_size != 0);
-        size_t s = util_fetch_and_add64(&provider->alloc_sum, size);
+        size_t s = utils_fetch_and_add_u64(&provider->alloc_sum, size);
         membind.node = (s / provider->part_size) % provider->nodeset_len;
         membind.bitmap = provider->nodeset[membind.node];
         membind.bind_size = ALIGN_UP(provider->part_size, membind.page_size);
@@ -893,10 +1027,6 @@ static umf_result_t os_alloc(void *provider, size_t size, size_t alignment,
                              void **resultPtr) {
     int ret;
 
-    if (provider == NULL || resultPtr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
 
     size_t page_size;
@@ -917,7 +1047,7 @@ static umf_result_t os_alloc(void *provider, size_t size, size_t alignment,
 
     void *addr = NULL;
     errno = 0;
-    ret = os_mmap_aligned(
+    ret = utils_mmap_aligned(
         NULL, size, alignment, page_size, os_provider->protection,
         os_provider->visibility, os_provider->fd, os_provider->max_size_fd,
         &os_provider->lock_fd, &addr, &os_provider->size_fd, &fd_offset);
@@ -938,7 +1068,15 @@ static umf_result_t os_alloc(void *provider, size_t size, size_t alignment,
 
     // Bind memory to NUMA nodes if numa_policy is other than DEFAULT
     if (os_provider->numa_policy != HWLOC_MEMBIND_DEFAULT) {
-        membind_t membind = membindFirst(os_provider, addr, size, page_size);
+        size_t first_size = ALIGN_UP_SAFE(size, page_size);
+        if (first_size == 0) {
+            LOG_ERR("size is too big, page align failed");
+            (void)utils_munmap(addr, size);
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+
+        membind_t membind =
+            membindFirst(os_provider, addr, first_size, page_size);
         if (membind.bitmap == NULL) {
             goto err_unmap;
         }
@@ -981,18 +1119,15 @@ 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:
-    (void)os_munmap(addr, size);
+    (void)utils_munmap(addr, size);
     return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
 }
 
 static umf_result_t os_free(void *provider, void *ptr, size_t size) {
-    if (provider == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     if (ptr == NULL) {
         return UMF_RESULT_SUCCESS;
     }
@@ -1000,11 +1135,11 @@ 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;
-    int ret = os_munmap(ptr, size);
+    int ret = utils_munmap(ptr, size);
     if (ret) {
         os_store_last_native_error(UMF_OS_RESULT_ERROR_FREE_FAILED, errno);
         LOG_PERR("memory deallocation failed");
@@ -1012,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;
 }
 
@@ -1044,26 +1181,23 @@ static void os_get_last_native_error(void *provider, const char **ppMessage,
     memcpy(TLS_last_native_error.msg_buff + pos, msg, len + 1);
     pos += len;
 
-    os_strerror(TLS_last_native_error.errno_value,
-                TLS_last_native_error.msg_buff + pos, TLS_MSG_BUF_LEN - pos);
+    utils_strerror(TLS_last_native_error.errno_value,
+                   TLS_last_native_error.msg_buff + pos, TLS_MSG_BUF_LEN - pos);
 
     *ppMessage = TLS_last_native_error.msg_buff;
 }
 
 static umf_result_t os_get_recommended_page_size(void *provider, size_t size,
                                                  size_t *page_size) {
-    (void)size; // unused
-
-    if (provider == NULL || page_size == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    (void)provider; // unused
+    (void)size;     // unused
 
-    *page_size = os_get_page_size();
+    *page_size = utils_get_page_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
 
@@ -1071,12 +1205,10 @@ static umf_result_t os_get_min_page_size(void *provider, void *ptr,
 }
 
 static umf_result_t os_purge_lazy(void *provider, void *ptr, size_t size) {
-    if (provider == NULL || ptr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    (void)provider; // unused
 
     errno = 0;
-    if (os_purge(ptr, size, UMF_PURGE_LAZY)) {
+    if (utils_purge(ptr, size, UMF_PURGE_LAZY)) {
         os_store_last_native_error(UMF_OS_RESULT_ERROR_PURGE_LAZY_FAILED,
                                    errno);
         LOG_PERR("lazy purging failed");
@@ -1087,12 +1219,10 @@ static umf_result_t os_purge_lazy(void *provider, void *ptr, size_t size) {
 }
 
 static umf_result_t os_purge_force(void *provider, void *ptr, size_t size) {
-    if (provider == NULL || ptr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    (void)provider; // unused
 
     errno = 0;
-    if (os_purge(ptr, size, UMF_PURGE_FORCE)) {
+    if (utils_purge(ptr, size, UMF_PURGE_FORCE)) {
         os_store_last_native_error(UMF_OS_RESULT_ERROR_PURGE_FORCE_FAILED,
                                    errno);
         LOG_PERR("force purging failed");
@@ -1113,11 +1243,11 @@ static umf_result_t os_allocation_split(void *provider, void *ptr,
     (void)totalSize;
 
     os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
-    if (os_provider->fd <= 0) {
+    if (os_provider->fd < 0) {
         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)",
@@ -1146,12 +1276,12 @@ static umf_result_t os_allocation_merge(void *provider, void *lowPtr,
     (void)totalSize;
 
     os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
-    if (os_provider->fd <= 0) {
+    if (os_provider->fd < 0) {
         return UMF_RESULT_SUCCESS;
     }
 
     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)",
@@ -1167,43 +1297,38 @@ typedef struct os_ipc_data_t {
     int fd;
     size_t fd_offset;
     size_t size;
-    char shm_name[NAME_MAX]; // optional - can be used or not (see below)
+    unsigned protection; // combination of OS-specific protection flags
+    unsigned visibility; // memory visibility mode
+    // shm_name is a Flexible Array Member because it is optional and its size
+    // varies on the Shared Memory object name
+    size_t shm_name_len;
+    char shm_name[];
 } os_ipc_data_t;
 
 static umf_result_t os_get_ipc_handle_size(void *provider, size_t *size) {
-    if (provider == NULL || size == NULL) {
+    os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
+    if (!os_provider->IPC_enabled) {
+        LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
-
-    if (os_provider->shm_name[0]) {
-        // os_ipc_data_t->shm_name will be used
-        *size = sizeof(os_ipc_data_t);
-    } else {
-        // os_ipc_data_t->shm_name will NOT be used
-        *size = sizeof(os_ipc_data_t) - NAME_MAX;
-    }
+    // NOTE: +1 for '\0' at the end of the string
+    *size = sizeof(os_ipc_data_t) + strlen(os_provider->shm_name) + 1;
 
     return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t os_get_ipc_handle(void *provider, const void *ptr,
                                       size_t size, void *providerIpcData) {
-    if (provider == NULL || ptr == NULL || providerIpcData == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
-    if (os_provider->fd <= 0) {
+    if (!os_provider->IPC_enabled) {
+        LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    void *value = critnib_get(os_provider->fd_offset_map, (uintptr_t)ptr);
+    void *value = critnib_get(os_provider->fd_offset_map, (uintptr_t)ptr, NULL);
     if (value == NULL) {
-        LOG_ERR("os_get_ipc_handle(): getting a value from the IPC cache "
-                "failed (addr=%p)",
-                ptr);
+        LOG_ERR("getting a value from the IPC cache failed (addr=%p)", ptr);
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
@@ -1211,9 +1336,13 @@ static umf_result_t os_get_ipc_handle(void *provider, const void *ptr,
     os_ipc_data->pid = utils_getpid();
     os_ipc_data->fd_offset = (size_t)value - 1;
     os_ipc_data->size = size;
-    if (os_provider->shm_name[0]) {
-        strncpy(os_ipc_data->shm_name, os_provider->shm_name, NAME_MAX - 1);
-        os_ipc_data->shm_name[NAME_MAX - 1] = '\0';
+    os_ipc_data->protection = os_provider->protection;
+    os_ipc_data->visibility = os_provider->visibility;
+    os_ipc_data->shm_name_len = strlen(os_provider->shm_name);
+    if (os_ipc_data->shm_name_len > 0) {
+        // NOTE: +1 for '\0' at the end of the string
+        strncpy(os_ipc_data->shm_name, os_provider->shm_name,
+                os_ipc_data->shm_name_len + 1);
     } else {
         os_ipc_data->fd = os_provider->fd;
     }
@@ -1222,19 +1351,24 @@ static umf_result_t os_get_ipc_handle(void *provider, const void *ptr,
 }
 
 static umf_result_t os_put_ipc_handle(void *provider, void *providerIpcData) {
-    if (provider == NULL || providerIpcData == NULL) {
+    os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
+    if (!os_provider->IPC_enabled) {
+        LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
     os_ipc_data_t *os_ipc_data = (os_ipc_data_t *)providerIpcData;
 
     if (os_ipc_data->pid != utils_getpid()) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    if (os_provider->shm_name[0]) {
-        if (strncmp(os_ipc_data->shm_name, os_provider->shm_name, NAME_MAX)) {
+    size_t shm_name_len = strlen(os_provider->shm_name);
+    if (shm_name_len > 0) {
+        if (os_ipc_data->shm_name_len != shm_name_len) {
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        } else if (strncmp(os_ipc_data->shm_name, os_provider->shm_name,
+                           shm_name_len)) {
             return UMF_RESULT_ERROR_INVALID_ARGUMENT;
         }
     } else {
@@ -1248,23 +1382,24 @@ static umf_result_t os_put_ipc_handle(void *provider, void *providerIpcData) {
 
 static umf_result_t os_open_ipc_handle(void *provider, void *providerIpcData,
                                        void **ptr) {
-    if (provider == NULL || providerIpcData == NULL || ptr == NULL) {
+    os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
+    if (!os_provider->IPC_enabled) {
+        LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
     os_ipc_data_t *os_ipc_data = (os_ipc_data_t *)providerIpcData;
     umf_result_t ret = UMF_RESULT_SUCCESS;
     int fd;
 
-    if (os_provider->shm_name[0]) {
-        fd = os_shm_open(os_provider->shm_name);
+    if (os_ipc_data->shm_name_len) {
+        fd = utils_shm_open(os_ipc_data->shm_name);
         if (fd <= 0) {
             LOG_PERR("opening a shared memory file (%s) failed",
-                     os_provider->shm_name);
+                     os_ipc_data->shm_name);
             return UMF_RESULT_ERROR_UNKNOWN;
         }
-        (void)os_shm_unlink(os_provider->shm_name);
+        (void)utils_shm_unlink(os_ipc_data->shm_name);
     } else {
         umf_result_t umf_result =
             utils_duplicate_fd(os_ipc_data->pid, os_ipc_data->fd, &fd);
@@ -1274,8 +1409,8 @@ static umf_result_t os_open_ipc_handle(void *provider, void *providerIpcData,
         }
     }
 
-    *ptr = os_mmap(NULL, os_ipc_data->size, os_provider->protection,
-                   os_provider->visibility, fd, os_ipc_data->fd_offset);
+    *ptr = utils_mmap(NULL, os_ipc_data->size, os_ipc_data->protection,
+                      os_ipc_data->visibility, fd, os_ipc_data->fd_offset);
     if (*ptr == NULL) {
         os_store_last_native_error(UMF_OS_RESULT_ERROR_ALLOC_FAILED, errno);
         LOG_PERR("memory mapping failed");
@@ -1289,12 +1424,14 @@ static umf_result_t os_open_ipc_handle(void *provider, void *providerIpcData,
 
 static umf_result_t os_close_ipc_handle(void *provider, void *ptr,
                                         size_t size) {
-    if (provider == NULL || ptr == NULL) {
+    os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
+    if (!os_provider->IPC_enabled) {
+        LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
     errno = 0;
-    int ret = os_munmap(ptr, size);
+    int ret = utils_munmap(ptr, size);
     // ignore error when size == 0
     if (ret && (size > 0)) {
         os_store_last_native_error(UMF_OS_RESULT_ERROR_FREE_FAILED, errno);
@@ -1306,8 +1443,16 @@ 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_VERSION_CURRENT,
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = os_initialize,
     .finalize = os_finalize,
     .alloc = os_alloc,
@@ -1316,16 +1461,200 @@ 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;
 }
+
+umf_result_t umfOsMemoryProviderParamsCreate(
+    umf_os_memory_provider_params_handle_t *hParams) {
+    libumfInit();
+    if (hParams == NULL) {
+        LOG_ERR("OS memory provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_os_memory_provider_params_handle_t params =
+        umf_ba_global_alloc(sizeof(*params));
+    if (params == NULL) {
+        LOG_ERR("allocating memory for OS memory provider params failed");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    params->protection = UMF_PROTECTION_READ | UMF_PROTECTION_WRITE;
+    params->visibility = UMF_MEM_MAP_PRIVATE;
+    params->shm_name = NULL;
+    params->numa_list = NULL;
+    params->numa_list_len = 0;
+    params->numa_mode = UMF_NUMA_MODE_DEFAULT;
+    params->part_size = 0;
+    params->partitions = NULL;
+    params->partitions_len = 0;
+
+    *hParams = params;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfOsMemoryProviderParamsDestroy(
+    umf_os_memory_provider_params_handle_t hParams) {
+    if (hParams != NULL) {
+        umf_ba_global_free(hParams->shm_name);
+        umf_ba_global_free(hParams->numa_list);
+        umf_ba_global_free(hParams->partitions);
+    }
+
+    umf_ba_global_free(hParams);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfOsMemoryProviderParamsSetProtection(
+    umf_os_memory_provider_params_handle_t hParams, unsigned protection) {
+    if (hParams == NULL) {
+        LOG_ERR("OS memory provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->protection = protection;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfOsMemoryProviderParamsSetVisibility(
+    umf_os_memory_provider_params_handle_t hParams,
+    umf_memory_visibility_t visibility) {
+    if (hParams == NULL) {
+        LOG_ERR("OS memory provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->visibility = visibility;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfOsMemoryProviderParamsSetShmName(
+    umf_os_memory_provider_params_handle_t hParams, const char *shm_name) {
+    if (hParams == NULL) {
+        LOG_ERR("OS memory provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    char *name = NULL;
+    if (shm_name) {
+        size_t len = strlen(shm_name) + 1;
+        name = umf_ba_global_alloc(len);
+        if (name == NULL) {
+            LOG_ERR("allocating memory for the shared memory name failed");
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        }
+
+        strncpy(name, shm_name, len);
+    }
+    umf_ba_global_free(hParams->shm_name);
+    hParams->shm_name = name;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfOsMemoryProviderParamsSetNumaList(
+    umf_os_memory_provider_params_handle_t hParams, unsigned *numa_list,
+    unsigned numa_list_len) {
+    if (hParams == NULL) {
+        LOG_ERR("OS memory provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (numa_list_len && !numa_list) {
+        LOG_ERR("numa_list_len is not 0, but numa_list is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    unsigned *new_list = NULL;
+    if (numa_list_len) {
+        new_list = umf_ba_global_alloc(numa_list_len * sizeof(*new_list));
+        if (new_list == NULL) {
+            LOG_ERR("allocating memory for the NUMA list failed");
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        }
+
+        memcpy(new_list, numa_list, numa_list_len * sizeof(*new_list));
+    }
+
+    umf_ba_global_free(hParams->numa_list);
+    hParams->numa_list = new_list;
+    hParams->numa_list_len = numa_list_len;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfOsMemoryProviderParamsSetNumaMode(
+    umf_os_memory_provider_params_handle_t hParams, umf_numa_mode_t numa_mode) {
+    if (hParams == NULL) {
+        LOG_ERR("OS memory provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->numa_mode = numa_mode;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfOsMemoryProviderParamsSetPartSize(
+    umf_os_memory_provider_params_handle_t hParams, size_t part_size) {
+    if (hParams == NULL) {
+        LOG_ERR("OS memory provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->part_size = part_size;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfOsMemoryProviderParamsSetPartitions(
+    umf_os_memory_provider_params_handle_t hParams,
+    umf_numa_split_partition_t *partitions, unsigned partitions_len) {
+    if (hParams == NULL) {
+        LOG_ERR("OS memory provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (partitions_len && !partitions) {
+        LOG_ERR("partitions_len is not 0, but partitions is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_numa_split_partition_t *new_partitions = NULL;
+    if (partitions_len) {
+        new_partitions =
+            umf_ba_global_alloc(partitions_len * sizeof(*new_partitions));
+        if (new_partitions == NULL) {
+            LOG_ERR("allocating memory for the partitions failed");
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        }
+
+        memcpy(new_partitions, partitions,
+               partitions_len * sizeof(*new_partitions));
+    }
+
+    umf_ba_global_free(hParams->partitions);
+    hParams->partitions = new_partitions;
+    hParams->partitions_len = partitions_len;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+#endif // !defined(UMF_NO_HWLOC)
diff --git a/src/provider/provider_os_memory_internal.h b/src/provider/provider_os_memory_internal.h
index 81d729d27..4d2e8e217 100644
--- a/src/provider/provider_os_memory_internal.h
+++ b/src/provider/provider_os_memory_internal.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -8,6 +8,13 @@
 #ifndef UMF_OS_MEMORY_PROVIDER_INTERNAL_H
 #define UMF_OS_MEMORY_PROVIDER_INTERNAL_H
 
+#include <limits.h>
+#include <stdbool.h>
+#if defined(_WIN32) && !defined(NAME_MAX)
+#include <stdlib.h>
+#define NAME_MAX _MAX_FNAME
+#endif /* defined(_WIN32) && !defined(NAME_MAX) */
+
 #include <umf/providers/provider_os_memory.h>
 
 #include "critnib.h"
@@ -15,26 +22,26 @@
 #include "utils_common.h"
 #include "utils_concurrency.h"
 
+#include "provider_ctl_stats_type.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef enum umf_purge_advise_t {
-    UMF_PURGE_LAZY,
-    UMF_PURGE_FORCE,
-} umf_purge_advise_t;
-
-#define NAME_MAX 255
-
 typedef struct os_memory_provider_t {
     unsigned protection; // combination of OS-specific protection flags
     unsigned visibility; // memory visibility mode
+
+    // IPC is enabled only if (in_params->visibility == UMF_MEM_MAP_SHARED)
+    bool IPC_enabled;
+
     // a name of a shared memory file (valid only in case of the shared memory visibility)
     char shm_name[NAME_MAX];
-    int fd;             // file descriptor for memory mapping
-    size_t size_fd;     // size of file used for memory mapping
-    size_t max_size_fd; // maximum size of file used for memory mapping
-    os_mutex_t lock_fd; // lock for updating file size
+
+    int fd;                // file descriptor for memory mapping
+    size_t size_fd;        // size of file used for memory mapping
+    size_t max_size_fd;    // maximum size of file used for memory mapping
+    utils_mutex_t lock_fd; // lock for updating file size
 
     // A critnib map storing (ptr, fd_offset + 1) pairs. We add 1 to fd_offset
     // in order to be able to store fd_offset equal 0, because
@@ -52,7 +59,7 @@ typedef struct os_memory_provider_t {
     int numa_flags; // combination of hwloc flags
 
     size_t part_size;
-    size_t alloc_sum; // sum of all allocations - used for manual interleaving
+    uint64_t alloc_sum; // sum of all allocations - used for manual interleaving
 
     struct {
         unsigned weight;
@@ -62,43 +69,9 @@ typedef struct os_memory_provider_t {
     size_t partitions_weight_sum;
 
     hwloc_topology_t topo;
-} os_memory_provider_t;
-
-umf_result_t os_translate_flags(unsigned in_flags, unsigned max,
-                                umf_result_t (*translate_flag)(unsigned,
-                                                               unsigned *),
-                                unsigned *out_flags);
-
-umf_result_t os_translate_mem_protection_flags(unsigned in_protection,
-                                               unsigned *out_protection);
-
-umf_result_t os_translate_mem_visibility_flag(umf_memory_visibility_t in_flag,
-                                              unsigned *out_flag);
-
-int os_create_anonymous_fd(void);
 
-int os_shm_create(const char *shm_name, size_t size);
-
-int os_shm_open(const char *shm_name);
-
-int os_shm_unlink(const char *shm_name);
-
-size_t get_max_file_size(void);
-
-int os_get_file_size(int fd, size_t *size);
-
-int os_set_file_size(int fd, size_t size);
-
-void *os_mmap(void *hint_addr, size_t length, int prot, int flag, int fd,
-              size_t fd_offset);
-
-int os_munmap(void *addr, size_t length);
-
-int os_purge(void *addr, size_t length, int advice);
-
-size_t os_get_page_size(void);
-
-void os_strerror(int errnum, char *buf, size_t buflen);
+    ctl_stats_t stats;
+} os_memory_provider_t;
 
 #ifdef __cplusplus
 }
diff --git a/src/provider/provider_os_memory_linux.c b/src/provider/provider_os_memory_linux.c
deleted file mode 100644
index fd0e3ab97..000000000
--- a/src/provider/provider_os_memory_linux.c
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * Copyright (C) 2023-2024 Intel Corporation
- *
- * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-*/
-
-#include <errno.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/syscall.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <umf/providers/provider_os_memory.h>
-
-#include "provider_os_memory_internal.h"
-#include "utils_log.h"
-
-umf_result_t os_translate_mem_visibility_flag(umf_memory_visibility_t in_flag,
-                                              unsigned *out_flag) {
-    switch (in_flag) {
-    case UMF_MEM_MAP_PRIVATE:
-        *out_flag = MAP_PRIVATE;
-        return UMF_RESULT_SUCCESS;
-    case UMF_MEM_MAP_SHARED:
-        *out_flag = MAP_SHARED;
-        return UMF_RESULT_SUCCESS;
-    }
-    return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-}
-
-// create a shared memory file
-int os_shm_create(const char *shm_name, size_t size) {
-    if (shm_name == NULL) {
-        LOG_ERR("empty name of a shared memory file");
-        return -1;
-    }
-
-    (void)shm_unlink(shm_name);
-
-    int fd = shm_open(shm_name, O_RDWR | O_CREAT | O_EXCL, 0600);
-    if (fd == -1) {
-        LOG_PERR("cannot create a shared memory file /dev/shm/%s", shm_name);
-        return fd;
-    }
-
-    int ret = os_set_file_size(fd, size);
-    if (ret) {
-        LOG_ERR("setting size (%zu) of a file /dev/shm/%s failed", size,
-                shm_name);
-        close(fd);
-        (void)shm_unlink(shm_name);
-        return -1;
-    }
-
-    return fd;
-}
-
-// open a shared memory file
-int os_shm_open(const char *shm_name) {
-    if (shm_name == NULL) {
-        LOG_ERR("empty name of a shared memory file");
-        return -1;
-    }
-
-    int fd = shm_open(shm_name, O_RDWR, 0600);
-    if (fd == -1) {
-        LOG_PERR("cannot open a shared memory file /dev/shm/%s", shm_name);
-    }
-
-    return fd;
-}
-
-// unlink a shared memory file
-int os_shm_unlink(const char *shm_name) { return shm_unlink(shm_name); }
-
-static int syscall_memfd_secret(void) {
-    int fd = -1;
-#ifdef __NR_memfd_secret
-    // SYS_memfd_secret is supported since Linux 5.14
-    fd = syscall(SYS_memfd_secret, 0);
-    if (fd == -1) {
-        LOG_PERR("memfd_secret() failed");
-    }
-    if (fd > 0) {
-        LOG_DEBUG("anonymous file descriptor created using memfd_secret()");
-    }
-#endif /* __NR_memfd_secret */
-    return fd;
-}
-
-static int syscall_memfd_create(void) {
-    int fd = -1;
-#ifdef __NR_memfd_create
-    // SYS_memfd_create is supported since Linux 3.17, glibc 2.27
-    fd = syscall(SYS_memfd_create, "anon_fd_name", 0);
-    if (fd == -1) {
-        LOG_PERR("memfd_create() failed");
-    }
-    if (fd > 0) {
-        LOG_DEBUG("anonymous file descriptor created using memfd_create()");
-    }
-#endif /* __NR_memfd_create */
-    return fd;
-}
-
-// create an anonymous file descriptor
-int os_create_anonymous_fd(void) {
-    int fd = -1;
-
-    if (!util_env_var_has_str("UMF_MEM_FD_FUNC", "memfd_create")) {
-        fd = syscall_memfd_secret();
-        if (fd > 0) {
-            return fd;
-        }
-    }
-
-    // The SYS_memfd_secret syscall can fail with errno == ENOTSYS (function not implemented).
-    // We should try to call the SYS_memfd_create syscall in this case.
-
-    fd = syscall_memfd_create();
-
-#if !(defined __NR_memfd_secret) && !(defined __NR_memfd_create)
-    if (fd == -1) {
-        LOG_ERR("cannot create an anonymous file descriptor - neither "
-                "memfd_secret() nor memfd_create() are defined");
-    }
-#endif /* !(defined __NR_memfd_secret) && !(defined __NR_memfd_create) */
-
-    return fd;
-}
-
-int os_get_file_size(int fd, size_t *size) {
-    struct stat statbuf;
-    int ret = fstat(fd, &statbuf);
-    if (ret) {
-        LOG_PERR("fstat(%i) failed", fd);
-        return ret;
-    }
-
-    *size = statbuf.st_size;
-    return 0;
-}
-
-int os_set_file_size(int fd, size_t size) {
-    errno = 0;
-    int ret = ftruncate(fd, size);
-    if (ret) {
-        LOG_PERR("ftruncate(%i, %zu) failed", fd, size);
-    }
-    return ret;
-}
diff --git a/src/provider/provider_os_memory_posix.c b/src/provider/provider_os_memory_posix.c
deleted file mode 100644
index 9308f6a18..000000000
--- a/src/provider/provider_os_memory_posix.c
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * Copyright (C) 2023-2024 Intel Corporation
- *
- * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-*/
-
-#include <errno.h>
-#include <limits.h>
-#include <string.h>
-#include <sys/mman.h>
-#include <sys/syscall.h>
-#include <unistd.h>
-
-#include <umf/providers/provider_os_memory.h>
-
-#include "provider_os_memory_internal.h"
-#include "utils_log.h"
-#include "utils_sanitizers.h"
-
-// maximum value of the off_t type
-#define OFF_T_MAX                                                              \
-    (sizeof(off_t) == sizeof(long long)                                        \
-         ? LLONG_MAX                                                           \
-         : (sizeof(off_t) == sizeof(long) ? LONG_MAX : INT_MAX))
-
-umf_result_t os_translate_mem_protection_one_flag(unsigned in_protection,
-                                                  unsigned *out_protection) {
-    switch (in_protection) {
-    case UMF_PROTECTION_NONE:
-        *out_protection = PROT_NONE;
-        return UMF_RESULT_SUCCESS;
-    case UMF_PROTECTION_READ:
-        *out_protection = PROT_READ;
-        return UMF_RESULT_SUCCESS;
-    case UMF_PROTECTION_WRITE:
-        *out_protection = PROT_WRITE;
-        return UMF_RESULT_SUCCESS;
-    case UMF_PROTECTION_EXEC:
-        *out_protection = PROT_EXEC;
-        return UMF_RESULT_SUCCESS;
-    }
-    return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-}
-
-size_t get_max_file_size(void) { return OFF_T_MAX; }
-
-umf_result_t os_translate_mem_protection_flags(unsigned in_protection,
-                                               unsigned *out_protection) {
-    // translate protection - combination of 'umf_mem_protection_flags_t' flags
-    return os_translate_flags(in_protection, UMF_PROTECTION_MAX,
-                              os_translate_mem_protection_one_flag,
-                              out_protection);
-}
-
-static int os_translate_purge_advise(umf_purge_advise_t advise) {
-    switch (advise) {
-    case UMF_PURGE_LAZY:
-        return MADV_FREE;
-    case UMF_PURGE_FORCE:
-        return MADV_DONTNEED;
-    }
-    return -1;
-}
-
-void *os_mmap(void *hint_addr, size_t length, int prot, int flag, int fd,
-              size_t fd_offset) {
-    fd = (fd == 0) ? -1 : fd;
-    if (fd == -1) {
-        // MAP_ANONYMOUS - the mapping is not backed by any file
-        flag |= MAP_ANONYMOUS;
-    }
-
-    void *ptr = mmap(hint_addr, length, prot, flag, fd, fd_offset);
-    if (ptr == MAP_FAILED) {
-        return NULL;
-    }
-    // this should be unnecessary but pairs of mmap/munmap do not reset
-    // asan's user-poisoning flags, leading to invalid error reports
-    // Bug 81619: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81619
-    utils_annotate_memory_defined(ptr, length);
-    return ptr;
-}
-
-int os_munmap(void *addr, size_t length) {
-    // this should be unnecessary but pairs of mmap/munmap do not reset
-    // asan's user-poisoning flags, leading to invalid error reports
-    // Bug 81619: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81619
-    utils_annotate_memory_defined(addr, length);
-    return munmap(addr, length);
-}
-
-size_t os_get_page_size(void) { return sysconf(_SC_PAGE_SIZE); }
-
-int os_purge(void *addr, size_t length, int advice) {
-    return madvise(addr, length, os_translate_purge_advise(advice));
-}
-
-void os_strerror(int errnum, char *buf, size_t buflen) {
-// 'strerror_r' implementation is XSI-compliant (returns 0 on success)
-#if (_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && !_GNU_SOURCE
-    if (strerror_r(errnum, buf, buflen)) {
-#else // 'strerror_r' implementation is GNU-specific (returns pointer on success)
-    if (!strerror_r(errnum, buf, buflen)) {
-#endif
-        LOG_PERR("Retrieving error code description failed");
-    }
-}
diff --git a/src/provider/provider_os_memory_windows.c b/src/provider/provider_os_memory_windows.c
deleted file mode 100644
index 994f4d53c..000000000
--- a/src/provider/provider_os_memory_windows.c
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
- * Copyright (C) 2024 Intel Corporation
- *
- * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-*/
-
-#include <windows.h>
-
-#include <assert.h>
-#include <stdio.h>
-#include <string.h>
-#include <sysinfoapi.h>
-
-#include <umf/providers/provider_os_memory.h>
-
-#include "utils_concurrency.h"
-#include "utils_log.h"
-
-static UTIL_ONCE_FLAG Page_size_is_initialized = UTIL_ONCE_FLAG_INIT;
-static size_t Page_size;
-
-umf_result_t os_translate_mem_protection_flags(unsigned in_protection,
-                                               unsigned *out_protection) {
-    switch (in_protection) {
-    case UMF_PROTECTION_NONE:
-        *out_protection = PAGE_NOACCESS;
-        return UMF_RESULT_SUCCESS;
-    case UMF_PROTECTION_EXEC:
-        *out_protection = PAGE_EXECUTE;
-        return UMF_RESULT_SUCCESS;
-    case (UMF_PROTECTION_EXEC | UMF_PROTECTION_READ):
-        *out_protection = PAGE_EXECUTE_READ;
-        return UMF_RESULT_SUCCESS;
-    case (UMF_PROTECTION_EXEC | UMF_PROTECTION_READ | UMF_PROTECTION_WRITE):
-        *out_protection = PAGE_EXECUTE_READWRITE;
-        return UMF_RESULT_SUCCESS;
-    case (UMF_PROTECTION_EXEC | UMF_PROTECTION_WRITE):
-        *out_protection = PAGE_EXECUTE_WRITECOPY;
-        return UMF_RESULT_SUCCESS;
-    case UMF_PROTECTION_READ:
-        *out_protection = PAGE_READONLY;
-        return UMF_RESULT_SUCCESS;
-    case (UMF_PROTECTION_READ | UMF_PROTECTION_WRITE):
-        *out_protection = PAGE_READWRITE;
-        return UMF_RESULT_SUCCESS;
-    case UMF_PROTECTION_WRITE:
-        *out_protection = PAGE_WRITECOPY;
-        return UMF_RESULT_SUCCESS;
-    }
-    LOG_ERR("os_translate_mem_protection_flags(): unsupported protection flag: "
-            "%u",
-            in_protection);
-    return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-}
-
-umf_result_t os_translate_mem_visibility_flag(umf_memory_visibility_t in_flag,
-                                              unsigned *out_flag) {
-    switch (in_flag) {
-    case UMF_MEM_MAP_PRIVATE:
-        *out_flag = 0; // ignored on Windows
-        return UMF_RESULT_SUCCESS;
-    case UMF_MEM_MAP_SHARED:
-        return UMF_RESULT_ERROR_NOT_SUPPORTED; // not supported on Windows yet
-    }
-    return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-}
-
-// create a shared memory file
-int os_shm_create(const char *shm_name, size_t size) {
-    (void)shm_name; // unused
-    (void)size;     // unused
-    return 0;       // ignored on Windows
-}
-
-// open a shared memory file
-int os_shm_open(const char *shm_name) {
-    (void)shm_name; // unused
-    return 0;       // ignored on Windows
-}
-
-// unlink a shared memory file
-int os_shm_unlink(const char *shm_name) {
-    (void)shm_name; // unused
-    return 0;       // ignored on Windows
-}
-
-int os_create_anonymous_fd(void) {
-    return 0; // ignored on Windows
-}
-
-size_t get_max_file_size(void) { return SIZE_MAX; }
-
-int os_get_file_size(int fd, size_t *size) {
-    (void)fd;   // unused
-    (void)size; // unused
-    return -1;  // not supported on Windows
-}
-
-int os_set_file_size(int fd, size_t size) {
-    (void)fd;   // unused
-    (void)size; // unused
-    return 0;   // ignored on Windows
-}
-
-void *os_mmap(void *hint_addr, size_t length, int prot, int flag, int fd,
-              size_t fd_offset) {
-    (void)flag;      // ignored on Windows
-    (void)fd;        // ignored on Windows
-    (void)fd_offset; // ignored on Windows
-    return VirtualAlloc(hint_addr, length, MEM_RESERVE | MEM_COMMIT, prot);
-}
-
-int os_munmap(void *addr, size_t length) {
-    // If VirtualFree() succeeds, the return value is nonzero.
-    // If VirtualFree() fails, the return value is 0 (zero).
-    (void)length; // unused
-    return (VirtualFree(addr, 0, MEM_RELEASE) == 0);
-}
-
-int os_purge(void *addr, size_t length, int advice) {
-    // If VirtualFree() succeeds, the return value is nonzero.
-    // If VirtualFree() fails, the return value is 0 (zero).
-    (void)advice; // unused
-
-    // temporarily disable the C6250 warning as we intentionally use the
-    // MEM_DECOMMIT flag only
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable : 6250)
-#endif // _MSC_VER
-
-    return (VirtualFree(addr, length, MEM_DECOMMIT) == 0);
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif // _MSC_VER
-}
-
-static void _os_get_page_size(void) {
-    SYSTEM_INFO SystemInfo;
-    GetSystemInfo(&SystemInfo);
-    Page_size = SystemInfo.dwPageSize;
-}
-
-size_t os_get_page_size(void) {
-    util_init_once(&Page_size_is_initialized, _os_get_page_size);
-    return Page_size;
-}
-
-void os_strerror(int errnum, char *buf, size_t buflen) {
-    strerror_s(buf, buflen, errnum);
-}
diff --git a/src/provider/provider_tracking.c b/src/provider/provider_tracking.c
index adbe3515b..252316ea6 100644
--- a/src/provider/provider_tracking.c
+++ b/src/provider/provider_tracking.c
@@ -1,68 +1,329 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  */
 
-#include "provider_tracking.h"
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <umf/memory_pool.h>
+#include <umf/memory_provider.h>
+#include <umf/memory_provider_ops.h>
+
 #include "base_alloc_global.h"
 #include "critnib.h"
+#include "ipc_cache.h"
 #include "ipc_internal.h"
+#include "memory_pool_internal.h"
+#include "provider_tracking.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
 #include "utils_log.h"
 
-#include <umf/memory_pool.h>
-#include <umf/memory_provider.h>
-#include <umf/memory_provider_ops.h>
+// TODO: we need to support an arbitrary amount of layers in the future
+#define MAX_LEVELS_OF_ALLOC_SEGMENT_MAP 8
 
-#include <assert.h>
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+uint64_t IPC_HANDLE_ID = 0;
 
-typedef struct tracker_value_t {
+struct umf_memory_tracker_t {
+    umf_ba_pool_t *alloc_info_allocator;
+    // Multilevel maps are needed to support the case
+    // when one memory pool acts as a memory provider
+    // for another memory pool (nested memory pooling).
+    critnib *alloc_segments_map[MAX_LEVELS_OF_ALLOC_SEGMENT_MAP];
+    utils_mutex_t splitMergeMutex;
+    umf_ba_pool_t *ipc_info_allocator;
+    critnib *ipc_segments_map;
+};
+
+typedef struct tracker_alloc_info_t {
     umf_memory_pool_handle_t pool;
     size_t size;
-} tracker_value_t;
+    // number of overlapping memory regions
+    // in the next level of map
+    // falling within the current range
+    size_t n_children;
+#if !defined(NDEBUG) && defined(UMF_DEVELOPER_MODE)
+    uint64_t is_freed;
+#endif
+} tracker_alloc_info_t;
+
+typedef struct tracker_ipc_info_t {
+    size_t size;
+    umf_memory_provider_handle_t provider;
+    ipc_opened_cache_value_t *ipc_cache_value;
+} tracker_ipc_info_t;
+
+// Get the most nested (on the highest level) allocation segment in the map with the `ptr` key.
+// If `no_children` is set to 1, the function will return the entry
+// only if it has no children on the higher level.
+// The function returns the entry if found, otherwise NULL.
+static tracker_alloc_info_t *get_most_nested_alloc_segment(
+    umf_memory_tracker_handle_t hTracker, const void *ptr, int *_level,
+    uintptr_t *_parent_key, tracker_alloc_info_t **_parent_value,
+    void **_ref_value, void **_ref_parent_value, int no_children) {
 
-static umf_result_t umfMemoryTrackerAdd(umf_memory_tracker_handle_t hTracker,
-                                        umf_memory_pool_handle_t pool,
-                                        const void *ptr, size_t size) {
     assert(ptr);
+    assert(_ref_value);
+    if (_parent_value) {
+        assert(_ref_parent_value);
+    }
+
+    tracker_alloc_info_t *parent_value = NULL;
+    tracker_alloc_info_t *rvalue = NULL;
+    uintptr_t parent_key = 0;
+    uintptr_t rkey = 0;
+    uint64_t rsize = 0;
+    size_t n_children = 0;
+    int level = 0;
+    int found = 0;
+
+    void *ref_value = NULL;
+    void *ref_parent_value = NULL;
+
+    do {
+        assert(level < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP);
+        found =
+            critnib_find(hTracker->alloc_segments_map[level], (uintptr_t)ptr,
+                         FIND_LE, (void *)&rkey, (void **)&rvalue, &ref_value);
+        if (!found) {
+            assert(ref_value == NULL);
+            break;
+        }
+
+        if (rvalue == NULL) {
+            if (ref_value) {
+                critnib_release(hTracker->alloc_segments_map[level], ref_value);
+            }
+            parent_value = NULL;
+            parent_key = 0;
+            rkey = 0;
+            rsize = 0;
+            level = 0;
+            found = 0;
+            ref_value = NULL;
+            ref_parent_value = NULL;
+            continue;
+        }
+
+        utils_atomic_load_acquire_u64((uint64_t *)&rvalue->size, &rsize);
+        utils_atomic_load_acquire_size_t(&rvalue->n_children, &n_children);
+        if (found && ((uintptr_t)ptr < rkey + rsize) && n_children) {
+            if (level == MAX_LEVELS_OF_ALLOC_SEGMENT_MAP - 1) {
+                break;
+            }
+
+            level++;
 
-    tracker_value_t *value = umf_ba_alloc(hTracker->tracker_allocator);
+            if (_parent_key) {
+                parent_key = rkey;
+            }
+
+            if (_parent_value) {
+                parent_value = rvalue;
+                // If we return the parent value, we have to return also its reference.
+                // If it is already set, we have to release the previous one first.
+                if (ref_parent_value) {
+                    assert(level >= 2);
+                    // release the previous reference to the parent value
+                    critnib_release(hTracker->alloc_segments_map[level - 2],
+                                    ref_parent_value);
+                }
+                ref_parent_value = ref_value;
+            } else if (ref_value) {
+                // If we do not return the parent value,
+                // we have to release the current 'ref_value' reference
+                // before it will be overwritten in the next critnib_find() call.
+                assert(level >= 1);
+                critnib_release(hTracker->alloc_segments_map[level - 1],
+                                ref_value);
+                ref_value = NULL;
+            }
+        }
+    } while (found && ((uintptr_t)ptr < rkey + rsize) && n_children);
+
+    if (!rvalue || rkey != (uintptr_t)ptr) {
+        return NULL;
+    }
+
+    if (no_children && (n_children > 0)) {
+        return NULL;
+    }
+
+    if (_level) {
+        *_level = level;
+    }
+    if (_parent_key) {
+        *_parent_key = parent_key;
+    }
+    if (_parent_value) {
+        *_ref_parent_value = ref_parent_value;
+        *_parent_value = parent_value;
+    }
+
+    assert(!no_children || rvalue->n_children == 0);
+    assert(ref_value);
+    *_ref_value = ref_value;
+
+    return rvalue;
+}
+
+static umf_result_t
+umfMemoryTrackerAddAtLevel(umf_memory_tracker_handle_t hTracker, int level,
+                           umf_memory_pool_handle_t pool, const void *ptr,
+                           size_t size, uintptr_t parent_key,
+                           tracker_alloc_info_t *parent_value,
+                           void *ref_parent_value) {
+    assert(ptr);
+
+    umf_result_t umf_result = UMF_RESULT_ERROR_UNKNOWN;
+
+    tracker_alloc_info_t *value = umf_ba_alloc(hTracker->alloc_info_allocator);
     if (value == NULL) {
-        LOG_ERR("failed to allocate tracker value, ptr=%p, size=%zu", ptr,
+        LOG_ERR("failed to allocate a tracker value, ptr=%p, size=%zu", ptr,
                 size);
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
     value->pool = pool;
     value->size = size;
-
-    int ret = critnib_insert(hTracker->map, (uintptr_t)ptr, value, 0);
-
+    value->n_children = 0;
+#if !defined(NDEBUG) && defined(UMF_DEVELOPER_MODE)
+    value->is_freed = 0;
+#endif
+
+    assert(level < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP);
+    int ret = critnib_insert(hTracker->alloc_segments_map[level],
+                             (uintptr_t)ptr, value, 0);
     if (ret == 0) {
-        LOG_DEBUG("memory region is added, tracker=%p, ptr=%p, size=%zu",
-                  (void *)hTracker, ptr, size);
+        LOG_DEBUG("memory region is added, tracker=%p, level=%i, pool=%p, "
+                  "ptr=%p, size=%zu",
+                  (void *)hTracker, level, (void *)pool, ptr, size);
+
+        if (parent_value) {
+            size_t n_children =
+                utils_atomic_increment_size_t(&parent_value->n_children) + 1;
+            LOG_DEBUG(
+                "child #%zu added to memory region: tracker=%p, level=%i, "
+                "pool=%p, ptr=%p, size=%zu",
+                n_children, (void *)hTracker, level - 1,
+                (void *)parent_value->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;
     }
+    if (ret == ENOMEM) {
+        umf_result = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
 
-    LOG_ERR("failed to insert tracker value, ret=%d, ptr=%p, size=%zu", ret,
-            ptr, size);
+    LOG_ERR(
+        "failed to insert the tracker value: pool=%p, ptr=%p, size=%zu, ret=%d",
+        (void *)pool, ptr, size, ret);
 
-    umf_ba_free(hTracker->tracker_allocator, value);
+    umf_ba_free(hTracker->alloc_info_allocator, value);
 
-    if (ret == ENOMEM) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    return umf_result;
+}
+
+static umf_result_t umfMemoryTrackerAdd(umf_memory_tracker_handle_t hTracker,
+                                        umf_memory_pool_handle_t pool,
+                                        const void *ptr, size_t size) {
+    assert(ptr);
+
+    tracker_alloc_info_t *parent_value = NULL;
+    tracker_alloc_info_t *rvalue = NULL;
+    uintptr_t parent_key = 0;
+    uintptr_t rkey = 0;
+    uint64_t rsize = 0;
+    size_t n_children = 0;
+    int level = 0;
+    int found = 0;
+
+    void *ref_value = NULL;
+    void *ref_parent_value = NULL;
+
+    // Find the most nested (in the highest level) entry
+    // in the critnib maps that contains the given 'ptr' pointer.
+    do {
+        assert(level < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP);
+        found =
+            critnib_find(hTracker->alloc_segments_map[level], (uintptr_t)ptr,
+                         FIND_LE, (void *)&rkey, (void **)&rvalue, &ref_value);
+        if (!found) {
+            assert(ref_value == NULL);
+            break;
+        }
+
+        if (!rvalue) {
+            if (ref_value) {
+                critnib_release(hTracker->alloc_segments_map[level], ref_value);
+            }
+            parent_value = NULL;
+            parent_key = 0;
+            rkey = 0;
+            rsize = 0;
+            level = 0;
+            found = 0;
+            ref_value = NULL;
+            ref_parent_value = NULL;
+            continue;
+        }
+
+#if !defined(NDEBUG) && defined(UMF_DEVELOPER_MODE)
+        // make sure rvalue is not freed
+        uint64_t is_freed;
+        utils_atomic_load_acquire_u64(&rvalue->is_freed, &is_freed);
+        assert(is_freed != 0xDEADBEEF);
+#endif
+
+        utils_atomic_load_acquire_u64((uint64_t *)&rvalue->size, &rsize);
+
+        if ((uintptr_t)ptr < rkey + rsize) {
+            if (level == MAX_LEVELS_OF_ALLOC_SEGMENT_MAP - 1) {
+                // TODO: we need to support an arbitrary amount of layers in the future
+                LOG_ERR("tracker level is too high, ptr=%p, size=%zu", ptr,
+                        size);
+                return UMF_RESULT_ERROR_OUT_OF_RESOURCES;
+            }
+            if (((uintptr_t)ptr + size) > (rkey + rsize)) {
+                LOG_ERR(
+                    "cannot insert to the tracker value (pool=%p, ptr=%p, "
+                    "size=%zu) "
+                    "that exceeds the parent value (pool=%p, ptr=%p, size=%zu)",
+                    (void *)pool, ptr, size, (void *)rvalue->pool, (void *)rkey,
+                    (size_t)rsize);
+                return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+            }
+            parent_key = rkey;
+            parent_value = rvalue;
+            if (ref_parent_value) {
+                assert(level >= 1);
+                critnib_release(hTracker->alloc_segments_map[level - 1],
+                                ref_parent_value);
+            }
+            ref_parent_value = ref_value;
+            level++;
+        }
+        utils_atomic_load_acquire_size_t(&rvalue->n_children, &n_children);
+    } while (found && ((uintptr_t)ptr < rkey + rsize) && n_children);
+
+    if (ref_value && ref_value != ref_parent_value) {
+        critnib_release(hTracker->alloc_segments_map[level], ref_value);
     }
 
-    return UMF_RESULT_ERROR_UNKNOWN;
+    return umfMemoryTrackerAddAtLevel(hTracker, level, pool, ptr, size,
+                                      parent_key, parent_value,
+                                      ref_parent_value);
 }
 
 static umf_result_t umfMemoryTrackerRemove(umf_memory_tracker_handle_t hTracker,
@@ -74,13 +335,125 @@ static umf_result_t umfMemoryTrackerRemove(umf_memory_tracker_handle_t hTracker,
     // Every umfMemoryTrackerAdd(..., ptr, ...) should have a corresponding
     // umfMemoryTrackerRemove call with the same ptr value.
 
-    void *value = critnib_remove(hTracker->map, (uintptr_t)ptr);
+    tracker_alloc_info_t *parent_value = NULL;
+    uintptr_t parent_key = 0;
+    int level = 0;
+
+    // Find the most nested (on the highest level) entry in the map
+    // with the `ptr` key and with no children - only such entry can be removed.
+    void *ref_value = NULL;
+    void *ref_parent_value = NULL;
+    tracker_alloc_info_t *value = get_most_nested_alloc_segment(
+        hTracker, ptr, &level, &parent_key, &parent_value, &ref_value,
+        &ref_parent_value, 1 /* no_children */);
     if (!value) {
-        LOG_ERR("pointer %p not found in the map", ptr);
+        LOG_ERR("pointer %p not found in the alloc_segments_map", ptr);
         return UMF_RESULT_ERROR_UNKNOWN;
     }
 
-    umf_ba_free(hTracker->tracker_allocator, value);
+    assert(level < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP);
+
+    // release the reference to the value got from get_most_nested_alloc_segment()
+    assert(ref_value);
+    critnib_release(hTracker->alloc_segments_map[level], ref_value);
+
+    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, (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",
+            n_children, (void *)hTracker, level - 1, (void *)parent_value->pool,
+            (void *)parent_key, parent_value->size);
+
+        assert(ref_parent_value);
+        assert(level >= 1);
+        // release the ref_parent_value got from get_most_nested_alloc_segment()
+        critnib_release(hTracker->alloc_segments_map[level - 1],
+                        ref_parent_value);
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t
+umfMemoryTrackerAddIpcSegment(umf_memory_tracker_handle_t hTracker,
+                              const void *ptr, size_t size,
+                              umf_memory_provider_handle_t provider,
+                              ipc_opened_cache_value_t *cache_entry) {
+    assert(hTracker);
+    assert(provider);
+    assert(cache_entry);
+
+    tracker_ipc_info_t *value = umf_ba_alloc(hTracker->ipc_info_allocator);
+
+    if (value == NULL) {
+        LOG_ERR("failed to allocate tracker_ipc_info_t, ptr=%p, size=%zu", ptr,
+                size);
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    value->size = size;
+    value->provider = provider;
+    value->ipc_cache_value = cache_entry;
+
+    int ret =
+        critnib_insert(hTracker->ipc_segments_map, (uintptr_t)ptr, value, 0);
+    if (ret == 0) {
+        LOG_DEBUG("IPC memory region is added, tracker=%p, ptr=%p, size=%zu, "
+                  "provider=%p, cache_entry=%p",
+                  (void *)hTracker, ptr, size, (void *)provider,
+                  (void *)cache_entry);
+        return UMF_RESULT_SUCCESS;
+    }
+
+    LOG_ERR("failed to insert tracker_ipc_info_t, ret=%d, ptr=%p, size=%zu, "
+            "provider=%p, cache_entry=%p",
+            ret, ptr, size, (void *)provider, (void *)cache_entry);
+
+    umf_ba_free(hTracker->ipc_info_allocator, value);
+
+    if (ret == ENOMEM) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    return UMF_RESULT_ERROR_UNKNOWN;
+}
+
+static umf_result_t
+umfMemoryTrackerRemoveIpcSegment(umf_memory_tracker_handle_t hTracker,
+                                 const void *ptr) {
+    assert(ptr);
+
+    void *ref_value = NULL;
+    void *value =
+        critnib_remove(hTracker->ipc_segments_map, (uintptr_t)ptr, &ref_value);
+    if (!value) {
+        LOG_ERR("pointer %p not found in the ipc_segments_map", ptr);
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    tracker_ipc_info_t *v = value;
+
+    LOG_DEBUG("IPC memory region removed: tracker=%p, ptr=%p, size=%zu, "
+              "provider=%p, cache_entry=%p",
+              (void *)hTracker, ptr, v->size, (void *)v->provider,
+              (void *)v->ipc_cache_value);
+
+    assert(ref_value);
+    critnib_release(hTracker->ipc_segments_map, ref_value);
 
     return UMF_RESULT_SUCCESS;
 }
@@ -97,33 +470,142 @@ umf_memory_pool_handle_t umfMemoryTrackerGetPool(const void *ptr) {
 
 umf_result_t umfMemoryTrackerGetAllocInfo(const void *ptr,
                                           umf_alloc_info_t *pAllocInfo) {
-    assert(ptr);
     assert(pAllocInfo);
 
+    if (ptr == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (TRACKER == NULL) {
+        LOG_ERR("tracker does not exist");
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+
+    if (TRACKER->alloc_segments_map[0] == NULL) {
+        LOG_ERR("tracker's alloc_segments_map does not exist");
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+
+    tracker_alloc_info_t *top_most_value = NULL;
+    tracker_alloc_info_t *rvalue = NULL;
+    uintptr_t top_most_key = 0;
+    uintptr_t rkey = 0;
+    uint64_t rsize = 0;
+    size_t n_children = 0;
+    int level = 0;
+    int found = 0;
+
+    void *ref_value = NULL;
+    void *ref_top_most_value = NULL;
+    int ref_level = 0;
+
+    do {
+        assert(level < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP);
+        found =
+            critnib_find(TRACKER->alloc_segments_map[level], (uintptr_t)ptr,
+                         FIND_LE, (void *)&rkey, (void **)&rvalue, &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 (ref_top_most_value) {
+                assert(level >= 1);
+                critnib_release(TRACKER->alloc_segments_map[level - 1],
+                                ref_top_most_value);
+            }
+            ref_top_most_value = ref_value;
+            ref_level = level;
+            if (n_children == 0 ||
+                level == MAX_LEVELS_OF_ALLOC_SEGMENT_MAP - 1) {
+                break;
+            }
+            level++;
+        }
+    } while (found && (uintptr_t)ptr < rkey + rsize && n_children);
+
+    if (!top_most_value) {
+        if (ref_value) {
+            critnib_release(TRACKER->alloc_segments_map[level], ref_value);
+        }
+
+        LOG_DEBUG("pointer %p not found in the tracker, TRACKER=%p", ptr,
+                  (void *)TRACKER);
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    pAllocInfo->base = (void *)top_most_key;
+    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;
+}
+
+umf_result_t umfMemoryTrackerGetIpcInfo(const void *ptr,
+                                        umf_ipc_info_t *pIpcInfo) {
+    assert(pIpcInfo);
+
+    if (ptr == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
     if (TRACKER == NULL) {
-        LOG_ERR("tracker is not created");
+        LOG_ERR("tracker does not exist");
         return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
 
-    if (TRACKER->map == NULL) {
-        LOG_ERR("tracker's map is not created");
+    if (TRACKER->ipc_segments_map == NULL) {
+        LOG_ERR("tracker's ipc_segments_map does not exist");
         return UMF_RESULT_ERROR_NOT_SUPPORTED;
     }
 
-    uintptr_t rkey;
-    tracker_value_t *rvalue;
-    int found = critnib_find(TRACKER->map, (uintptr_t)ptr, FIND_LE,
-                             (void *)&rkey, (void **)&rvalue);
-    if (!found || (uintptr_t)ptr >= rkey + rvalue->size) {
-        LOG_WARN("pointer %p not found in the "
-                 "tracker, TRACKER=%p",
-                 ptr, (void *)TRACKER);
+    uintptr_t rkey = 0;
+    tracker_ipc_info_t *rvalue = NULL;
+    void *ref_value = NULL;
+    int found = critnib_find(TRACKER->ipc_segments_map, (uintptr_t)ptr, FIND_LE,
+                             (void *)&rkey, (void **)&rvalue, &ref_value);
+
+    if (!found || (found && (rvalue == NULL)) ||
+        ((uintptr_t)ptr >= rkey + rvalue->size)) {
+        LOG_DEBUG("pointer %p not found in the tracker, TRACKER=%p", ptr,
+                  (void *)TRACKER);
+        if (ref_value) {
+            critnib_release(TRACKER->ipc_segments_map, ref_value);
+        }
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    pAllocInfo->base = (void *)rkey;
-    pAllocInfo->baseSize = rvalue->size;
-    pAllocInfo->pool = rvalue->pool;
+    pIpcInfo->base = (void *)rkey;
+    pIpcInfo->baseSize = rvalue->size;
+    pIpcInfo->provider = rvalue->provider;
+
+    if (ref_value) {
+        critnib_release(TRACKER->ipc_segments_map, ref_value);
+    }
 
     return UMF_RESULT_SUCCESS;
 }
@@ -132,6 +614,7 @@ umf_result_t umfMemoryTrackerGetAllocInfo(const void *ptr,
 // providerIpcData is a Flexible Array Member because its size varies
 // depending on the provider.
 typedef struct ipc_cache_value_t {
+    uint64_t handle_id;
     uint64_t ipcDataSize;
     char providerIpcData[];
 } ipc_cache_value_t;
@@ -141,31 +624,44 @@ typedef struct umf_tracking_memory_provider_t {
     umf_memory_tracker_handle_t hTracker;
     umf_memory_pool_handle_t pool;
     critnib *ipcCache;
+    ipc_opened_cache_handle_t hIpcMappedCache;
 } umf_tracking_memory_provider_t;
 
 typedef struct umf_tracking_memory_provider_t umf_tracking_memory_provider_t;
 
 static umf_result_t trackingAlloc(void *hProvider, size_t size,
-                                  size_t alignment, void **ptr) {
+                                  size_t alignment, void **_ptr) {
     umf_tracking_memory_provider_t *p =
         (umf_tracking_memory_provider_t *)hProvider;
     umf_result_t ret = UMF_RESULT_SUCCESS;
+    void *ptr;
 
     assert(p->hUpstream);
 
-    ret = umfMemoryProviderAlloc(p->hUpstream, size, alignment, ptr);
-    if (ret != UMF_RESULT_SUCCESS || !*ptr) {
+    *_ptr = NULL;
+
+    ret = umfMemoryProviderAlloc(p->hUpstream, size, alignment, &ptr);
+    if (ret != UMF_RESULT_SUCCESS || !ptr) {
         return ret;
     }
 
-    umf_result_t ret2 = umfMemoryTrackerAdd(p->hTracker, p->pool, *ptr, size);
-    if (ret2 != UMF_RESULT_SUCCESS) {
+    ret = umfMemoryTrackerAdd(p->hTracker, p->pool, ptr, size);
+    if (ret != UMF_RESULT_SUCCESS) {
         LOG_ERR("failed to add allocated region to the tracker, ptr = %p, size "
                 "= %zu, ret = %d",
-                *ptr, size, ret2);
+                ptr, size, ret);
+        umf_result_t ret2 = umfMemoryProviderFree(p->hUpstream, ptr, size);
+        if (ret2 != UMF_RESULT_SUCCESS) {
+            LOG_ERR("upstream provider failed to free the memory: ptr = %p, "
+                    "size = %zu, ret = %d",
+                    ptr, size, ret2);
+        }
+        return ret;
     }
 
-    return ret;
+    *_ptr = ptr;
+
+    return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t trackingAllocationSplit(void *hProvider, void *ptr,
@@ -174,30 +670,30 @@ static umf_result_t trackingAllocationSplit(void *hProvider, void *ptr,
     umf_result_t ret = UMF_RESULT_ERROR_UNKNOWN;
     umf_tracking_memory_provider_t *provider =
         (umf_tracking_memory_provider_t *)hProvider;
+    tracker_alloc_info_t *parent_value = NULL;
+    uintptr_t parent_key = 0;
 
-    tracker_value_t *splitValue =
-        umf_ba_alloc(provider->hTracker->tracker_allocator);
-    if (!splitValue) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    splitValue->pool = provider->pool;
-    splitValue->size = firstSize;
-
-    int r = util_mutex_lock(&provider->hTracker->splitMergeMutex);
+    int r = utils_mutex_lock(&provider->hTracker->splitMergeMutex);
     if (r) {
         goto err_lock;
     }
 
-    tracker_value_t *value =
-        (tracker_value_t *)critnib_get(provider->hTracker->map, (uintptr_t)ptr);
+    int level = 0;
+    void *ref_value = NULL;
+    void *ref_parent_value = NULL;
+
+    // Find the most nested (on the highest level) entry in the map
+    // with the `ptr` key and with no children - only such entry can be split.
+    tracker_alloc_info_t *value = get_most_nested_alloc_segment(
+        provider->hTracker, ptr, &level, &parent_key, &parent_value, &ref_value,
+        &ref_parent_value, 1 /* no_children */);
     if (!value) {
         LOG_ERR("region for split is not found in the tracker");
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
         goto err;
     }
     if (value->size != totalSize) {
-        LOG_ERR("tracked size %zu does not match requested size to split: %zu",
+        LOG_ERR("tracked size=%zu does not match requested size to split: %zu",
                 value->size, totalSize);
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
         goto err;
@@ -213,36 +709,48 @@ static umf_result_t trackingAllocationSplit(void *hProvider, void *ptr,
     void *highPtr = (void *)(((uintptr_t)ptr) + firstSize);
     size_t secondSize = totalSize - firstSize;
 
+    assert(level < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP);
+
     // We'll have a duplicate entry for the range [highPtr, highValue->size] but this is fine,
     // the value is the same anyway and we forbid removing that range concurrently
-    ret = umfMemoryTrackerAdd(provider->hTracker, provider->pool, highPtr,
-                              secondSize);
+    ret = umfMemoryTrackerAddAtLevel(provider->hTracker, level, provider->pool,
+                                     highPtr, secondSize, parent_key,
+                                     parent_value, ref_parent_value);
     if (ret != UMF_RESULT_SUCCESS) {
-        LOG_ERR("failed to add split region to the tracker, ptr = %p, size "
-                "= %zu, ret = %d",
+        LOG_ERR("failed to add the split region to the tracker, ptr=%p, "
+                "size=%zu, ret=%d",
                 highPtr, secondSize, ret);
+
+        // revert the split
+        (void)umfMemoryProviderAllocationMerge(provider->hUpstream, ptr,
+                                               highPtr, totalSize);
+
         // TODO: what now? should we rollback the split? This can only happen due to ENOMEM
         // so it's unlikely but probably the best solution would be to try to preallocate everything
         // (value and critnib nodes) before calling umfMemoryProviderAllocationSplit.
         goto err;
     }
 
-    int cret = critnib_insert(provider->hTracker->map, (uintptr_t)ptr,
-                              (void *)splitValue, 1 /* update */);
-    // this cannot fail since we know the element exists (nothing to allocate)
-    assert(cret == 0);
-    (void)cret;
+    // update the size of the first part
+    utils_atomic_store_release_u64((uint64_t *)&value->size, firstSize);
+    critnib_release(provider->hTracker->alloc_segments_map[level], ref_value);
 
-    // free the original value
-    umf_ba_free(provider->hTracker->tracker_allocator, value);
-    util_mutex_unlock(&provider->hTracker->splitMergeMutex);
+    utils_mutex_unlock(&provider->hTracker->splitMergeMutex);
+
+    LOG_DEBUG(
+        "split memory region (level=%i): ptr=%p, totalSize=%zu, firstSize=%zu",
+        level, ptr, totalSize, firstSize);
 
     return UMF_RESULT_SUCCESS;
 
 err:
-    util_mutex_unlock(&provider->hTracker->splitMergeMutex);
+    utils_mutex_unlock(&provider->hTracker->splitMergeMutex);
+
 err_lock:
-    umf_ba_free(provider->hTracker->tracker_allocator, splitValue);
+    LOG_ERR(
+        "failed to split memory region: ptr=%p, totalSize=%zu, firstSize=%zu",
+        ptr, totalSize, firstSize);
+
     return ret;
 }
 
@@ -252,83 +760,111 @@ static umf_result_t trackingAllocationMerge(void *hProvider, void *lowPtr,
     umf_tracking_memory_provider_t *provider =
         (umf_tracking_memory_provider_t *)hProvider;
 
-    tracker_value_t *mergedValue =
-        umf_ba_alloc(provider->hTracker->tracker_allocator);
-
-    if (!mergedValue) {
-        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    mergedValue->pool = provider->pool;
-    mergedValue->size = totalSize;
+    // any different negative values
+    int lowLevel = -2;
+    int highLevel = -1;
 
-    int r = util_mutex_lock(&provider->hTracker->splitMergeMutex);
+    int r = utils_mutex_lock(&provider->hTracker->splitMergeMutex);
     if (r) {
         goto err_lock;
     }
 
-    tracker_value_t *lowValue = (tracker_value_t *)critnib_get(
-        provider->hTracker->map, (uintptr_t)lowPtr);
+    void *ref_lowValue = NULL;
+    void *ref_highValue = NULL;
+
+    tracker_alloc_info_t *lowValue = get_most_nested_alloc_segment(
+        provider->hTracker, lowPtr, &lowLevel, NULL, NULL, &ref_lowValue, NULL,
+        0 /* no_children */);
     if (!lowValue) {
-        LOG_ERR("no left value");
+        LOG_FATAL("no left value");
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err;
+        goto err_fatal;
+    }
+    if (lowValue->n_children) {
+        LOG_FATAL("left value is used (has children)");
+        ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        goto err_fatal;
     }
-    tracker_value_t *highValue = (tracker_value_t *)critnib_get(
-        provider->hTracker->map, (uintptr_t)highPtr);
+
+    tracker_alloc_info_t *highValue = get_most_nested_alloc_segment(
+        provider->hTracker, highPtr, &highLevel, NULL, NULL, &ref_highValue,
+        NULL, 0 /* no_children */);
     if (!highValue) {
-        LOG_ERR("no right value");
+        LOG_FATAL("no right value");
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err;
+        goto err_fatal;
+    }
+    if (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_fatal;
     }
     if (lowValue->pool != highValue->pool) {
-        LOG_ERR("pool mismatch");
+        LOG_FATAL("pool mismatch");
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err;
+        goto err_fatal;
     }
     if (lowValue->size + highValue->size != totalSize) {
-        LOG_ERR("lowValue->size + highValue->size != totalSize");
+        LOG_FATAL("lowValue->size + highValue->size != totalSize");
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err;
+        goto err_fatal;
     }
 
     ret = umfMemoryProviderAllocationMerge(provider->hUpstream, lowPtr, highPtr,
                                            totalSize);
     if (ret != UMF_RESULT_SUCCESS) {
-        LOG_ERR("upstream provider failed to merge regions");
-        goto err;
+        LOG_WARN("upstream provider failed to merge regions");
+        goto cannot_merge;
     }
 
-    // We'll have a duplicate entry for the range [highPtr, highValue->size] but this is fine,
-    // the value is the same anyway and we forbid removing that range concurrently
-    int cret = critnib_insert(provider->hTracker->map, (uintptr_t)lowPtr,
-                              (void *)mergedValue, 1 /* update */);
-    // this cannot fail since we know the element exists (nothing to allocate)
-    assert(cret == 0);
-    (void)cret;
+    // we only need to update the size of the first part
+    utils_atomic_store_release_u64((uint64_t *)&lowValue->size, totalSize);
 
-    // free old value that we just replaced with mergedValue
-    umf_ba_free(provider->hTracker->tracker_allocator, lowValue);
+    size_t low_children = lowValue->n_children;
+    size_t high_children = highValue->n_children;
 
-    void *erasedhighValue =
-        critnib_remove(provider->hTracker->map, (uintptr_t)highPtr);
-    assert(erasedhighValue == highValue);
+    critnib_release(provider->hTracker->alloc_segments_map[lowLevel],
+                    ref_lowValue);
+    critnib_release(provider->hTracker->alloc_segments_map[highLevel],
+                    ref_highValue);
 
-    umf_ba_free(provider->hTracker->tracker_allocator, erasedhighValue);
+    critnib_remove_release(provider->hTracker->alloc_segments_map[highLevel],
+                           (uintptr_t)highPtr);
 
-    util_mutex_unlock(&provider->hTracker->splitMergeMutex);
+    LOG_DEBUG("merged memory regions (level=%i): lowPtr=%p (child=%zu), "
+              "highPtr=%p (child=%zu), totalSize=%zu",
+              lowLevel, lowPtr, low_children, highPtr, high_children,
+              totalSize);
+
+    utils_mutex_unlock(&provider->hTracker->splitMergeMutex);
 
     return UMF_RESULT_SUCCESS;
 
-err:
-    util_mutex_unlock(&provider->hTracker->splitMergeMutex);
+err_fatal:
+    LOG_FATAL("failed to merge memory regions: lowPtr=%p (level=%i), "
+              "highPtr=%p (level=%i), totalSize=%zu",
+              lowPtr, lowLevel, highPtr, highLevel, totalSize);
+
+cannot_merge:
+    utils_mutex_unlock(&provider->hTracker->splitMergeMutex);
+
 err_lock:
-    umf_ba_free(provider->hTracker->tracker_allocator, mergedValue);
+    LOG_ERR("failed to merge memory regions: lowPtr=%p (level=%i), highPtr=%p "
+            "(level=%i), totalSize=%zu",
+            lowPtr, lowLevel, highPtr, highLevel, totalSize);
+
     return ret;
 }
 
 static umf_result_t trackingFree(void *hProvider, void *ptr, size_t size) {
     umf_result_t ret;
+    umf_result_t ret_remove = UMF_RESULT_ERROR_UNKNOWN;
     umf_tracking_memory_provider_t *p =
         (umf_tracking_memory_provider_t *)hProvider;
 
@@ -337,37 +873,46 @@ static umf_result_t trackingFree(void *hProvider, void *ptr, size_t size) {
     // could allocate the memory at address `ptr` before a call to umfMemoryTrackerRemove
     // resulting in inconsistent state.
     if (ptr) {
-        ret = umfMemoryTrackerRemove(p->hTracker, ptr);
-        if (ret != UMF_RESULT_SUCCESS) {
+        ret_remove = umfMemoryTrackerRemove(p->hTracker, ptr);
+        if (ret_remove != UMF_RESULT_SUCCESS) {
             // DO NOT return an error here, because the tracking provider
             // cannot change behaviour of the upstream provider.
             LOG_ERR("failed to remove the region from the tracker, ptr=%p, "
                     "size=%zu, ret = %d",
-                    ptr, size, ret);
+                    ptr, size, ret_remove);
         }
     }
 
-    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,
                                             cache_value->providerIpcData);
         if (ret != UMF_RESULT_SUCCESS) {
-            LOG_ERR("upstream provider is failed to put IPC handle, ptr=%p, "
+            LOG_ERR("upstream provider failed to put IPC handle, ptr=%p, "
                     "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);
     if (ret != UMF_RESULT_SUCCESS) {
-        LOG_ERR("upstream provider is failed to free the memory");
+        LOG_ERR("upstream provider failed to free the memory");
+        // Do not add memory back to the tracker,
+        // if it had not been removed.
+        if (ret_remove != UMF_RESULT_SUCCESS) {
+            return ret;
+        }
+
         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;
     }
@@ -375,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;
@@ -395,49 +940,64 @@ static umf_result_t trackingInitialize(void *params, void **ret) {
 #ifndef NDEBUG
 static void check_if_tracker_is_empty(umf_memory_tracker_handle_t hTracker,
                                       umf_memory_pool_handle_t pool) {
-    uintptr_t rkey;
-    void *rvalue;
     size_t n_items = 0;
-    uintptr_t last_key = 0;
 
-    while (1 == critnib_find((critnib *)hTracker->map, last_key, FIND_G, &rkey,
-                             &rvalue)) {
-        tracker_value_t *value = (tracker_value_t *)rvalue;
-        if (value->pool == pool || pool == NULL) {
-            n_items++;
-        }
+    for (int i = 0; i < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP; i++) {
+        uintptr_t last_key = 0;
+        uintptr_t rkey;
+        tracker_alloc_info_t *rvalue;
+        void *ref_value = NULL;
+
+        while (1 == critnib_find(hTracker->alloc_segments_map[i], last_key,
+                                 FIND_G, &rkey, (void **)&rvalue, &ref_value)) {
+            if (rvalue && ((rvalue->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;
+            last_key = rkey;
+        }
     }
 
     if (n_items) {
-        // Do not assert if we are running in the proxy library,
+        // Do not log the error if we are running in the proxy library,
         // because it may need those resources till
         // the very end of exiting the application.
-        if (!util_is_running_in_proxy_lib()) {
+        if (!utils_is_running_in_proxy_lib()) {
             if (pool) {
-                LOG_ERR("tracking provider of pool %p is not empty! "
-                        "(%zu items left)",
+                LOG_ERR("tracking provider of pool %p is not empty! (%zu items "
+                        "left)",
                         (void *)pool, n_items);
             } else {
-                LOG_ERR("tracking provider is not empty! (%zu items "
-                        "left)",
+                LOG_ERR("tracking provider is not empty! (%zu items left)",
                         n_items);
             }
+
+#ifdef UMF_DEVELOPER_MODE
+            assert(n_items == 0 && "tracking provider is not empty!");
+#endif
         }
     }
 }
 #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;
+
+    umfIpcOpenedCacheDestroy(p->hIpcMappedCache);
+
     critnib_delete(p->ipcCache);
-#ifndef NDEBUG
-    check_if_tracker_is_empty(p->hTracker, p->pool);
-#endif /* NDEBUG */
 
     umf_ba_global_free(provider);
+    return UMF_RESULT_SUCCESS;
 }
 
 static void trackingGetLastError(void *provider, const char **msg,
@@ -455,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;
@@ -486,6 +1046,11 @@ static umf_result_t trackingGetIpcHandleSize(void *provider, size_t *size) {
     return umfMemoryProviderGetIPCHandleSize(p->hUpstream, size);
 }
 
+static inline umf_ipc_data_t *getIpcDataFromIpcHandle(void *providerIpcData) {
+    return (umf_ipc_data_t *)((uint8_t *)providerIpcData -
+                              sizeof(umf_ipc_data_t));
+}
+
 static umf_result_t trackingGetIpcHandle(void *provider, const void *ptr,
                                          size_t size, void *providerIpcData) {
     umf_tracking_memory_provider_t *p =
@@ -493,47 +1058,45 @@ static umf_result_t trackingGetIpcHandle(void *provider, const void *ptr,
     umf_result_t ret = UMF_RESULT_SUCCESS;
     size_t ipcDataSize = 0;
     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
-            ipc_cache_value_t *cache_value = (ipc_cache_value_t *)value;
-            memcpy(providerIpcData, cache_value->providerIpcData,
-                   cache_value->ipcDataSize);
+            cache_value = (ipc_cache_value_t *)value;
             cached = 1;
-        } else {
-            ret = umfMemoryProviderGetIPCHandle(p->hUpstream, ptr, size,
-                                                providerIpcData);
-            if (ret != UMF_RESULT_SUCCESS) {
-                LOG_ERR("upstream provider is failed to get IPC handle");
-                return ret;
+        } 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 is failed to get the size of IPC "
+                LOG_ERR("upstream provider failed to get the size of IPC "
                         "handle");
-                ret = umfMemoryProviderPutIPCHandle(p->hUpstream,
-                                                    providerIpcData);
-                if (ret != UMF_RESULT_SUCCESS) {
-                    LOG_ERR("upstream provider is failed to put IPC handle");
-                }
                 return ret;
             }
 
             size_t value_size = sizeof(ipc_cache_value_t) + ipcDataSize;
-            ipc_cache_value_t *cache_value = umf_ba_global_alloc(value_size);
+            cache_value = umf_ba_global_alloc(value_size);
             if (!cache_value) {
                 LOG_ERR("failed to allocate cache_value");
-                ret = umfMemoryProviderPutIPCHandle(p->hUpstream,
-                                                    providerIpcData);
-                if (ret != UMF_RESULT_SUCCESS) {
-                    LOG_ERR("upstream provider is failed to put IPC handle");
-                }
                 return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
             }
 
+            ret = umfMemoryProviderGetIPCHandle(p->hUpstream, ptr, size,
+                                                cache_value->providerIpcData);
+            if (ret != UMF_RESULT_SUCCESS) {
+                LOG_ERR("upstream provider failed to get IPC handle");
+                umf_ba_global_free(cache_value);
+                return ret;
+            }
+
+            cache_value->handle_id = utils_atomic_increment_u64(&IPC_HANDLE_ID);
             cache_value->ipcDataSize = ipcDataSize;
-            memcpy(cache_value->providerIpcData, providerIpcData, ipcDataSize);
 
             int insRes = critnib_insert(p->ipcCache, (uintptr_t)ptr,
                                         (void *)cache_value, 0 /*update*/);
@@ -549,11 +1112,11 @@ static umf_result_t trackingGetIpcHandle(void *provider, const void *ptr,
                 //    But this case should be rare enough.
                 // 2. critnib failed to allocate memory internally. We need
                 //    to cleanup and return corresponding error.
+                ret = umfMemoryProviderPutIPCHandle(
+                    p->hUpstream, cache_value->providerIpcData);
                 umf_ba_global_free(cache_value);
-                ret = umfMemoryProviderPutIPCHandle(p->hUpstream,
-                                                    providerIpcData);
                 if (ret != UMF_RESULT_SUCCESS) {
-                    LOG_ERR("upstream provider is failed to put IPC handle");
+                    LOG_ERR("upstream provider failed to put IPC handle");
                     return ret;
                 }
                 if (insRes == ENOMEM) {
@@ -564,6 +1127,14 @@ static umf_result_t trackingGetIpcHandle(void *provider, const void *ptr,
         }
     } while (!cached);
 
+    memcpy(providerIpcData, cache_value->providerIpcData,
+           cache_value->ipcDataSize);
+    ipcUmfData->handle_id = cache_value->handle_id;
+
+    if (ref_value) {
+        critnib_release(p->ipcCache, ref_value);
+    }
+
     return ret;
 }
 
@@ -576,17 +1147,81 @@ static umf_result_t trackingPutIpcHandle(void *provider,
     return UMF_RESULT_SUCCESS;
 }
 
-static size_t getDataSizeFromIpcHandle(const void *providerIpcData) {
-    // This is hack to get size of memory pointed by IPC handle.
-    // tracking memory provider gets only provider-specific data
-    // pointed by providerIpcData, but the size of allocation tracked
-    // by umf_ipc_data_t. We use this trick to get pointer to
-    // umf_ipc_data_t data because the providerIpcData is
-    // the Flexible Array Member of umf_ipc_data_t.
-    const umf_ipc_data_t *ipcUmfData =
-        (const umf_ipc_data_t *)((const uint8_t *)providerIpcData -
-                                 sizeof(umf_ipc_data_t));
-    return ipcUmfData->baseSize;
+static void
+ipcOpenedCacheEvictionCallback(const ipc_opened_cache_key_t *key,
+                               const ipc_opened_cache_value_t *value) {
+    umf_tracking_memory_provider_t *p =
+        (umf_tracking_memory_provider_t *)key->local_provider;
+    // umfMemoryTrackerRemoveIpcSegment should be called before umfMemoryProviderCloseIPCHandle
+    // to avoid a race condition. If the order would be different, other thread
+    // could allocate the memory at address `ptr` before a call to umfMemoryTrackerRemoveIpcSegment
+    // resulting in inconsistent state.
+    if (value->mapped_base_ptr) {
+        umf_result_t ret = umfMemoryTrackerRemoveIpcSegment(
+            p->hTracker, value->mapped_base_ptr);
+        if (ret != UMF_RESULT_SUCCESS) {
+            // DO NOT return an error here, because the tracking provider
+            // cannot change behaviour of the upstream provider.
+            LOG_ERR("failed to remove the region from the IPC tracker, ptr=%p, "
+                    "size=%zu, ret = %d",
+                    value->mapped_base_ptr, value->mapped_size, ret);
+        }
+    }
+    umf_result_t ret = umfMemoryProviderCloseIPCHandle(
+        p->hUpstream, value->mapped_base_ptr, value->mapped_size);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("provider failed to close IPC handle, ptr=%p, size=%zu",
+                value->mapped_base_ptr, value->mapped_size);
+    }
+}
+
+static umf_result_t
+upstreamOpenIPCHandle(umf_tracking_memory_provider_t *p, void *providerIpcData,
+                      size_t bufferSize,
+                      ipc_opened_cache_value_t *cache_entry) {
+    void *mapped_ptr = NULL;
+    assert(p != NULL);
+    assert(cache_entry != NULL);
+    umf_result_t ret = umfMemoryProviderOpenIPCHandle(
+        p->hUpstream, providerIpcData, &mapped_ptr);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("upstream provider failed to open IPC handle");
+        return ret;
+    }
+    assert(mapped_ptr != NULL);
+
+    // Today umfMemoryTrackerAddIpcSegment requires the memory provider handle
+    // to know which tracking provider instance opened the IPC handle.
+    // The `p` points to the tracking provider private data.
+    // Because of that we get handle to the tracking provider instance
+    // using `p->pool->provider`.
+    //
+    // TODO:
+    // Today we always create a pool and get an IPC handler from the pool.
+    // And tracking provider is always created together with a pool.
+    // And the IPC handler is a tracking memory provider in fact.
+    // However, we are considering adding an API that allows IPC handler creation
+    // from scratch (without creating a memory pool). In that case, we will
+    // create a tracker provider without a pool. So p->pool might be NULL in the future.
+    ret = umfMemoryTrackerAddIpcSegment(p->hTracker, mapped_ptr, bufferSize,
+                                        p->pool->provider, cache_entry);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("failed to add IPC region to the tracker, ptr=%p, "
+                "size=%zu, "
+                "ret = %d",
+                mapped_ptr, bufferSize, ret);
+        if (umfMemoryProviderCloseIPCHandle(p->hUpstream, mapped_ptr,
+                                            bufferSize)) {
+            LOG_ERR("upstream provider failed to close IPC handle, "
+                    "ptr=%p, size=%zu",
+                    mapped_ptr, bufferSize);
+        }
+        return ret;
+    }
+
+    cache_entry->mapped_size = bufferSize;
+    utils_atomic_store_release_ptr(&(cache_entry->mapped_base_ptr), mapped_ptr);
+    return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t trackingOpenIpcHandle(void *provider, void *providerIpcData,
@@ -596,51 +1231,72 @@ static umf_result_t trackingOpenIpcHandle(void *provider, void *providerIpcData,
     umf_result_t ret = UMF_RESULT_SUCCESS;
 
     assert(p->hUpstream);
+    assert(p->hIpcMappedCache);
 
-    ret = umfMemoryProviderOpenIPCHandle(p->hUpstream, providerIpcData, ptr);
+    umf_ipc_data_t *ipcUmfData = getIpcDataFromIpcHandle(providerIpcData);
+
+    // Compiler may add paddings to the ipc_opened_cache_key_t structure
+    // so we need to zero it out to avoid false cache miss.
+    ipc_opened_cache_key_t key = {0};
+    key.remote_base_ptr = ipcUmfData->base;
+    key.local_provider = provider;
+    key.remote_pid = ipcUmfData->pid;
+
+    ipc_opened_cache_value_t *cache_entry = NULL;
+    ret = umfIpcOpenedCacheGet(p->hIpcMappedCache, &key, ipcUmfData->handle_id,
+                               &cache_entry);
     if (ret != UMF_RESULT_SUCCESS) {
-        LOG_ERR("upstream provider is failed to open IPC handle");
+        LOG_ERR("failed to get cache entry");
         return ret;
     }
-    size_t bufferSize = getDataSizeFromIpcHandle(providerIpcData);
-    ret = umfMemoryTrackerAdd(p->hTracker, p->pool, *ptr, bufferSize);
-    if (ret != UMF_RESULT_SUCCESS) {
-        LOG_ERR("failed to add IPC region to the tracker, ptr=%p, size=%zu, "
-                "ret = %d",
-                *ptr, bufferSize, ret);
-        if (umfMemoryProviderCloseIPCHandle(p->hUpstream, *ptr, bufferSize)) {
-            LOG_ERR("upstream provider is failed to close IPC handle, ptr=%p, "
-                    "size=%zu",
-                    *ptr, bufferSize);
+
+    assert(cache_entry != NULL);
+
+    void *mapped_ptr = NULL;
+    utils_atomic_load_acquire_ptr(&(cache_entry->mapped_base_ptr),
+                                  (void **)&mapped_ptr);
+    if (mapped_ptr == NULL) { // new cache entry
+        utils_mutex_lock(&(cache_entry->mmap_lock));
+        utils_atomic_load_acquire_ptr(&(cache_entry->mapped_base_ptr),
+                                      (void **)&mapped_ptr);
+        if (mapped_ptr == NULL) {
+            ret = upstreamOpenIPCHandle(p, providerIpcData,
+                                        ipcUmfData->baseSize, cache_entry);
         }
+        mapped_ptr = cache_entry->mapped_base_ptr;
+        utils_mutex_unlock(&(cache_entry->mmap_lock));
     }
+
+    if (ret == UMF_RESULT_SUCCESS) {
+        assert(mapped_ptr != NULL);
+        *ptr = mapped_ptr;
+    }
+
     return ret;
 }
 
 static umf_result_t trackingCloseIpcHandle(void *provider, void *ptr,
                                            size_t size) {
-    umf_tracking_memory_provider_t *p =
-        (umf_tracking_memory_provider_t *)provider;
-
-    // umfMemoryTrackerRemove should be called before umfMemoryProviderFree
-    // to avoid a race condition. If the order would be different, other thread
-    // could allocate the memory at address `ptr` before a call to umfMemoryTrackerRemove
-    // resulting in inconsistent state.
-    if (ptr) {
-        umf_result_t ret = umfMemoryTrackerRemove(p->hTracker, ptr);
-        if (ret != UMF_RESULT_SUCCESS) {
-            // DO NOT return an error here, because the tracking provider
-            // cannot change behaviour of the upstream provider.
-            LOG_ERR("failed to remove the region from the tracker, ptr=%p, "
-                    "size=%zu, ret = %d",
-                    ptr, size, ret);
-        }
+    (void)provider;
+    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 umfMemoryProviderCloseIPCHandle(p->hUpstream, ptr, size);
+
+    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 = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = trackingInitialize,
     .finalize = trackingFinalize,
     .alloc = trackingAlloc,
@@ -649,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,
@@ -671,16 +1334,20 @@ 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;
     }
 
+    params.hIpcMappedCache =
+        umfIpcOpenedCacheCreate(ipcOpenedCacheEvictionCallback);
+
     LOG_DEBUG("upstream=%p, tracker=%p, "
-              "pool=%p, ipcCache=%p",
+              "pool=%p, ipcCache=%p, hIpcMappedCache=%p",
               (void *)params.hUpstream, (void *)params.hTracker,
-              (void *)params.pool, (void *)params.ipcCache);
+              (void *)params.pool, (void *)params.ipcCache,
+              (void *)params.hIpcMappedCache);
 
     return umfMemoryProviderCreate(&UMF_TRACKING_MEMORY_PROVIDER_OPS, &params,
                                    hTrackingProvider);
@@ -695,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));
@@ -702,33 +1385,58 @@ umf_memory_tracker_handle_t umfMemoryTrackerCreate(void) {
         return NULL;
     }
 
-    umf_ba_pool_t *tracker_allocator =
-        umf_ba_create(sizeof(struct tracker_value_t));
-    if (!tracker_allocator) {
+    memset(handle, 0, sizeof(struct umf_memory_tracker_t));
+
+    umf_ba_pool_t *alloc_info_allocator =
+        umf_ba_create(sizeof(struct tracker_alloc_info_t));
+    if (!alloc_info_allocator) {
         goto err_free_handle;
     }
 
-    handle->tracker_allocator = tracker_allocator;
+    handle->alloc_info_allocator = alloc_info_allocator;
 
-    void *mutex_ptr = util_mutex_init(&handle->splitMergeMutex);
+    void *mutex_ptr = utils_mutex_init(&handle->splitMergeMutex);
     if (!mutex_ptr) {
-        goto err_destroy_tracker_allocator;
+        goto err_destroy_alloc_info_allocator;
     }
 
-    handle->map = critnib_new();
-    if (!handle->map) {
-        goto err_destroy_mutex;
+    int i;
+    for (i = 0; i < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP; i++) {
+        handle->alloc_segments_map[i] =
+            critnib_new(free_leaf, alloc_info_allocator);
+        if (!handle->alloc_segments_map[i]) {
+            goto err_destroy_alloc_segments_map;
+        }
+    }
+
+    handle->ipc_info_allocator =
+        umf_ba_create(sizeof(struct tracker_ipc_info_t));
+    if (!handle->ipc_info_allocator) {
+        goto err_destroy_alloc_segments_map;
+    }
+
+    handle->ipc_segments_map =
+        critnib_new(free_ipc_segment, handle->ipc_info_allocator);
+    if (!handle->ipc_segments_map) {
+        goto err_destroy_ipc_info_allocator;
     }
 
-    LOG_DEBUG("tracker created, handle=%p, segment map=%p", (void *)handle,
-              (void *)handle->map);
+    LOG_DEBUG("tracker created, handle=%p, alloc_segments_map=%p",
+              (void *)handle, (void *)handle->alloc_segments_map);
 
     return handle;
 
-err_destroy_mutex:
-    util_mutex_destroy_not_free(&handle->splitMergeMutex);
-err_destroy_tracker_allocator:
-    umf_ba_destroy(tracker_allocator);
+err_destroy_ipc_info_allocator:
+    umf_ba_destroy(handle->ipc_info_allocator);
+err_destroy_alloc_segments_map:
+    for (i = 0; i < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP; i++) {
+        if (handle->alloc_segments_map[i]) {
+            critnib_delete(handle->alloc_segments_map[i]);
+        }
+    }
+    utils_mutex_destroy_not_free(&handle->splitMergeMutex);
+err_destroy_alloc_info_allocator:
+    umf_ba_destroy(alloc_info_allocator);
 err_free_handle:
     umf_ba_global_free(handle);
     return NULL;
@@ -739,10 +1447,10 @@ void umfMemoryTrackerDestroy(umf_memory_tracker_handle_t handle) {
         return;
     }
 
-    // Do not destroy if we are running in the proxy library,
+    // Do not destroy the tracker if we are running in the proxy library,
     // because it may need those resources till
     // the very end of exiting the application.
-    if (util_is_running_in_proxy_lib()) {
+    if (utils_is_running_in_proxy_lib()) {
         return;
     }
 
@@ -753,10 +1461,18 @@ void umfMemoryTrackerDestroy(umf_memory_tracker_handle_t handle) {
     // We have to zero all inner pointers,
     // because the tracker handle can be copied
     // and used in many places.
-    critnib_delete(handle->map);
-    handle->map = NULL;
-    util_mutex_destroy_not_free(&handle->splitMergeMutex);
-    umf_ba_destroy(handle->tracker_allocator);
-    handle->tracker_allocator = NULL;
+    for (int i = 0; i < MAX_LEVELS_OF_ALLOC_SEGMENT_MAP; i++) {
+        if (handle->alloc_segments_map[i]) {
+            critnib_delete(handle->alloc_segments_map[i]);
+            handle->alloc_segments_map[i] = NULL;
+        }
+    }
+    utils_mutex_destroy_not_free(&handle->splitMergeMutex);
+    umf_ba_destroy(handle->alloc_info_allocator);
+    handle->alloc_info_allocator = NULL;
+    critnib_delete(handle->ipc_segments_map);
+    handle->ipc_segments_map = NULL;
+    umf_ba_destroy(handle->ipc_info_allocator);
+    handle->ipc_info_allocator = NULL;
     umf_ba_global_free(handle);
 }
diff --git a/src/provider/provider_tracking.h b/src/provider/provider_tracking.h
index 585b4fe5c..842449be5 100644
--- a/src/provider/provider_tracking.h
+++ b/src/provider/provider_tracking.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -11,6 +11,7 @@
 #define UMF_MEMORY_TRACKER_INTERNAL_H 1
 
 #include <assert.h>
+#include <stdbool.h>
 #include <stdlib.h>
 
 #include <umf/base.h>
@@ -25,12 +26,7 @@
 extern "C" {
 #endif
 
-struct umf_memory_tracker_t {
-    umf_ba_pool_t *tracker_allocator;
-    critnib *map;
-    os_mutex_t splitMergeMutex;
-};
-
+struct umf_memory_tracker_t;
 typedef struct umf_memory_tracker_t *umf_memory_tracker_handle_t;
 
 extern umf_memory_tracker_handle_t TRACKER;
@@ -49,6 +45,15 @@ typedef struct umf_alloc_info_t {
 umf_result_t umfMemoryTrackerGetAllocInfo(const void *ptr,
                                           umf_alloc_info_t *pAllocInfo);
 
+typedef struct umf_ipc_info_t {
+    void *base;
+    size_t baseSize;
+    umf_memory_provider_handle_t provider;
+} umf_ipc_info_t;
+
+umf_result_t umfMemoryTrackerGetIpcInfo(const void *ptr,
+                                        umf_ipc_info_t *pIpcInfo);
+
 // Creates a memory provider that tracks each allocation/deallocation through umf_memory_tracker_handle_t and
 // forwards all requests to hUpstream memory Provider. hUpstream lifetime should be managed by the user of this function.
 umf_result_t umfTrackingMemoryProviderCreate(
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/proxy_lib/proxy_lib.c b/src/proxy_lib/proxy_lib.c
index 6c3ffa272..ccb60f8ab 100644
--- a/src/proxy_lib/proxy_lib.c
+++ b/src/proxy_lib/proxy_lib.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -27,6 +27,12 @@
  * - _aligned_offset_recalloc()
  */
 
+#ifndef _WIN32
+#define _GNU_SOURCE // for RTLD_NEXT
+#include <dlfcn.h>
+#undef _GNU_SOURCE
+#endif /* _WIN32 */
+
 #if (defined PROXY_LIB_USES_JEMALLOC_POOL)
 #include <umf/pools/pool_jemalloc.h>
 #define umfPoolManagerOps umfJemallocPoolOps
@@ -38,6 +44,7 @@
 #endif
 
 #include <assert.h>
+#include <limits.h>
 #include <stdio.h>
 
 #include <umf/memory_pool.h>
@@ -47,6 +54,7 @@
 #include "base_alloc_linear.h"
 #include "proxy_lib.h"
 #include "utils_common.h"
+#include "utils_load_library.h"
 #include "utils_log.h"
 
 #ifdef _WIN32 /* Windows ***************************************/
@@ -58,7 +66,7 @@
 #define UTIL_ONCE_FLAG INIT_ONCE
 #define UTIL_ONCE_FLAG_INIT INIT_ONCE_STATIC_INIT
 
-void util_init_once(UTIL_ONCE_FLAG *flag, void (*onceCb)(void));
+void utils_init_once(UTIL_ONCE_FLAG *flag, void (*onceCb)(void));
 
 #else /* Linux *************************************************/
 
@@ -93,6 +101,24 @@ void util_init_once(UTIL_ONCE_FLAG *flag, void (*onceCb)(void));
  * of a UMF pool to allocate memory needed by an application. It should be freed
  * by an application.
  */
+#ifndef _WIN32
+typedef void *(*system_aligned_alloc_t)(size_t alignment, size_t size);
+typedef void *(*system_calloc_t)(size_t nmemb, size_t size);
+typedef void (*system_free_t)(void *ptr);
+typedef void *(*system_malloc_t)(size_t size);
+typedef size_t (*system_malloc_usable_size_t)(void *ptr);
+typedef void *(*system_realloc_t)(void *ptr, size_t size);
+
+// pointers to the default system allocator's API
+static system_aligned_alloc_t System_aligned_alloc;
+static system_calloc_t System_calloc;
+static system_free_t System_free;
+static system_malloc_t System_malloc;
+static system_malloc_usable_size_t System_malloc_usable_size;
+static system_realloc_t System_realloc;
+
+static size_t Size_threshold_value = 0;
+#endif /* _WIN32 */
 
 static UTIL_ONCE_FLAG Base_alloc_leak_initialized = UTIL_ONCE_FLAG_INIT;
 static umf_ba_linear_pool_t *Base_alloc_leak = NULL;
@@ -106,63 +132,131 @@ static __TLS int was_called_from_umfPool = 0;
 /*** The constructor and destructor of the proxy library *********************/
 /*****************************************************************************/
 
+#ifndef _WIN32
+static size_t get_size_threshold(void) {
+    char *str_threshold = utils_env_var_get_str("UMF_PROXY", "size.threshold=");
+    LOG_DEBUG("UMF_PROXY[size.threshold] = %s", str_threshold);
+    long threshold = utils_get_size_threshold(str_threshold);
+    if (threshold < 0) {
+        LOG_FATAL("incorrect size threshold: %s", str_threshold);
+        exit(-1);
+    }
+
+    return (size_t)threshold;
+}
+
+static int get_system_allocator_symbols(void) {
+    *((void **)(&System_aligned_alloc)) =
+        utils_get_symbol_addr(RTLD_NEXT, "aligned_alloc", NULL);
+    *((void **)(&System_calloc)) =
+        utils_get_symbol_addr(RTLD_NEXT, "calloc", NULL);
+    *((void **)(&System_free)) = utils_get_symbol_addr(RTLD_NEXT, "free", NULL);
+    *((void **)(&System_malloc)) =
+        utils_get_symbol_addr(RTLD_NEXT, "malloc", NULL);
+    *((void **)(&System_malloc_usable_size)) =
+        utils_get_symbol_addr(RTLD_NEXT, "malloc_usable_size", NULL);
+    *((void **)(&System_realloc)) =
+        utils_get_symbol_addr(RTLD_NEXT, "realloc", NULL);
+
+    if (System_aligned_alloc && System_calloc && System_free && System_malloc &&
+        System_malloc_usable_size && System_realloc) {
+        return 0;
+    }
+
+    LOG_FATAL("Required system allocator's symbols not found.");
+
+    return -1;
+}
+#endif /* _WIN32 */
+
 void proxy_lib_create_common(void) {
-    util_log_init();
-    umf_os_memory_provider_params_t os_params =
-        umfOsMemoryProviderParamsDefault();
+    utils_log_init();
+    umf_os_memory_provider_params_handle_t os_params = NULL;
     umf_result_t umf_result;
 
+    umf_result = umfOsMemoryProviderParamsCreate(&os_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        LOG_FATAL("creating OS memory provider params failed");
+        exit(-1);
+    }
+
 #ifndef _WIN32
-#define NAME_MAX 255
-    char shm_name[NAME_MAX];
+    size_t _threshold = get_size_threshold();
+    if (_threshold > 0) {
+        if (get_system_allocator_symbols()) {
+            LOG_FATAL("initialization of the system allocator failed!");
+            exit(-1);
+        }
 
-    if (util_env_var_has_str("UMF_PROXY", "page.disposition=shared-fd")) {
-        LOG_DEBUG("proxy_lib: using the MAP_SHARED visibility mode with the "
-                  "file descriptor duplication");
-        os_params.visibility = UMF_MEM_MAP_SHARED;
-        os_params.shm_name = NULL;
+        Size_threshold_value = _threshold;
+        LOG_INFO("system allocator initialized, size threshold value = %zu",
+                 Size_threshold_value);
+    }
 
-    } else if (util_env_var_has_str("UMF_PROXY",
-                                    "page.disposition=shared-shm")) {
-        LOG_DEBUG("proxy_lib: using the MAP_SHARED visibility mode with the "
-                  "named shared memory");
-        os_params.visibility = UMF_MEM_MAP_SHARED;
+    if (utils_env_var_has_str("UMF_PROXY", "page.disposition=shared-fd")) {
+        LOG_INFO("proxy_lib: using the MAP_SHARED visibility mode with the "
+                 "file descriptor duplication");
+        umf_result = umfOsMemoryProviderParamsSetVisibility(os_params,
+                                                            UMF_MEM_MAP_SHARED);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            LOG_FATAL("setting visibility mode failed");
+            exit(-1);
+        }
+        umf_result = umfOsMemoryProviderParamsSetShmName(os_params, NULL);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            LOG_FATAL("setting shared memory name failed");
+            exit(-1);
+        }
+    } else if (utils_env_var_has_str("UMF_PROXY",
+                                     "page.disposition=shared-shm")) {
+        umf_result = umfOsMemoryProviderParamsSetVisibility(os_params,
+                                                            UMF_MEM_MAP_SHARED);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            LOG_FATAL("setting visibility mode failed");
+            exit(-1);
+        }
 
+        char shm_name[NAME_MAX];
         memset(shm_name, 0, NAME_MAX);
         sprintf(shm_name, "umf_proxy_lib_shm_pid_%i", utils_getpid());
-        os_params.shm_name = shm_name;
+        umf_result = umfOsMemoryProviderParamsSetShmName(os_params, shm_name);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            LOG_FATAL("setting shared memory name failed");
+            exit(-1);
+        }
 
-        LOG_DEBUG("proxy_lib: using the MAP_SHARED visibility mode with the "
-                  "named shared memory: %s",
-                  os_params.shm_name);
+        LOG_INFO("proxy_lib: using the MAP_SHARED visibility mode with the "
+                 "named shared memory: %s",
+                 shm_name);
     }
-#undef NAME_MAX
-#endif
+#endif /* _WIN32 */
 
-    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(), &os_params,
+    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(), os_params,
                                          &OS_memory_provider);
+    umfOsMemoryProviderParamsDestroy(os_params);
     if (umf_result != UMF_RESULT_SUCCESS) {
-        LOG_ERR("creating OS memory provider failed");
+        LOG_FATAL("creating OS memory provider failed");
         exit(-1);
     }
 
-    umf_result =
-        umfPoolCreate(umfPoolManagerOps(), OS_memory_provider, NULL,
-                      UMF_POOL_CREATE_FLAG_DISABLE_TRACKING, &Proxy_pool);
+    umf_result = umfPoolCreate(umfPoolManagerOps(), OS_memory_provider, NULL, 0,
+                               &Proxy_pool);
     if (umf_result != UMF_RESULT_SUCCESS) {
-        LOG_ERR("creating UMF pool manager failed");
+        LOG_FATAL("creating UMF pool manager failed");
         exit(-1);
     }
+
     // The UMF pool has just been created (Proxy_pool != NULL). Stop using
     // the linear allocator and start using the UMF pool allocator from now on.
+    LOG_DEBUG("proxy library initialized");
 }
 
 void proxy_lib_destroy_common(void) {
-    if (util_is_running_in_proxy_lib()) {
+    if (utils_is_running_in_proxy_lib()) {
         // We cannot destroy 'Base_alloc_leak' nor 'Proxy_pool' nor 'OS_memory_provider',
         // because it could lead to use-after-free in the program's unloader
         // (for example _dl_fini() on Linux).
-        return;
+        goto fini_proxy_lib_destroy_common;
     }
 
     umf_memory_pool_handle_t pool = Proxy_pool;
@@ -172,6 +266,10 @@ void proxy_lib_destroy_common(void) {
     umf_memory_provider_handle_t provider = OS_memory_provider;
     OS_memory_provider = NULL;
     umfMemoryProviderDestroy(provider);
+    LOG_DEBUG("proxy library destroyed");
+
+fini_proxy_lib_destroy_common:
+    LOG_DEBUG("proxy library finalized");
 }
 
 /*****************************************************************************/
@@ -205,23 +303,31 @@ static inline void *ba_generic_realloc(umf_ba_linear_pool_t *pool, void *ptr,
 /*** The "LEAK" linear base allocator functions ******************************/
 /*****************************************************************************/
 
-static void ba_leak_create(void) { Base_alloc_leak = umf_ba_linear_create(0); }
+static void ba_leak_create(void) {
+    Base_alloc_leak = umf_ba_linear_create(4 * 1024 * 1024);
+}
 
 // it does not implement destroy(), because we cannot destroy non-freed memory
 
 static void ba_leak_init_once(void) {
-    util_init_once(&Base_alloc_leak_initialized, ba_leak_create);
+    utils_init_once(&Base_alloc_leak_initialized, ba_leak_create);
 }
 
-static inline void *ba_leak_malloc(size_t size) {
+static inline void *ba_leak_aligned_alloc(size_t alignment, size_t size) {
     ba_leak_init_once();
-    return umf_ba_linear_alloc(Base_alloc_leak, size);
+    void *ptr = umf_ba_linear_alloc(Base_alloc_leak, size + alignment);
+    return (void *)ALIGN_UP_SAFE((uintptr_t)ptr, alignment);
+}
+
+static inline void *ba_leak_malloc(size_t size) {
+    return ba_leak_aligned_alloc(0, size);
 }
 
 static inline void *ba_leak_calloc(size_t nmemb, size_t size) {
     ba_leak_init_once();
     // umf_ba_linear_alloc() returns zeroed memory
-    return umf_ba_linear_alloc(Base_alloc_leak, nmemb * size);
+    // so ba_leak_aligned_alloc() does too
+    return ba_leak_aligned_alloc(0, nmemb * size);
 }
 
 static inline void *ba_leak_realloc(void *ptr, size_t size, size_t max_size) {
@@ -229,12 +335,6 @@ static inline void *ba_leak_realloc(void *ptr, size_t size, size_t max_size) {
     return ba_generic_realloc(Base_alloc_leak, ptr, size, max_size);
 }
 
-static inline void *ba_leak_aligned_alloc(size_t alignment, size_t size) {
-    ba_leak_init_once();
-    void *ptr = umf_ba_linear_alloc(Base_alloc_leak, size + alignment);
-    return (void *)ALIGN_UP((uintptr_t)ptr, alignment);
-}
-
 static inline int ba_leak_free(void *ptr) {
     ba_leak_init_once();
     return umf_ba_linear_free(Base_alloc_leak, ptr);
@@ -250,6 +350,12 @@ static inline size_t ba_leak_pool_contains_pointer(void *ptr) {
 /*****************************************************************************/
 
 void *malloc(size_t size) {
+#ifndef _WIN32
+    if (size < Size_threshold_value) {
+        return System_malloc(size);
+    }
+#endif /* _WIN32 */
+
     if (!was_called_from_umfPool && Proxy_pool) {
         was_called_from_umfPool = 1;
         void *ptr = umfPoolMalloc(Proxy_pool, size);
@@ -261,6 +367,12 @@ void *malloc(size_t size) {
 }
 
 void *calloc(size_t nmemb, size_t size) {
+#ifndef _WIN32
+    if ((nmemb * size) < Size_threshold_value) {
+        return System_calloc(nmemb, size);
+    }
+#endif /* _WIN32 */
+
     if (!was_called_from_umfPool && Proxy_pool) {
         was_called_from_umfPool = 1;
         void *ptr = umfPoolCalloc(Proxy_pool, nmemb, size);
@@ -280,15 +392,22 @@ void free(void *ptr) {
         return;
     }
 
-    if (Proxy_pool) {
+    if (Proxy_pool && (umfPoolByPtr(ptr) == Proxy_pool)) {
         if (umfPoolFree(Proxy_pool, ptr) != UMF_RESULT_SUCCESS) {
             LOG_ERR("umfPoolFree() failed");
-            assert(0);
         }
         return;
     }
 
-    assert(0);
+#ifndef _WIN32
+    if (Size_threshold_value) {
+        System_free(ptr);
+        return;
+    }
+#endif /* _WIN32 */
+
+    LOG_ERR("free() failed: %p", ptr);
+
     return;
 }
 
@@ -307,18 +426,31 @@ void *realloc(void *ptr, size_t size) {
         return ba_leak_realloc(ptr, size, leak_pool_contains_pointer);
     }
 
-    if (Proxy_pool) {
+    if (Proxy_pool && (umfPoolByPtr(ptr) == Proxy_pool)) {
         was_called_from_umfPool = 1;
         void *new_ptr = umfPoolRealloc(Proxy_pool, ptr, size);
         was_called_from_umfPool = 0;
         return new_ptr;
     }
 
-    assert(0);
+#ifndef _WIN32
+    if (Size_threshold_value) {
+        return System_realloc(ptr, size);
+    }
+#endif /* _WIN32 */
+
+    LOG_ERR("realloc() failed: %p", ptr);
+
     return NULL;
 }
 
 void *aligned_alloc(size_t alignment, size_t size) {
+#ifndef _WIN32
+    if (size < Size_threshold_value) {
+        return System_aligned_alloc(alignment, size);
+    }
+#endif /* _WIN32 */
+
     if (!was_called_from_umfPool && Proxy_pool) {
         was_called_from_umfPool = 1;
         void *ptr = umfPoolAlignedMalloc(Proxy_pool, size, alignment);
@@ -334,19 +466,30 @@ size_t _msize(void *ptr) {
 #else
 size_t malloc_usable_size(void *ptr) {
 #endif
-
-    // a check to verify we are running the proxy library
+    // a check to verify if we are running the proxy library
     if (ptr == (void *)0x01) {
         return 0xDEADBEEF;
     }
 
-    if (!was_called_from_umfPool && Proxy_pool) {
+    if (ba_leak_pool_contains_pointer(ptr)) {
+        return 0; // unsupported in case of the ba_leak allocator
+    }
+
+    if (Proxy_pool && (umfPoolByPtr(ptr) == Proxy_pool)) {
         was_called_from_umfPool = 1;
         size_t size = umfPoolMallocUsableSize(Proxy_pool, ptr);
         was_called_from_umfPool = 0;
         return size;
     }
 
+#ifndef _WIN32
+    if (Size_threshold_value) {
+        return System_malloc_usable_size(ptr);
+    }
+#endif /* _WIN32 */
+
+    LOG_ERR("malloc_usable_size() failed: %p", ptr);
+
     return 0; // unsupported in this case
 }
 
diff --git a/src/proxy_lib/proxy_lib.def b/src/proxy_lib/proxy_lib.def
index f30b40556..82b666b6a 100644
--- a/src/proxy_lib/proxy_lib.def
+++ b/src/proxy_lib/proxy_lib.def
@@ -5,6 +5,7 @@
 ;;;;  End Copyright Notice
 
 LIBRARY UMF_PROXY
+
 EXPORTS
 	DllMain
 	aligned_alloc
diff --git a/src/proxy_lib/proxy_lib.map b/src/proxy_lib/proxy_lib.map
index 5d93d03ba..93ae001e6 100644
--- a/src/proxy_lib/proxy_lib.map
+++ b/src/proxy_lib/proxy_lib.map
@@ -2,8 +2,8 @@
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-# linker VERSION script
-
+# These functions are meant to be in unnamed scope. They are also not named
+# with any umf prefix, as they should override functions with the same name.
 {
     global:
         aligned_alloc;
diff --git a/src/proxy_lib/proxy_lib.rc.in b/src/proxy_lib/proxy_lib.rc.in
index dce151ec3..a3eff71de 100644
--- a/src/proxy_lib/proxy_lib.rc.in
+++ b/src/proxy_lib/proxy_lib.rc.in
@@ -1,4 +1,4 @@
-// Copyright (c) 2024 Intel Corporation
+// Copyright (C) 2024-2025 Intel Corporation
 //
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -10,6 +10,8 @@
 
 #define UMF_VERNUMBERS @PROJECT_VERSION_MAJOR@,@PROJECT_VERSION_MINOR@,@PROJECT_VERSION_PATCH@,@UMF_VERSION_REVISION@
 #define _UMF_VERSION "@UMF_VERSION@"
+// Store our CMake vars in the "FileDescription" block, as the custom fields require special parsing.
+#define _UMF_CMAKE_VARS "@UMF_ALL_CMAKE_VARIABLES@"
 
 #ifdef _DEBUG
 #define VERSION_DEBUG VS_FF_DEBUG
@@ -49,9 +51,9 @@ BEGIN
         BLOCK "040904b0" // U.S. English, Unicode (0x04b0 == 1200)
         BEGIN
             VALUE "CompanyName", "Intel Corporation\0"
-            VALUE "FileDescription", "Unified Memory Framework (UMF) proxy library\0"
+            VALUE "FileDescription", "Unified Memory Framework (UMF) proxy library (build options: " _UMF_CMAKE_VARS ")\0"
             VALUE "FileVersion", _UMF_VERSION "\0"
-            VALUE "LegalCopyright", "Copyright 2024, Intel Corporation. All rights reserved.\0"
+            VALUE "LegalCopyright", "Copyright 2024-2025, Intel Corporation. All rights reserved.\0"
             VALUE "LegalTrademarks", "\0"
             VALUE "OriginalFilename", "umf_proxy.dll\0"
             VALUE "ProductName", "Unified Memory Framework (UMF)\0"
diff --git a/src/ravl/ravl.c b/src/ravl/ravl.c
new file mode 100644
index 000000000..dd6c17b03
--- /dev/null
+++ b/src/ravl/ravl.c
@@ -0,0 +1,557 @@
+/*
+ *
+ * Copyright (C) 2018-2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+/*
+ * ravl.c -- implementation of a RAVL tree
+ * https://sidsen.azurewebsites.net//papers/ravl-trees-journal.pdf
+ */
+
+#include "ravl.h"
+#include "../src/utils/utils_common.h"
+#include "../src/utils/utils_concurrency.h"
+#include "assert.h"
+#include "base_alloc_global.h"
+
+#include <errno.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define RAVL_DEFAULT_DATA_SIZE (sizeof(void *))
+
+enum ravl_slot_type {
+    RAVL_LEFT,
+    RAVL_RIGHT,
+
+    MAX_SLOTS,
+
+    RAVL_ROOT
+};
+
+struct ravl_node {
+    struct ravl_node *parent;
+    struct ravl_node *slots[MAX_SLOTS];
+    int32_t rank; /* cannot be greater than height of the subtree */
+    int32_t pointer_based;
+    char data[];
+};
+
+struct ravl {
+    struct ravl_node *root;
+    ravl_compare *compare;
+    size_t data_size;
+};
+
+/*
+ * ravl_new -- creates a new ravl tree instance
+ */
+struct ravl *ravl_new_sized(ravl_compare *compare, size_t data_size) {
+    struct ravl *r = umf_ba_global_alloc(sizeof(*r));
+    if (r == NULL) {
+        return NULL;
+    }
+
+    r->compare = compare;
+    r->root = NULL;
+    r->data_size = data_size;
+
+    return r;
+}
+
+/*
+ * ravl_new -- creates a new tree that stores data pointers
+ */
+struct ravl *ravl_new(ravl_compare *compare) {
+    return ravl_new_sized(compare, RAVL_DEFAULT_DATA_SIZE);
+}
+
+/*
+ * ravl_clear_node -- (internal) recursively clears the given subtree,
+ *	calls callback in an in-order fashion. Optionally frees the given node.
+ */
+static void ravl_foreach_node(struct ravl_node *n, ravl_cb cb, void *arg,
+                              int free_node) {
+    if (n == NULL) {
+        return;
+    }
+
+    ravl_foreach_node(n->slots[RAVL_LEFT], cb, arg, free_node);
+    if (cb) {
+        cb((void *)n->data, arg);
+    }
+    ravl_foreach_node(n->slots[RAVL_RIGHT], cb, arg, free_node);
+
+    if (free_node) {
+        umf_ba_global_free(n);
+    }
+}
+
+/*
+ * ravl_clear -- clears the entire tree, starting from the root
+ */
+void ravl_clear(struct ravl *ravl) {
+    ravl_foreach_node(ravl->root, NULL, NULL, 1);
+    ravl->root = NULL;
+}
+
+/*
+ * ravl_delete_cb -- clears and deletes the given ravl instance, calls callback
+ */
+void ravl_delete_cb(struct ravl *ravl, ravl_cb cb, void *arg) {
+    ravl_foreach_node(ravl->root, cb, arg, 1);
+    umf_ba_global_free(ravl);
+}
+
+/*
+ * ravl_delete -- clears and deletes the given ravl instance
+ */
+void ravl_delete(struct ravl *ravl) { ravl_delete_cb(ravl, NULL, NULL); }
+
+/*
+ * ravl_foreach -- traverses the entire tree, calling callback for every node
+ */
+void ravl_foreach(struct ravl *ravl, ravl_cb cb, void *arg) {
+    ravl_foreach_node(ravl->root, cb, arg, 0);
+}
+
+/*
+ * ravl_empty -- checks whether the given tree is empty
+ */
+int ravl_empty(struct ravl *ravl) { return ravl->root == NULL; }
+
+/*
+ * ravl_node_insert_constructor -- node data constructor for ravl_insert
+ */
+static void ravl_node_insert_constructor(void *data, size_t data_size,
+                                         const void *arg) {
+    /* suppress unused-parameter errors */
+    (void)data_size;
+
+    /* copy only the 'arg' pointer */
+    memcpy(data, &arg, sizeof(arg));
+}
+
+/*
+ * ravl_node_copy_constructor -- node data constructor for ravl_emplace_copy
+ */
+static void ravl_node_copy_constructor(void *data, size_t data_size,
+                                       const void *arg) {
+    memcpy(data, arg, data_size);
+}
+
+/*
+ * ravl_new_node -- (internal) allocates and initializes a new node
+ */
+static struct ravl_node *ravl_new_node(struct ravl *ravl, ravl_constr constr,
+                                       const void *arg) {
+    struct ravl_node *n = umf_ba_global_alloc(sizeof(*n) + ravl->data_size);
+    if (n == NULL) {
+        return NULL;
+    }
+
+    n->parent = NULL;
+    n->slots[RAVL_LEFT] = NULL;
+    n->slots[RAVL_RIGHT] = NULL;
+    n->rank = 0;
+    n->pointer_based = constr == ravl_node_insert_constructor;
+    constr(n->data, ravl->data_size, arg);
+
+    return n;
+}
+
+/*
+ * ravl_slot_opposite -- (internal) returns the opposite slot type, cannot be
+ *	called for root type
+ */
+static enum ravl_slot_type ravl_slot_opposite(enum ravl_slot_type t) {
+    assert(t != RAVL_ROOT);
+
+    return t == RAVL_LEFT ? RAVL_RIGHT : RAVL_LEFT;
+}
+
+/*
+ * ravl_node_slot_type -- (internal) returns the type of the given node:
+ *	left child, right child or root
+ */
+static enum ravl_slot_type ravl_node_slot_type(struct ravl_node *n) {
+    if (n->parent == NULL) {
+        return RAVL_ROOT;
+    }
+
+    return n->parent->slots[RAVL_LEFT] == n ? RAVL_LEFT : RAVL_RIGHT;
+}
+
+/*
+ * ravl_node_sibling -- (internal) returns the sibling of the given node,
+ *	NULL if the node is root (has no parent)
+ */
+static struct ravl_node *ravl_node_sibling(struct ravl_node *n) {
+    enum ravl_slot_type t = ravl_node_slot_type(n);
+    if (t == RAVL_ROOT) {
+        return NULL;
+    }
+
+    return n->parent->slots[t == RAVL_LEFT ? RAVL_RIGHT : RAVL_LEFT];
+}
+
+/*
+ * ravl_node_ref -- (internal) returns the pointer to the memory location in
+ *	which the given node resides
+ */
+static struct ravl_node **ravl_node_ref(struct ravl *ravl,
+                                        struct ravl_node *n) {
+    enum ravl_slot_type t = ravl_node_slot_type(n);
+
+    return t == RAVL_ROOT ? &ravl->root : &n->parent->slots[t];
+}
+
+/*
+ * ravl_rotate -- (internal) performs a rotation around a given node
+ *
+ * The node n swaps place with its parent. If n is right child, parent becomes
+ * the left child of n, otherwise parent becomes right child of n.
+ */
+static void ravl_rotate(struct ravl *ravl, struct ravl_node *n) {
+    assert(n->parent != NULL);
+    struct ravl_node *p = n->parent;
+    struct ravl_node **pref = ravl_node_ref(ravl, p);
+
+    enum ravl_slot_type t = ravl_node_slot_type(n);
+    enum ravl_slot_type t_opposite = ravl_slot_opposite(t);
+
+    n->parent = p->parent;
+    p->parent = n;
+    *pref = n;
+
+    if ((p->slots[t] = n->slots[t_opposite]) != NULL) {
+        p->slots[t]->parent = p;
+    }
+    n->slots[t_opposite] = p;
+}
+
+/*
+ * ravl_node_rank -- (internal) returns the rank of the node
+ *
+ * For the purpose of balancing, NULL nodes have rank -1.
+ */
+static int ravl_node_rank(struct ravl_node *n) {
+    return n == NULL ? -1 : n->rank;
+}
+
+/*
+ * ravl_node_rank_difference_parent -- (internal) returns the rank different
+ *	between parent node p and its child n
+ *
+ * Every rank difference must be positive.
+ *
+ * Either of these can be NULL.
+ */
+static int ravl_node_rank_difference_parent(struct ravl_node *p,
+                                            struct ravl_node *n) {
+    int rv = ravl_node_rank(p) - ravl_node_rank(n);
+    // assert to check integer overflow
+    // ravl_node_rank(x) is >= -1
+    assert(rv <= ravl_node_rank(p) + 1);
+    return rv;
+}
+
+/*
+ * ravl_node_rank_difference - (internal) returns the rank difference between
+ *	parent and its child
+ *
+ * Can be used to check if a given node is an i-child.
+ */
+static int ravl_node_rank_difference(struct ravl_node *n) {
+    return ravl_node_rank_difference_parent(n->parent, n);
+}
+
+/*
+ * ravl_node_is_i_j -- (internal) checks if a given node is strictly i,j-node
+ */
+static int ravl_node_is_i_j(struct ravl_node *n, int i, int j) {
+    return (ravl_node_rank_difference_parent(n, n->slots[RAVL_LEFT]) == i &&
+            ravl_node_rank_difference_parent(n, n->slots[RAVL_RIGHT]) == j);
+}
+
+/*
+ * ravl_node_is -- (internal) checks if a given node is i,j-node or j,i-node
+ */
+static int ravl_node_is(struct ravl_node *n, int i, int j) {
+    return ravl_node_is_i_j(n, i, j) || ravl_node_is_i_j(n, j, i);
+}
+
+/*
+ * ravl_node_promote -- promotes a given node by increasing its rank
+ */
+static void ravl_node_promote(struct ravl_node *n) { n->rank += 1; }
+
+/*
+ * ravl_node_promote -- demotes a given node by increasing its rank
+ */
+static void ravl_node_demote(struct ravl_node *n) {
+    assert(n->rank > 0);
+    n->rank -= 1;
+}
+
+/*
+ * ravl_balance -- balances the tree after insert
+ *
+ * This function must restore the invariant that every rank
+ * difference is positive.
+ */
+static void ravl_balance(struct ravl *ravl, struct ravl_node *n) {
+    /* walk up the tree, promoting nodes */
+    while (n->parent && ravl_node_is(n->parent, 0, 1)) {
+        ravl_node_promote(n->parent);
+        n = n->parent;
+    }
+
+    /*
+	 * Either the rank rule holds or n is a 0-child whose sibling is an
+	 * i-child with i > 1.
+	 */
+    struct ravl_node *s = ravl_node_sibling(n);
+    if (!(ravl_node_rank_difference(n) == 0 &&
+          ravl_node_rank_difference_parent(n->parent, s) > 1)) {
+        return;
+    }
+
+    struct ravl_node *y = n->parent;
+    /* if n is a left child, let z be n's right child and vice versa */
+    enum ravl_slot_type t = ravl_slot_opposite(ravl_node_slot_type(n));
+    struct ravl_node *z = n->slots[t];
+
+    if (z == NULL || ravl_node_rank_difference(z) == 2) {
+        ravl_rotate(ravl, n);
+        ravl_node_demote(y);
+    } else if (ravl_node_rank_difference(z) == 1) {
+        ravl_rotate(ravl, z);
+        ravl_rotate(ravl, z);
+        ravl_node_promote(z);
+        ravl_node_demote(n);
+        assert(y != NULL);
+        ravl_node_demote(y);
+    }
+}
+
+/*
+ * ravl_insert -- insert data into the tree
+ */
+int ravl_insert(struct ravl *ravl, const void *data) {
+    return ravl_emplace(ravl, ravl_node_insert_constructor, data);
+}
+
+/*
+ * ravl_insert -- copy construct data inside of a new tree node
+ */
+int ravl_emplace_copy(struct ravl *ravl, const void *data) {
+    return ravl_emplace(ravl, ravl_node_copy_constructor, data);
+}
+
+/*
+ * ravl_emplace -- construct data inside of a new tree node
+ */
+int ravl_emplace(struct ravl *ravl, ravl_constr constr, const void *arg) {
+    struct ravl_node *n = ravl_new_node(ravl, constr, arg);
+    if (n == NULL) {
+        return -1;
+    }
+
+    /* walk down the tree and insert the new node into a missing slot */
+    struct ravl_node **dstp = &ravl->root;
+    struct ravl_node *dst = NULL;
+    while (*dstp != NULL) {
+        dst = (*dstp);
+        int cmp_result = ravl->compare(ravl_data(n), ravl_data(dst));
+        if (cmp_result == 0) {
+            goto error_duplicate;
+        }
+
+        dstp = &dst->slots[cmp_result > 0];
+    }
+    n->parent = dst;
+    *dstp = n;
+
+    ravl_balance(ravl, n);
+
+    return 0;
+
+error_duplicate:
+    errno = EEXIST;
+    umf_ba_global_free(n);
+    return -1;
+}
+
+/*
+ * ravl_node_type_most -- (internal) returns left-most or right-most node in
+ *	the subtree
+ */
+static struct ravl_node *ravl_node_type_most(struct ravl_node *n,
+                                             enum ravl_slot_type t) {
+    while (n->slots[t] != NULL) {
+        n = n->slots[t];
+    }
+
+    return n;
+}
+
+/*
+ * ravl_node_cessor -- (internal) returns the successor or predecessor of the
+ *	node
+ */
+static struct ravl_node *ravl_node_cessor(struct ravl_node *n,
+                                          enum ravl_slot_type t) {
+    /*
+	 * If t child is present, we are looking for t-opposite-most node
+	 * in t child subtree
+	 */
+    if (n->slots[t]) {
+        return ravl_node_type_most(n->slots[t], ravl_slot_opposite(t));
+    }
+
+    /* otherwise get the first parent on the t path */
+    while (n->parent != NULL && n == n->parent->slots[t]) {
+        n = n->parent;
+    }
+
+    return n->parent;
+}
+
+/*
+ * ravl_node_successor -- returns node's successor
+ *
+ * It's the first node larger than n.
+ */
+struct ravl_node *ravl_node_successor(struct ravl_node *n) {
+    return ravl_node_cessor(n, RAVL_RIGHT);
+}
+
+/*
+ * ravl_node_predecessor -- returns node's successor
+ *
+ * It's the first node smaller than n.
+ */
+struct ravl_node *ravl_node_predecessor(struct ravl_node *n) {
+    return ravl_node_cessor(n, RAVL_LEFT);
+}
+
+/*
+ * ravl_predicate_holds -- (internal) verifies the given predicate for
+ *	the current node in the search path
+ *
+ * If the predicate holds for the given node or a node that can be directly
+ * derived from it, returns 1. Otherwise returns 0.
+ */
+static int ravl_predicate_holds(int result, struct ravl_node **ret,
+                                struct ravl_node *n,
+                                enum ravl_predicate flags) {
+    if (flags & RAVL_PREDICATE_EQUAL) {
+        if (result == 0) {
+            *ret = n;
+            return 1;
+        }
+    }
+    if (flags & RAVL_PREDICATE_GREATER) {
+        if (result < 0) { /* data < n->data */
+            *ret = n;
+            return 0;
+        } else if (result == 0) {
+            *ret = ravl_node_successor(n);
+            return 1;
+        }
+    }
+    if (flags & RAVL_PREDICATE_LESS) {
+        if (result > 0) { /* data > n->data */
+            *ret = n;
+            return 0;
+        } else if (result == 0) {
+            *ret = ravl_node_predecessor(n);
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+/*
+ * ravl_find -- searches for the node in the tree
+ */
+struct ravl_node *ravl_find(struct ravl *ravl, const void *data,
+                            enum ravl_predicate flags) {
+    struct ravl_node *r = NULL;
+    struct ravl_node *n = ravl->root;
+    while (n) {
+        int result = ravl->compare(data, ravl_data(n));
+        if (ravl_predicate_holds(result, &r, n, flags)) {
+            return r;
+        }
+
+        n = n->slots[result > 0];
+    }
+
+    return r;
+}
+
+/*
+ * ravl_remove -- removes the given node from the tree
+ */
+void ravl_remove(struct ravl *ravl, struct ravl_node *n) {
+    if (n->slots[RAVL_LEFT] != NULL && n->slots[RAVL_RIGHT] != NULL) {
+        /* if both children are present, remove the successor instead */
+        struct ravl_node *s = ravl_node_successor(n);
+        memcpy(n->data, s->data, ravl->data_size);
+
+        ravl_remove(ravl, s);
+    } else {
+        /* swap n with the child that may exist */
+        struct ravl_node *r =
+            n->slots[RAVL_LEFT] ? n->slots[RAVL_LEFT] : n->slots[RAVL_RIGHT];
+        if (r != NULL) {
+            r->parent = n->parent;
+        }
+
+        *ravl_node_ref(ravl, n) = r;
+        umf_ba_global_free(n);
+    }
+}
+
+/*
+ * ravl_data -- returns the data contained within the node
+ */
+void *ravl_data(struct ravl_node *node) {
+    if (node->pointer_based) {
+        void *data;
+        memcpy(&data, node->data, sizeof(void *));
+        return data;
+    } else {
+        return (void *)node->data;
+    }
+}
+
+/*
+ * ravl_first -- returns first (left-most) node in the tree
+ */
+struct ravl_node *ravl_first(struct ravl *ravl) {
+    if (ravl->root) {
+        return ravl_node_type_most(ravl->root, RAVL_LEFT);
+    }
+
+    return NULL;
+}
+
+/*
+ * ravl_last -- returns last (right-most) node in the tree
+ */
+struct ravl_node *ravl_last(struct ravl *ravl) {
+    if (ravl->root) {
+        return ravl_node_type_most(ravl->root, RAVL_RIGHT);
+    }
+
+    return NULL;
+}
diff --git a/src/ravl/ravl.h b/src/ravl/ravl.h
new file mode 100644
index 000000000..ae84d5a56
--- /dev/null
+++ b/src/ravl/ravl.h
@@ -0,0 +1,63 @@
+/*
+ *
+ * Copyright (C) 2018-2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+/*
+ * ravl.h -- internal definitions for ravl tree
+ */
+
+#ifndef UMF_RAVL_H
+#define UMF_RAVL_H 1
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct ravl;
+struct ravl_node;
+
+enum ravl_predicate {
+    RAVL_PREDICATE_EQUAL = 1 << 0,
+    RAVL_PREDICATE_GREATER = 1 << 1,
+    RAVL_PREDICATE_LESS = 1 << 2,
+    RAVL_PREDICATE_LESS_EQUAL = RAVL_PREDICATE_EQUAL | RAVL_PREDICATE_LESS,
+    RAVL_PREDICATE_GREATER_EQUAL =
+        RAVL_PREDICATE_EQUAL | RAVL_PREDICATE_GREATER,
+};
+
+typedef int ravl_compare(const void *lhs, const void *rhs);
+typedef void ravl_cb(void *data, void *arg);
+typedef void ravl_constr(void *data, size_t data_size, const void *arg);
+
+struct ravl *ravl_new(ravl_compare *compare);
+struct ravl *ravl_new_sized(ravl_compare *compare, size_t data_size);
+void ravl_delete(struct ravl *ravl);
+void ravl_delete_cb(struct ravl *ravl, ravl_cb cb, void *arg);
+void ravl_foreach(struct ravl *ravl, ravl_cb cb, void *arg);
+int ravl_empty(struct ravl *ravl);
+void ravl_clear(struct ravl *ravl);
+int ravl_insert(struct ravl *ravl, const void *data);
+int ravl_emplace(struct ravl *ravl, ravl_constr constr, const void *arg);
+int ravl_emplace_copy(struct ravl *ravl, const void *data);
+
+struct ravl_node *ravl_find(struct ravl *ravl, const void *data,
+                            enum ravl_predicate predicate_flags);
+struct ravl_node *ravl_first(struct ravl *ravl);
+struct ravl_node *ravl_last(struct ravl *ravl);
+void *ravl_data(struct ravl_node *node);
+void ravl_remove(struct ravl *ravl, struct ravl_node *node);
+struct ravl_node *ravl_node_successor(struct ravl_node *n);
+struct ravl_node *ravl_node_predecessor(struct ravl_node *n);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_RAVL_H */
diff --git a/src/topology.c b/src/topology.c
index 79caffdb6..eab7992ce 100644
--- a/src/topology.c
+++ b/src/topology.c
@@ -41,6 +41,6 @@ static void umfCreateTopology(void) {
 }
 
 hwloc_topology_t umfGetTopology(void) {
-    util_init_once(&topology_initialized, umfCreateTopology);
+    utils_init_once(&topology_initialized, umfCreateTopology);
     return topology;
 }
diff --git a/src/uthash/uthash.h b/src/uthash/uthash.h
new file mode 100644
index 000000000..6058e638e
--- /dev/null
+++ b/src/uthash/uthash.h
@@ -0,0 +1,1261 @@
+/*
+Copyright (C) 2024 Intel Corporation
+Copyright (c) 2003-2022, Troy D. Hanson  https://troydhanson.github.io/uthash/
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+Modifications by Intel:
+- define uthash_malloc unconditional as a umf_ba_global_alloc
+- define uthash_free unconditional as a umf_ba_global_free
+*/
+
+#ifndef UTHASH_H
+#define UTHASH_H
+
+#define UTHASH_VERSION 2.3.0
+
+#include <stddef.h> /* ptrdiff_t */
+#include <stdlib.h> /* exit */
+#include <string.h> /* memcmp, memset, strlen */
+
+#include "base_alloc_global.h"
+
+#if defined(HASH_DEFINE_OWN_STDINT) && HASH_DEFINE_OWN_STDINT
+/* This codepath is provided for backward compatibility, but I plan to remove it. */
+#warning                                                                       \
+    "HASH_DEFINE_OWN_STDINT is deprecated; please use HASH_NO_STDINT instead"
+typedef unsigned int uint32_t;
+typedef unsigned char uint8_t;
+#elif defined(HASH_NO_STDINT) && HASH_NO_STDINT
+#else
+#include <stdint.h> /* uint8_t, uint32_t */
+#endif
+
+/* These macros use decltype or the earlier __typeof GNU extension.
+   As decltype is only available in newer compilers (VS2010 or gcc 4.3+
+   when compiling c++ source) this code uses whatever method is needed
+   or, for VS2008 where neither is available, uses casting workarounds. */
+#if !defined(DECLTYPE) && !defined(NO_DECLTYPE)
+#if defined(_MSC_VER)                        /* MS compiler */
+#if _MSC_VER >= 1600 && defined(__cplusplus) /* VS2010 or newer in C++ mode */
+#define DECLTYPE(x) (decltype(x))
+#else /* VS2008 or older (or VS2010 in C mode) */
+#define NO_DECLTYPE
+#endif
+#elif defined(__MCST__) /* Elbrus C Compiler */
+#define DECLTYPE(x) (__typeof(x))
+#elif defined(__BORLANDC__) || defined(__ICCARM__) || defined(__LCC__) ||      \
+    defined(__WATCOMC__)
+#define NO_DECLTYPE
+#else /* GNU, Sun and other compilers */
+#define DECLTYPE(x) (__typeof(x))
+#endif
+#endif
+
+#ifdef NO_DECLTYPE
+#define DECLTYPE(x)
+#define DECLTYPE_ASSIGN(dst, src)                                              \
+    do {                                                                       \
+        char **_da_dst = (char **)(&(dst));                                    \
+        *_da_dst = (char *)(src);                                              \
+    } while (0)
+#else
+#define DECLTYPE_ASSIGN(dst, src)                                              \
+    do {                                                                       \
+        (dst) = DECLTYPE(dst)(src);                                            \
+    } while (0)
+#endif
+
+#define uthash_malloc(sz) umf_ba_global_alloc(sz)    /* malloc fcn */
+#define uthash_free(ptr, sz) umf_ba_global_free(ptr) /* free fcn */
+
+#ifndef uthash_bzero
+#define uthash_bzero(a, n) memset(a, '\0', n)
+#endif
+#ifndef uthash_strlen
+#define uthash_strlen(s) strlen(s)
+#endif
+
+#ifndef HASH_FUNCTION
+#define HASH_FUNCTION(keyptr, keylen, hashv) HASH_JEN(keyptr, keylen, hashv)
+#endif
+
+#ifndef HASH_KEYCMP
+#define HASH_KEYCMP(a, b, n) memcmp(a, b, n)
+#endif
+
+#ifndef uthash_noexpand_fyi
+#define uthash_noexpand_fyi(tbl) /* can be defined to log noexpand  */
+#endif
+#ifndef uthash_expand_fyi
+#define uthash_expand_fyi(tbl) /* can be defined to log expands   */
+#endif
+
+#ifndef HASH_NONFATAL_OOM
+#define HASH_NONFATAL_OOM 0
+#endif
+
+#if HASH_NONFATAL_OOM
+/* malloc failures can be recovered from */
+
+#ifndef uthash_nonfatal_oom
+#define uthash_nonfatal_oom(obj)                                               \
+    do {                                                                       \
+    } while (0) /* non-fatal OOM error */
+#endif
+
+#define HASH_RECORD_OOM(oomed)                                                 \
+    do {                                                                       \
+        (oomed) = 1;                                                           \
+    } while (0)
+#define IF_HASH_NONFATAL_OOM(x) x
+
+#else
+/* malloc failures result in lost memory, hash tables are unusable */
+
+#ifndef uthash_fatal
+#define uthash_fatal(msg) exit(-1) /* fatal OOM error */
+#endif
+
+#define HASH_RECORD_OOM(oomed) uthash_fatal("out of memory")
+#define IF_HASH_NONFATAL_OOM(x)
+
+#endif
+
+/* initial number of buckets */
+#define HASH_INITIAL_NUM_BUCKETS 32U     /* initial number of buckets        */
+#define HASH_INITIAL_NUM_BUCKETS_LOG2 5U /* lg2 of initial number of buckets */
+#define HASH_BKT_CAPACITY_THRESH 10U     /* expand when bucket count reaches */
+
+/* calculate the element whose hash handle address is hhp */
+#define ELMT_FROM_HH(tbl, hhp) ((void *)(((char *)(hhp)) - ((tbl)->hho)))
+/* calculate the hash handle from element address elp */
+#define HH_FROM_ELMT(tbl, elp)                                                 \
+    ((UT_hash_handle *)(void *)(((char *)(elp)) + ((tbl)->hho)))
+
+#define HASH_ROLLBACK_BKT(hh, head, itemptrhh)                                 \
+    do {                                                                       \
+        struct UT_hash_handle *_hd_hh_item = (itemptrhh);                      \
+        unsigned _hd_bkt;                                                      \
+        HASH_TO_BKT(_hd_hh_item->hashv, (head)->hh.tbl->num_buckets, _hd_bkt); \
+        (head)->hh.tbl->buckets[_hd_bkt].count++;                              \
+        _hd_hh_item->hh_next = NULL;                                           \
+        _hd_hh_item->hh_prev = NULL;                                           \
+    } while (0)
+
+#define HASH_VALUE(keyptr, keylen, hashv)                                      \
+    do {                                                                       \
+        HASH_FUNCTION(keyptr, keylen, hashv);                                  \
+    } while (0)
+
+#define HASH_FIND_BYHASHVALUE(hh, head, keyptr, keylen, hashval, out)          \
+    do {                                                                       \
+        (out) = NULL;                                                          \
+        if (head) {                                                            \
+            unsigned _hf_bkt;                                                  \
+            HASH_TO_BKT(hashval, (head)->hh.tbl->num_buckets, _hf_bkt);        \
+            if (HASH_BLOOM_TEST((head)->hh.tbl, hashval)) {                    \
+                HASH_FIND_IN_BKT((head)->hh.tbl, hh,                           \
+                                 (head)->hh.tbl->buckets[_hf_bkt], keyptr,     \
+                                 keylen, hashval, out);                        \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+#define HASH_FIND(hh, head, keyptr, keylen, out)                               \
+    do {                                                                       \
+        (out) = NULL;                                                          \
+        if (head) {                                                            \
+            unsigned _hf_hashv;                                                \
+            HASH_VALUE(keyptr, keylen, _hf_hashv);                             \
+            HASH_FIND_BYHASHVALUE(hh, head, keyptr, keylen, _hf_hashv, out);   \
+        }                                                                      \
+    } while (0)
+
+#ifdef HASH_BLOOM
+#define HASH_BLOOM_BITLEN (1UL << HASH_BLOOM)
+#define HASH_BLOOM_BYTELEN                                                     \
+    (HASH_BLOOM_BITLEN / 8UL) + (((HASH_BLOOM_BITLEN % 8UL) != 0UL) ? 1UL : 0UL)
+#define HASH_BLOOM_MAKE(tbl, oomed)                                            \
+    do {                                                                       \
+        (tbl)->bloom_nbits = HASH_BLOOM;                                       \
+        (tbl)->bloom_bv = (uint8_t *)uthash_malloc(HASH_BLOOM_BYTELEN);        \
+        if (!(tbl)->bloom_bv) {                                                \
+            HASH_RECORD_OOM(oomed);                                            \
+        } else {                                                               \
+            uthash_bzero((tbl)->bloom_bv, HASH_BLOOM_BYTELEN);                 \
+            (tbl)->bloom_sig = HASH_BLOOM_SIGNATURE;                           \
+        }                                                                      \
+    } while (0)
+
+#define HASH_BLOOM_FREE(tbl)                                                   \
+    do {                                                                       \
+        uthash_free((tbl)->bloom_bv, HASH_BLOOM_BYTELEN);                      \
+    } while (0)
+
+#define HASH_BLOOM_BITSET(bv, idx) (bv[(idx) / 8U] |= (1U << ((idx) % 8U)))
+#define HASH_BLOOM_BITTEST(bv, idx)                                            \
+    ((bv[(idx) / 8U] & (1U << ((idx) % 8U))) != 0)
+
+#define HASH_BLOOM_ADD(tbl, hashv)                                             \
+    HASH_BLOOM_BITSET(                                                         \
+        (tbl)->bloom_bv,                                                       \
+        ((hashv) & (uint32_t)((1UL << (tbl)->bloom_nbits) - 1U)))
+
+#define HASH_BLOOM_TEST(tbl, hashv)                                            \
+    HASH_BLOOM_BITTEST(                                                        \
+        (tbl)->bloom_bv,                                                       \
+        ((hashv) & (uint32_t)((1UL << (tbl)->bloom_nbits) - 1U)))
+
+#else
+#define HASH_BLOOM_MAKE(tbl, oomed)
+#define HASH_BLOOM_FREE(tbl)
+#define HASH_BLOOM_ADD(tbl, hashv)
+#define HASH_BLOOM_TEST(tbl, hashv) 1
+#define HASH_BLOOM_BYTELEN 0U
+#endif
+
+#define HASH_MAKE_TABLE(hh, head, oomed)                                       \
+    do {                                                                       \
+        (head)->hh.tbl =                                                       \
+            (UT_hash_table *)uthash_malloc(sizeof(UT_hash_table));             \
+        if (!(head)->hh.tbl) {                                                 \
+            HASH_RECORD_OOM(oomed);                                            \
+        } else {                                                               \
+            uthash_bzero((head)->hh.tbl, sizeof(UT_hash_table));               \
+            (head)->hh.tbl->tail = &((head)->hh);                              \
+            (head)->hh.tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;            \
+            (head)->hh.tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;  \
+            (head)->hh.tbl->hho = (char *)(&(head)->hh) - (char *)(head);      \
+            (head)->hh.tbl->buckets = (UT_hash_bucket *)uthash_malloc(         \
+                HASH_INITIAL_NUM_BUCKETS * sizeof(struct UT_hash_bucket));     \
+            (head)->hh.tbl->signature = HASH_SIGNATURE;                        \
+            if (!(head)->hh.tbl->buckets) {                                    \
+                HASH_RECORD_OOM(oomed);                                        \
+                uthash_free((head)->hh.tbl, sizeof(UT_hash_table));            \
+            } else {                                                           \
+                uthash_bzero((head)->hh.tbl->buckets,                          \
+                             HASH_INITIAL_NUM_BUCKETS *                        \
+                                 sizeof(struct UT_hash_bucket));               \
+                HASH_BLOOM_MAKE((head)->hh.tbl, oomed);                        \
+                IF_HASH_NONFATAL_OOM(if (oomed) {                              \
+                    uthash_free((head)->hh.tbl->buckets,                       \
+                                HASH_INITIAL_NUM_BUCKETS *                     \
+                                    sizeof(struct UT_hash_bucket));            \
+                    uthash_free((head)->hh.tbl, sizeof(UT_hash_table));        \
+                })                                                             \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+#define HASH_REPLACE_BYHASHVALUE_INORDER(hh, head, fieldname, keylen_in,       \
+                                         hashval, add, replaced, cmpfcn)       \
+    do {                                                                       \
+        (replaced) = NULL;                                                     \
+        HASH_FIND_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in,        \
+                              hashval, replaced);                              \
+        if (replaced) {                                                        \
+            HASH_DELETE(hh, head, replaced);                                   \
+        }                                                                      \
+        HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh, head, &((add)->fieldname),     \
+                                            keylen_in, hashval, add, cmpfcn);  \
+    } while (0)
+
+#define HASH_REPLACE_BYHASHVALUE(hh, head, fieldname, keylen_in, hashval, add, \
+                                 replaced)                                     \
+    do {                                                                       \
+        (replaced) = NULL;                                                     \
+        HASH_FIND_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in,        \
+                              hashval, replaced);                              \
+        if (replaced) {                                                        \
+            HASH_DELETE(hh, head, replaced);                                   \
+        }                                                                      \
+        HASH_ADD_KEYPTR_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in,  \
+                                    hashval, add);                             \
+    } while (0)
+
+#define HASH_REPLACE(hh, head, fieldname, keylen_in, add, replaced)            \
+    do {                                                                       \
+        unsigned _hr_hashv;                                                    \
+        HASH_VALUE(&((add)->fieldname), keylen_in, _hr_hashv);                 \
+        HASH_REPLACE_BYHASHVALUE(hh, head, fieldname, keylen_in, _hr_hashv,    \
+                                 add, replaced);                               \
+    } while (0)
+
+#define HASH_REPLACE_INORDER(hh, head, fieldname, keylen_in, add, replaced,    \
+                             cmpfcn)                                           \
+    do {                                                                       \
+        unsigned _hr_hashv;                                                    \
+        HASH_VALUE(&((add)->fieldname), keylen_in, _hr_hashv);                 \
+        HASH_REPLACE_BYHASHVALUE_INORDER(hh, head, fieldname, keylen_in,       \
+                                         _hr_hashv, add, replaced, cmpfcn);    \
+    } while (0)
+
+#define HASH_APPEND_LIST(hh, head, add)                                        \
+    do {                                                                       \
+        (add)->hh.next = NULL;                                                 \
+        (add)->hh.prev = ELMT_FROM_HH((head)->hh.tbl, (head)->hh.tbl->tail);   \
+        (head)->hh.tbl->tail->next = (add);                                    \
+        (head)->hh.tbl->tail = &((add)->hh);                                   \
+    } while (0)
+
+#define HASH_AKBI_INNER_LOOP(hh, head, add, cmpfcn)                            \
+    do {                                                                       \
+        do {                                                                   \
+            if (cmpfcn(DECLTYPE(head)(_hs_iter), add) > 0) {                   \
+                break;                                                         \
+            }                                                                  \
+        } while ((_hs_iter = HH_FROM_ELMT((head)->hh.tbl, _hs_iter)->next));   \
+    } while (0)
+
+#ifdef NO_DECLTYPE
+#undef HASH_AKBI_INNER_LOOP
+#define HASH_AKBI_INNER_LOOP(hh, head, add, cmpfcn)                            \
+    do {                                                                       \
+        char *_hs_saved_head = (char *)(head);                                 \
+        do {                                                                   \
+            DECLTYPE_ASSIGN(head, _hs_iter);                                   \
+            if (cmpfcn(head, add) > 0) {                                       \
+                DECLTYPE_ASSIGN(head, _hs_saved_head);                         \
+                break;                                                         \
+            }                                                                  \
+            DECLTYPE_ASSIGN(head, _hs_saved_head);                             \
+        } while ((_hs_iter = HH_FROM_ELMT((head)->hh.tbl, _hs_iter)->next));   \
+    } while (0)
+#endif
+
+#if HASH_NONFATAL_OOM
+
+#define HASH_ADD_TO_TABLE(hh, head, keyptr, keylen_in, hashval, add, oomed)    \
+    do {                                                                       \
+        if (!(oomed)) {                                                        \
+            unsigned _ha_bkt;                                                  \
+            (head)->hh.tbl->num_items++;                                       \
+            HASH_TO_BKT(hashval, (head)->hh.tbl->num_buckets, _ha_bkt);        \
+            HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt], hh, &(add)->hh,  \
+                            oomed);                                            \
+            if (oomed) {                                                       \
+                HASH_ROLLBACK_BKT(hh, head, &(add)->hh);                       \
+                HASH_DELETE_HH(hh, head, &(add)->hh);                          \
+                (add)->hh.tbl = NULL;                                          \
+                uthash_nonfatal_oom(add);                                      \
+            } else {                                                           \
+                HASH_BLOOM_ADD((head)->hh.tbl, hashval);                       \
+                HASH_EMIT_KEY(hh, head, keyptr, keylen_in);                    \
+            }                                                                  \
+        } else {                                                               \
+            (add)->hh.tbl = NULL;                                              \
+            uthash_nonfatal_oom(add);                                          \
+        }                                                                      \
+    } while (0)
+
+#else
+
+#define HASH_ADD_TO_TABLE(hh, head, keyptr, keylen_in, hashval, add, oomed)    \
+    do {                                                                       \
+        unsigned _ha_bkt;                                                      \
+        (head)->hh.tbl->num_items++;                                           \
+        HASH_TO_BKT(hashval, (head)->hh.tbl->num_buckets, _ha_bkt);            \
+        HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt], hh, &(add)->hh,      \
+                        oomed);                                                \
+        HASH_BLOOM_ADD((head)->hh.tbl, hashval);                               \
+        HASH_EMIT_KEY(hh, head, keyptr, keylen_in);                            \
+    } while (0)
+
+#endif
+
+#define HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh, head, keyptr, keylen_in,       \
+                                            hashval, add, cmpfcn)              \
+    do {                                                                       \
+        IF_HASH_NONFATAL_OOM(int _ha_oomed = 0;)                               \
+        (add)->hh.hashv = (hashval);                                           \
+        (add)->hh.key = (char *)(keyptr);                                      \
+        (add)->hh.keylen = (unsigned)(keylen_in);                              \
+        if (!(head)) {                                                         \
+            (add)->hh.next = NULL;                                             \
+            (add)->hh.prev = NULL;                                             \
+            HASH_MAKE_TABLE(hh, add, _ha_oomed);                               \
+            IF_HASH_NONFATAL_OOM(if (!_ha_oomed) { )                                    \
+      (head) = (add);                                                          \
+    IF_HASH_NONFATAL_OOM(                                                      \
+            })                                                                 \
+        } else {                                                               \
+            void *_hs_iter = (head);                                           \
+            (add)->hh.tbl = (head)->hh.tbl;                                    \
+            HASH_AKBI_INNER_LOOP(hh, head, add, cmpfcn);                       \
+            if (_hs_iter) {                                                    \
+                (add)->hh.next = _hs_iter;                                     \
+                if (((add)->hh.prev =                                          \
+                         HH_FROM_ELMT((head)->hh.tbl, _hs_iter)->prev)) {      \
+                    HH_FROM_ELMT((head)->hh.tbl, (add)->hh.prev)->next =       \
+                        (add);                                                 \
+                } else {                                                       \
+                    (head) = (add);                                            \
+                }                                                              \
+                HH_FROM_ELMT((head)->hh.tbl, _hs_iter)->prev = (add);          \
+            } else {                                                           \
+                HASH_APPEND_LIST(hh, head, add);                               \
+            }                                                                  \
+        }                                                                      \
+        HASH_ADD_TO_TABLE(hh, head, keyptr, keylen_in, hashval, add,           \
+                          _ha_oomed);                                          \
+        HASH_FSCK(hh, head, "HASH_ADD_KEYPTR_BYHASHVALUE_INORDER");            \
+    } while (0)
+
+#define HASH_ADD_KEYPTR_INORDER(hh, head, keyptr, keylen_in, add, cmpfcn)      \
+    do {                                                                       \
+        unsigned _hs_hashv;                                                    \
+        HASH_VALUE(keyptr, keylen_in, _hs_hashv);                              \
+        HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh, head, keyptr, keylen_in,       \
+                                            _hs_hashv, add, cmpfcn);           \
+    } while (0)
+
+#define HASH_ADD_BYHASHVALUE_INORDER(hh, head, fieldname, keylen_in, hashval,  \
+                                     add, cmpfcn)                              \
+    HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh, head, &((add)->fieldname),         \
+                                        keylen_in, hashval, add, cmpfcn)
+
+#define HASH_ADD_INORDER(hh, head, fieldname, keylen_in, add, cmpfcn)          \
+    HASH_ADD_KEYPTR_INORDER(hh, head, &((add)->fieldname), keylen_in, add,     \
+                            cmpfcn)
+
+#define HASH_ADD_KEYPTR_BYHASHVALUE(hh, head, keyptr, keylen_in, hashval, add) \
+    do {                                                                       \
+        IF_HASH_NONFATAL_OOM(int _ha_oomed = 0;)                               \
+        (add)->hh.hashv = (hashval);                                           \
+        (add)->hh.key = (const void *)(keyptr);                                \
+        (add)->hh.keylen = (unsigned)(keylen_in);                              \
+        if (!(head)) {                                                         \
+            (add)->hh.next = NULL;                                             \
+            (add)->hh.prev = NULL;                                             \
+            HASH_MAKE_TABLE(hh, add, _ha_oomed);                               \
+            IF_HASH_NONFATAL_OOM(if (!_ha_oomed) { )                                    \
+      (head) = (add);                                                          \
+    IF_HASH_NONFATAL_OOM(                                                      \
+            })                                                                 \
+        } else {                                                               \
+            (add)->hh.tbl = (head)->hh.tbl;                                    \
+            HASH_APPEND_LIST(hh, head, add);                                   \
+        }                                                                      \
+        HASH_ADD_TO_TABLE(hh, head, keyptr, keylen_in, hashval, add,           \
+                          _ha_oomed);                                          \
+        HASH_FSCK(hh, head, "HASH_ADD_KEYPTR_BYHASHVALUE");                    \
+    } while (0)
+
+#define HASH_ADD_KEYPTR(hh, head, keyptr, keylen_in, add)                      \
+    do {                                                                       \
+        unsigned _ha_hashv;                                                    \
+        HASH_VALUE(keyptr, keylen_in, _ha_hashv);                              \
+        HASH_ADD_KEYPTR_BYHASHVALUE(hh, head, keyptr, keylen_in, _ha_hashv,    \
+                                    add);                                      \
+    } while (0)
+
+#define HASH_ADD_BYHASHVALUE(hh, head, fieldname, keylen_in, hashval, add)     \
+    HASH_ADD_KEYPTR_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in,      \
+                                hashval, add)
+
+#define HASH_ADD(hh, head, fieldname, keylen_in, add)                          \
+    HASH_ADD_KEYPTR(hh, head, &((add)->fieldname), keylen_in, add)
+
+#define HASH_TO_BKT(hashv, num_bkts, bkt)                                      \
+    do {                                                                       \
+        bkt = ((hashv) & ((num_bkts)-1U));                                     \
+    } while (0)
+
+/* delete "delptr" from the hash table.
+ * "the usual" patch-up process for the app-order doubly-linked-list.
+ * The use of _hd_hh_del below deserves special explanation.
+ * These used to be expressed using (delptr) but that led to a bug
+ * if someone used the same symbol for the head and deletee, like
+ *  HASH_DELETE(hh,users,users);
+ * We want that to work, but by changing the head (users) below
+ * we were forfeiting our ability to further refer to the deletee (users)
+ * in the patch-up process. Solution: use scratch space to
+ * copy the deletee pointer, then the latter references are via that
+ * scratch pointer rather than through the repointed (users) symbol.
+ */
+#define HASH_DELETE(hh, head, delptr) HASH_DELETE_HH(hh, head, &(delptr)->hh)
+
+#define HASH_DELETE_HH(hh, head, delptrhh)                                     \
+    do {                                                                       \
+        const struct UT_hash_handle *_hd_hh_del = (delptrhh);                  \
+        if ((_hd_hh_del->prev == NULL) && (_hd_hh_del->next == NULL)) {        \
+            HASH_BLOOM_FREE((head)->hh.tbl);                                   \
+            uthash_free((head)->hh.tbl->buckets,                               \
+                        (head)->hh.tbl->num_buckets *                          \
+                            sizeof(struct UT_hash_bucket));                    \
+            uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                \
+            (head) = NULL;                                                     \
+        } else {                                                               \
+            unsigned _hd_bkt;                                                  \
+            if (_hd_hh_del == (head)->hh.tbl->tail) {                          \
+                (head)->hh.tbl->tail =                                         \
+                    HH_FROM_ELMT((head)->hh.tbl, _hd_hh_del->prev);            \
+            }                                                                  \
+            if (_hd_hh_del->prev != NULL) {                                    \
+                HH_FROM_ELMT((head)->hh.tbl, _hd_hh_del->prev)->next =         \
+                    _hd_hh_del->next;                                          \
+            } else {                                                           \
+                DECLTYPE_ASSIGN(head, _hd_hh_del->next);                       \
+            }                                                                  \
+            if (_hd_hh_del->next != NULL) {                                    \
+                HH_FROM_ELMT((head)->hh.tbl, _hd_hh_del->next)->prev =         \
+                    _hd_hh_del->prev;                                          \
+            }                                                                  \
+            HASH_TO_BKT(_hd_hh_del->hashv, (head)->hh.tbl->num_buckets,        \
+                        _hd_bkt);                                              \
+            HASH_DEL_IN_BKT((head)->hh.tbl->buckets[_hd_bkt], _hd_hh_del);     \
+            (head)->hh.tbl->num_items--;                                       \
+        }                                                                      \
+        HASH_FSCK(hh, head, "HASH_DELETE_HH");                                 \
+    } while (0)
+
+/* convenience forms of HASH_FIND/HASH_ADD/HASH_DEL */
+#define HASH_FIND_STR(head, findstr, out)                                      \
+    do {                                                                       \
+        unsigned _uthash_hfstr_keylen = (unsigned)uthash_strlen(findstr);      \
+        HASH_FIND(hh, head, findstr, _uthash_hfstr_keylen, out);               \
+    } while (0)
+#define HASH_ADD_STR(head, strfield, add)                                      \
+    do {                                                                       \
+        unsigned _uthash_hastr_keylen =                                        \
+            (unsigned)uthash_strlen((add)->strfield);                          \
+        HASH_ADD(hh, head, strfield[0], _uthash_hastr_keylen, add);            \
+    } while (0)
+#define HASH_REPLACE_STR(head, strfield, add, replaced)                        \
+    do {                                                                       \
+        unsigned _uthash_hrstr_keylen =                                        \
+            (unsigned)uthash_strlen((add)->strfield);                          \
+        HASH_REPLACE(hh, head, strfield[0], _uthash_hrstr_keylen, add,         \
+                     replaced);                                                \
+    } while (0)
+#define HASH_FIND_INT(head, findint, out)                                      \
+    HASH_FIND(hh, head, findint, sizeof(int), out)
+#define HASH_ADD_INT(head, intfield, add)                                      \
+    HASH_ADD(hh, head, intfield, sizeof(int), add)
+#define HASH_REPLACE_INT(head, intfield, add, replaced)                        \
+    HASH_REPLACE(hh, head, intfield, sizeof(int), add, replaced)
+#define HASH_FIND_PTR(head, findptr, out)                                      \
+    HASH_FIND(hh, head, findptr, sizeof(void *), out)
+#define HASH_ADD_PTR(head, ptrfield, add)                                      \
+    HASH_ADD(hh, head, ptrfield, sizeof(void *), add)
+#define HASH_REPLACE_PTR(head, ptrfield, add, replaced)                        \
+    HASH_REPLACE(hh, head, ptrfield, sizeof(void *), add, replaced)
+#define HASH_DEL(head, delptr) HASH_DELETE(hh, head, delptr)
+
+/* HASH_FSCK checks hash integrity on every add/delete when HASH_DEBUG is defined.
+ * This is for uthash developer only; it compiles away if HASH_DEBUG isn't defined.
+ */
+#ifdef HASH_DEBUG
+#include <stdio.h> /* fprintf, stderr */
+#define HASH_OOPS(...)                                                         \
+    do {                                                                       \
+        fprintf(stderr, __VA_ARGS__);                                          \
+        exit(-1);                                                              \
+    } while (0)
+#define HASH_FSCK(hh, head, where)                                             \
+    do {                                                                       \
+        struct UT_hash_handle *_thh;                                           \
+        if (head) {                                                            \
+            unsigned _bkt_i;                                                   \
+            unsigned _count = 0;                                               \
+            char *_prev;                                                       \
+            for (_bkt_i = 0; _bkt_i < (head)->hh.tbl->num_buckets; ++_bkt_i) { \
+                unsigned _bkt_count = 0;                                       \
+                _thh = (head)->hh.tbl->buckets[_bkt_i].hh_head;                \
+                _prev = NULL;                                                  \
+                while (_thh) {                                                 \
+                    if (_prev != (char *)(_thh->hh_prev)) {                    \
+                        HASH_OOPS("%s: invalid hh_prev %p, actual %p\n",       \
+                                  (where), (void *)_thh->hh_prev,              \
+                                  (void *)_prev);                              \
+                    }                                                          \
+                    _bkt_count++;                                              \
+                    _prev = (char *)(_thh);                                    \
+                    _thh = _thh->hh_next;                                      \
+                }                                                              \
+                _count += _bkt_count;                                          \
+                if ((head)->hh.tbl->buckets[_bkt_i].count != _bkt_count) {     \
+                    HASH_OOPS("%s: invalid bucket count %u, actual %u\n",      \
+                              (where), (head)->hh.tbl->buckets[_bkt_i].count,  \
+                              _bkt_count);                                     \
+                }                                                              \
+            }                                                                  \
+            if (_count != (head)->hh.tbl->num_items) {                         \
+                HASH_OOPS("%s: invalid hh item count %u, actual %u\n",         \
+                          (where), (head)->hh.tbl->num_items, _count);         \
+            }                                                                  \
+            _count = 0;                                                        \
+            _prev = NULL;                                                      \
+            _thh = &(head)->hh;                                                \
+            while (_thh) {                                                     \
+                _count++;                                                      \
+                if (_prev != (char *)_thh->prev) {                             \
+                    HASH_OOPS("%s: invalid prev %p, actual %p\n", (where),     \
+                              (void *)_thh->prev, (void *)_prev);              \
+                }                                                              \
+                _prev = (char *)ELMT_FROM_HH((head)->hh.tbl, _thh);            \
+                _thh = (_thh->next ? HH_FROM_ELMT((head)->hh.tbl, _thh->next)  \
+                                   : NULL);                                    \
+            }                                                                  \
+            if (_count != (head)->hh.tbl->num_items) {                         \
+                HASH_OOPS("%s: invalid app item count %u, actual %u\n",        \
+                          (where), (head)->hh.tbl->num_items, _count);         \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+#else
+#define HASH_FSCK(hh, head, where)
+#endif
+
+/* When compiled with -DHASH_EMIT_KEYS, length-prefixed keys are emitted to
+ * the descriptor to which this macro is defined for tuning the hash function.
+ * The app can #include <unistd.h> to get the prototype for write(2). */
+#ifdef HASH_EMIT_KEYS
+#define HASH_EMIT_KEY(hh, head, keyptr, fieldlen)                              \
+    do {                                                                       \
+        unsigned _klen = fieldlen;                                             \
+        write(HASH_EMIT_KEYS, &_klen, sizeof(_klen));                          \
+        write(HASH_EMIT_KEYS, keyptr, (unsigned long)fieldlen);                \
+    } while (0)
+#else
+#define HASH_EMIT_KEY(hh, head, keyptr, fieldlen)
+#endif
+
+/* The Bernstein hash function, used in Perl prior to v5.6. Note (x<<5+x)=x*33. */
+#define HASH_BER(key, keylen, hashv)                                           \
+    do {                                                                       \
+        unsigned _hb_keylen = (unsigned)keylen;                                \
+        const unsigned char *_hb_key = (const unsigned char *)(key);           \
+        (hashv) = 0;                                                           \
+        while (_hb_keylen-- != 0U) {                                           \
+            (hashv) = (((hashv) << 5) + (hashv)) + *_hb_key++;                 \
+        }                                                                      \
+    } while (0)
+
+/* SAX/FNV/OAT/JEN hash functions are macro variants of those listed at
+ * http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx
+ * (archive link: https://archive.is/Ivcan )
+ */
+#define HASH_SAX(key, keylen, hashv)                                           \
+    do {                                                                       \
+        unsigned _sx_i;                                                        \
+        const unsigned char *_hs_key = (const unsigned char *)(key);           \
+        hashv = 0;                                                             \
+        for (_sx_i = 0; _sx_i < keylen; _sx_i++) {                             \
+            hashv ^= (hashv << 5) + (hashv >> 2) + _hs_key[_sx_i];             \
+        }                                                                      \
+    } while (0)
+/* FNV-1a variation */
+#define HASH_FNV(key, keylen, hashv)                                           \
+    do {                                                                       \
+        unsigned _fn_i;                                                        \
+        const unsigned char *_hf_key = (const unsigned char *)(key);           \
+        (hashv) = 2166136261U;                                                 \
+        for (_fn_i = 0; _fn_i < keylen; _fn_i++) {                             \
+            hashv = hashv ^ _hf_key[_fn_i];                                    \
+            hashv = hashv * 16777619U;                                         \
+        }                                                                      \
+    } while (0)
+
+#define HASH_OAT(key, keylen, hashv)                                           \
+    do {                                                                       \
+        unsigned _ho_i;                                                        \
+        const unsigned char *_ho_key = (const unsigned char *)(key);           \
+        hashv = 0;                                                             \
+        for (_ho_i = 0; _ho_i < keylen; _ho_i++) {                             \
+            hashv += _ho_key[_ho_i];                                           \
+            hashv += (hashv << 10);                                            \
+            hashv ^= (hashv >> 6);                                             \
+        }                                                                      \
+        hashv += (hashv << 3);                                                 \
+        hashv ^= (hashv >> 11);                                                \
+        hashv += (hashv << 15);                                                \
+    } while (0)
+
+#define HASH_JEN_MIX(a, b, c)                                                  \
+    do {                                                                       \
+        a -= b;                                                                \
+        a -= c;                                                                \
+        a ^= (c >> 13);                                                        \
+        b -= c;                                                                \
+        b -= a;                                                                \
+        b ^= (a << 8);                                                         \
+        c -= a;                                                                \
+        c -= b;                                                                \
+        c ^= (b >> 13);                                                        \
+        a -= b;                                                                \
+        a -= c;                                                                \
+        a ^= (c >> 12);                                                        \
+        b -= c;                                                                \
+        b -= a;                                                                \
+        b ^= (a << 16);                                                        \
+        c -= a;                                                                \
+        c -= b;                                                                \
+        c ^= (b >> 5);                                                         \
+        a -= b;                                                                \
+        a -= c;                                                                \
+        a ^= (c >> 3);                                                         \
+        b -= c;                                                                \
+        b -= a;                                                                \
+        b ^= (a << 10);                                                        \
+        c -= a;                                                                \
+        c -= b;                                                                \
+        c ^= (b >> 15);                                                        \
+    } while (0)
+
+#define HASH_JEN(key, keylen, hashv)                                           \
+    do {                                                                       \
+        unsigned _hj_i, _hj_j, _hj_k;                                          \
+        unsigned const char *_hj_key = (unsigned const char *)(key);           \
+        hashv = 0xfeedbeefu;                                                   \
+        _hj_i = _hj_j = 0x9e3779b9u;                                           \
+        _hj_k = (unsigned)(keylen);                                            \
+        while (_hj_k >= 12U) {                                                 \
+            _hj_i +=                                                           \
+                (_hj_key[0] + ((unsigned)_hj_key[1] << 8) +                    \
+                 ((unsigned)_hj_key[2] << 16) + ((unsigned)_hj_key[3] << 24)); \
+            _hj_j +=                                                           \
+                (_hj_key[4] + ((unsigned)_hj_key[5] << 8) +                    \
+                 ((unsigned)_hj_key[6] << 16) + ((unsigned)_hj_key[7] << 24)); \
+            hashv += (_hj_key[8] + ((unsigned)_hj_key[9] << 8) +               \
+                      ((unsigned)_hj_key[10] << 16) +                          \
+                      ((unsigned)_hj_key[11] << 24));                          \
+                                                                               \
+            HASH_JEN_MIX(_hj_i, _hj_j, hashv);                                 \
+                                                                               \
+            _hj_key += 12;                                                     \
+            _hj_k -= 12U;                                                      \
+        }                                                                      \
+        hashv += (unsigned)(keylen);                                           \
+        switch (_hj_k) {                                                       \
+        case 11:                                                               \
+            hashv += ((unsigned)_hj_key[10] << 24); /* FALLTHROUGH */          \
+        case 10:                                                               \
+            hashv += ((unsigned)_hj_key[9] << 16); /* FALLTHROUGH */           \
+        case 9:                                                                \
+            hashv += ((unsigned)_hj_key[8] << 8); /* FALLTHROUGH */            \
+        case 8:                                                                \
+            _hj_j += ((unsigned)_hj_key[7] << 24); /* FALLTHROUGH */           \
+        case 7:                                                                \
+            _hj_j += ((unsigned)_hj_key[6] << 16); /* FALLTHROUGH */           \
+        case 6:                                                                \
+            _hj_j += ((unsigned)_hj_key[5] << 8); /* FALLTHROUGH */            \
+        case 5:                                                                \
+            _hj_j += _hj_key[4]; /* FALLTHROUGH */                             \
+        case 4:                                                                \
+            _hj_i += ((unsigned)_hj_key[3] << 24); /* FALLTHROUGH */           \
+        case 3:                                                                \
+            _hj_i += ((unsigned)_hj_key[2] << 16); /* FALLTHROUGH */           \
+        case 2:                                                                \
+            _hj_i += ((unsigned)_hj_key[1] << 8); /* FALLTHROUGH */            \
+        case 1:                                                                \
+            _hj_i += _hj_key[0]; /* FALLTHROUGH */                             \
+        default:;                                                              \
+        }                                                                      \
+        HASH_JEN_MIX(_hj_i, _hj_j, hashv);                                     \
+    } while (0)
+
+/* The Paul Hsieh hash function */
+#undef get16bits
+#if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__) ||        \
+    defined(_MSC_VER) || defined(__BORLANDC__) || defined(__TURBOC__)
+#define get16bits(d) (*((const uint16_t *)(d)))
+#endif
+
+#if !defined(get16bits)
+#define get16bits(d)                                                           \
+    ((((uint32_t)(((const uint8_t *)(d))[1])) << 8) +                          \
+     (uint32_t)(((const uint8_t *)(d))[0]))
+#endif
+#define HASH_SFH(key, keylen, hashv)                                           \
+    do {                                                                       \
+        unsigned const char *_sfh_key = (unsigned const char *)(key);          \
+        uint32_t _sfh_tmp, _sfh_len = (uint32_t)keylen;                        \
+                                                                               \
+        unsigned _sfh_rem = _sfh_len & 3U;                                     \
+        _sfh_len >>= 2;                                                        \
+        hashv = 0xcafebabeu;                                                   \
+                                                                               \
+        /* Main loop */                                                        \
+        for (; _sfh_len > 0U; _sfh_len--) {                                    \
+            hashv += get16bits(_sfh_key);                                      \
+            _sfh_tmp = ((uint32_t)(get16bits(_sfh_key + 2)) << 11) ^ hashv;    \
+            hashv = (hashv << 16) ^ _sfh_tmp;                                  \
+            _sfh_key += 2U * sizeof(uint16_t);                                 \
+            hashv += hashv >> 11;                                              \
+        }                                                                      \
+                                                                               \
+        /* Handle end cases */                                                 \
+        switch (_sfh_rem) {                                                    \
+        case 3:                                                                \
+            hashv += get16bits(_sfh_key);                                      \
+            hashv ^= hashv << 16;                                              \
+            hashv ^= (uint32_t)(_sfh_key[sizeof(uint16_t)]) << 18;             \
+            hashv += hashv >> 11;                                              \
+            break;                                                             \
+        case 2:                                                                \
+            hashv += get16bits(_sfh_key);                                      \
+            hashv ^= hashv << 11;                                              \
+            hashv += hashv >> 17;                                              \
+            break;                                                             \
+        case 1:                                                                \
+            hashv += *_sfh_key;                                                \
+            hashv ^= hashv << 10;                                              \
+            hashv += hashv >> 1;                                               \
+            break;                                                             \
+        default:;                                                              \
+        }                                                                      \
+                                                                               \
+        /* Force "avalanching" of final 127 bits */                            \
+        hashv ^= hashv << 3;                                                   \
+        hashv += hashv >> 5;                                                   \
+        hashv ^= hashv << 4;                                                   \
+        hashv += hashv >> 17;                                                  \
+        hashv ^= hashv << 25;                                                  \
+        hashv += hashv >> 6;                                                   \
+    } while (0)
+
+/* iterate over items in a known bucket to find desired item */
+#define HASH_FIND_IN_BKT(tbl, hh, head, keyptr, keylen_in, hashval, out)       \
+    do {                                                                       \
+        if ((head).hh_head != NULL) {                                          \
+            DECLTYPE_ASSIGN(out, ELMT_FROM_HH(tbl, (head).hh_head));           \
+        } else {                                                               \
+            (out) = NULL;                                                      \
+        }                                                                      \
+        while ((out) != NULL) {                                                \
+            if ((out)->hh.hashv == (hashval) &&                                \
+                (out)->hh.keylen == (keylen_in)) {                             \
+                if (HASH_KEYCMP((out)->hh.key, keyptr, keylen_in) == 0) {      \
+                    break;                                                     \
+                }                                                              \
+            }                                                                  \
+            if ((out)->hh.hh_next != NULL) {                                   \
+                DECLTYPE_ASSIGN(out, ELMT_FROM_HH(tbl, (out)->hh.hh_next));    \
+            } else {                                                           \
+                (out) = NULL;                                                  \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+/* add an item to a bucket  */
+#define HASH_ADD_TO_BKT(head, hh, addhh, oomed)                                \
+    do {                                                                       \
+        UT_hash_bucket *_ha_head = &(head);                                    \
+        _ha_head->count++;                                                     \
+        (addhh)->hh_next = _ha_head->hh_head;                                  \
+        (addhh)->hh_prev = NULL;                                               \
+        if (_ha_head->hh_head != NULL) {                                       \
+            _ha_head->hh_head->hh_prev = (addhh);                              \
+        }                                                                      \
+        _ha_head->hh_head = (addhh);                                           \
+        if ((_ha_head->count >=                                                \
+             ((_ha_head->expand_mult + 1U) * HASH_BKT_CAPACITY_THRESH)) &&     \
+            !(addhh)->tbl->noexpand) {                                         \
+            HASH_EXPAND_BUCKETS(addhh, (addhh)->tbl, oomed);                   \
+            IF_HASH_NONFATAL_OOM(if (oomed) { HASH_DEL_IN_BKT(head, addhh); }) \
+        }                                                                      \
+    } while (0)
+
+/* remove an item from a given bucket */
+#define HASH_DEL_IN_BKT(head, delhh)                                           \
+    do {                                                                       \
+        UT_hash_bucket *_hd_head = &(head);                                    \
+        _hd_head->count--;                                                     \
+        if (_hd_head->hh_head == (delhh)) {                                    \
+            _hd_head->hh_head = (delhh)->hh_next;                              \
+        }                                                                      \
+        if ((delhh)->hh_prev) {                                                \
+            (delhh)->hh_prev->hh_next = (delhh)->hh_next;                      \
+        }                                                                      \
+        if ((delhh)->hh_next) {                                                \
+            (delhh)->hh_next->hh_prev = (delhh)->hh_prev;                      \
+        }                                                                      \
+    } while (0)
+
+/* Bucket expansion has the effect of doubling the number of buckets
+ * and redistributing the items into the new buckets. Ideally the
+ * items will distribute more or less evenly into the new buckets
+ * (the extent to which this is true is a measure of the quality of
+ * the hash function as it applies to the key domain).
+ *
+ * With the items distributed into more buckets, the chain length
+ * (item count) in each bucket is reduced. Thus by expanding buckets
+ * the hash keeps a bound on the chain length. This bounded chain
+ * length is the essence of how a hash provides constant time lookup.
+ *
+ * The calculation of tbl->ideal_chain_maxlen below deserves some
+ * explanation. First, keep in mind that we're calculating the ideal
+ * maximum chain length based on the *new* (doubled) bucket count.
+ * In fractions this is just n/b (n=number of items,b=new num buckets).
+ * Since the ideal chain length is an integer, we want to calculate
+ * ceil(n/b). We don't depend on floating point arithmetic in this
+ * hash, so to calculate ceil(n/b) with integers we could write
+ *
+ *      ceil(n/b) = (n/b) + ((n%b)?1:0)
+ *
+ * and in fact a previous version of this hash did just that.
+ * But now we have improved things a bit by recognizing that b is
+ * always a power of two. We keep its base 2 log handy (call it lb),
+ * so now we can write this with a bit shift and logical AND:
+ *
+ *      ceil(n/b) = (n>>lb) + ( (n & (b-1)) ? 1:0)
+ *
+ */
+#define HASH_EXPAND_BUCKETS(hh, tbl, oomed)                                    \
+    do {                                                                       \
+        unsigned _he_bkt;                                                      \
+        unsigned _he_bkt_i;                                                    \
+        struct UT_hash_handle *_he_thh, *_he_hh_nxt;                           \
+        UT_hash_bucket *_he_new_buckets, *_he_newbkt;                          \
+        _he_new_buckets = (UT_hash_bucket *)uthash_malloc(                     \
+            sizeof(struct UT_hash_bucket) * (tbl)->num_buckets * 2U);          \
+        if (!_he_new_buckets) {                                                \
+            HASH_RECORD_OOM(oomed);                                            \
+        } else {                                                               \
+            uthash_bzero(_he_new_buckets, sizeof(struct UT_hash_bucket) *      \
+                                              (tbl)->num_buckets * 2U);        \
+            (tbl)->ideal_chain_maxlen =                                        \
+                ((tbl)->num_items >> ((tbl)->log2_num_buckets + 1U)) +         \
+                ((((tbl)->num_items & (((tbl)->num_buckets * 2U) - 1U)) != 0U) \
+                     ? 1U                                                      \
+                     : 0U);                                                    \
+            (tbl)->nonideal_items = 0;                                         \
+            for (_he_bkt_i = 0; _he_bkt_i < (tbl)->num_buckets; _he_bkt_i++) { \
+                _he_thh = (tbl)->buckets[_he_bkt_i].hh_head;                   \
+                while (_he_thh != NULL) {                                      \
+                    _he_hh_nxt = _he_thh->hh_next;                             \
+                    HASH_TO_BKT(_he_thh->hashv, (tbl)->num_buckets * 2U,       \
+                                _he_bkt);                                      \
+                    _he_newbkt = &(_he_new_buckets[_he_bkt]);                  \
+                    if (++(_he_newbkt->count) > (tbl)->ideal_chain_maxlen) {   \
+                        (tbl)->nonideal_items++;                               \
+                        if (_he_newbkt->count >                                \
+                            _he_newbkt->expand_mult *                          \
+                                (tbl)->ideal_chain_maxlen) {                   \
+                            _he_newbkt->expand_mult++;                         \
+                        }                                                      \
+                    }                                                          \
+                    _he_thh->hh_prev = NULL;                                   \
+                    _he_thh->hh_next = _he_newbkt->hh_head;                    \
+                    if (_he_newbkt->hh_head != NULL) {                         \
+                        _he_newbkt->hh_head->hh_prev = _he_thh;                \
+                    }                                                          \
+                    _he_newbkt->hh_head = _he_thh;                             \
+                    _he_thh = _he_hh_nxt;                                      \
+                }                                                              \
+            }                                                                  \
+            uthash_free((tbl)->buckets,                                        \
+                        (tbl)->num_buckets * sizeof(struct UT_hash_bucket));   \
+            (tbl)->num_buckets *= 2U;                                          \
+            (tbl)->log2_num_buckets++;                                         \
+            (tbl)->buckets = _he_new_buckets;                                  \
+            (tbl)->ineff_expands =                                             \
+                ((tbl)->nonideal_items > ((tbl)->num_items >> 1))              \
+                    ? ((tbl)->ineff_expands + 1U)                              \
+                    : 0U;                                                      \
+            if ((tbl)->ineff_expands > 1U) {                                   \
+                (tbl)->noexpand = 1;                                           \
+                uthash_noexpand_fyi(tbl);                                      \
+            }                                                                  \
+            uthash_expand_fyi(tbl);                                            \
+        }                                                                      \
+    } while (0)
+
+/* This is an adaptation of Simon Tatham's O(n log(n)) mergesort */
+/* Note that HASH_SORT assumes the hash handle name to be hh.
+ * HASH_SRT was added to allow the hash handle name to be passed in. */
+#define HASH_SORT(head, cmpfcn) HASH_SRT(hh, head, cmpfcn)
+#define HASH_SRT(hh, head, cmpfcn)                                             \
+    do {                                                                       \
+        unsigned _hs_i;                                                        \
+        unsigned _hs_looping, _hs_nmerges, _hs_insize, _hs_psize, _hs_qsize;   \
+        struct UT_hash_handle *_hs_p, *_hs_q, *_hs_e, *_hs_list, *_hs_tail;    \
+        if (head != NULL) {                                                    \
+            _hs_insize = 1;                                                    \
+            _hs_looping = 1;                                                   \
+            _hs_list = &((head)->hh);                                          \
+            while (_hs_looping != 0U) {                                        \
+                _hs_p = _hs_list;                                              \
+                _hs_list = NULL;                                               \
+                _hs_tail = NULL;                                               \
+                _hs_nmerges = 0;                                               \
+                while (_hs_p != NULL) {                                        \
+                    _hs_nmerges++;                                             \
+                    _hs_q = _hs_p;                                             \
+                    _hs_psize = 0;                                             \
+                    for (_hs_i = 0; _hs_i < _hs_insize; ++_hs_i) {             \
+                        _hs_psize++;                                           \
+                        _hs_q =                                                \
+                            ((_hs_q->next != NULL)                             \
+                                 ? HH_FROM_ELMT((head)->hh.tbl, _hs_q->next)   \
+                                 : NULL);                                      \
+                        if (_hs_q == NULL) {                                   \
+                            break;                                             \
+                        }                                                      \
+                    }                                                          \
+                    _hs_qsize = _hs_insize;                                    \
+                    while ((_hs_psize != 0U) ||                                \
+                           ((_hs_qsize != 0U) && (_hs_q != NULL))) {           \
+                        if (_hs_psize == 0U) {                                 \
+                            _hs_e = _hs_q;                                     \
+                            _hs_q = ((_hs_q->next != NULL)                     \
+                                         ? HH_FROM_ELMT((head)->hh.tbl,        \
+                                                        _hs_q->next)           \
+                                         : NULL);                              \
+                            _hs_qsize--;                                       \
+                        } else if ((_hs_qsize == 0U) || (_hs_q == NULL)) {     \
+                            _hs_e = _hs_p;                                     \
+                            if (_hs_p != NULL) {                               \
+                                _hs_p = ((_hs_p->next != NULL)                 \
+                                             ? HH_FROM_ELMT((head)->hh.tbl,    \
+                                                            _hs_p->next)       \
+                                             : NULL);                          \
+                            }                                                  \
+                            _hs_psize--;                                       \
+                        } else if ((cmpfcn(DECLTYPE(head)(ELMT_FROM_HH(        \
+                                               (head)->hh.tbl, _hs_p)),        \
+                                           DECLTYPE(head)(ELMT_FROM_HH(        \
+                                               (head)->hh.tbl, _hs_q)))) <=    \
+                                   0) {                                        \
+                            _hs_e = _hs_p;                                     \
+                            if (_hs_p != NULL) {                               \
+                                _hs_p = ((_hs_p->next != NULL)                 \
+                                             ? HH_FROM_ELMT((head)->hh.tbl,    \
+                                                            _hs_p->next)       \
+                                             : NULL);                          \
+                            }                                                  \
+                            _hs_psize--;                                       \
+                        } else {                                               \
+                            _hs_e = _hs_q;                                     \
+                            _hs_q = ((_hs_q->next != NULL)                     \
+                                         ? HH_FROM_ELMT((head)->hh.tbl,        \
+                                                        _hs_q->next)           \
+                                         : NULL);                              \
+                            _hs_qsize--;                                       \
+                        }                                                      \
+                        if (_hs_tail != NULL) {                                \
+                            _hs_tail->next =                                   \
+                                ((_hs_e != NULL)                               \
+                                     ? ELMT_FROM_HH((head)->hh.tbl, _hs_e)     \
+                                     : NULL);                                  \
+                        } else {                                               \
+                            _hs_list = _hs_e;                                  \
+                        }                                                      \
+                        if (_hs_e != NULL) {                                   \
+                            _hs_e->prev =                                      \
+                                ((_hs_tail != NULL)                            \
+                                     ? ELMT_FROM_HH((head)->hh.tbl, _hs_tail)  \
+                                     : NULL);                                  \
+                        }                                                      \
+                        _hs_tail = _hs_e;                                      \
+                    }                                                          \
+                    _hs_p = _hs_q;                                             \
+                }                                                              \
+                if (_hs_tail != NULL) {                                        \
+                    _hs_tail->next = NULL;                                     \
+                }                                                              \
+                if (_hs_nmerges <= 1U) {                                       \
+                    _hs_looping = 0;                                           \
+                    (head)->hh.tbl->tail = _hs_tail;                           \
+                    DECLTYPE_ASSIGN(head,                                      \
+                                    ELMT_FROM_HH((head)->hh.tbl, _hs_list));   \
+                }                                                              \
+                _hs_insize *= 2U;                                              \
+            }                                                                  \
+            HASH_FSCK(hh, head, "HASH_SRT");                                   \
+        }                                                                      \
+    } while (0)
+
+/* This function selects items from one hash into another hash.
+ * The end result is that the selected items have dual presence
+ * in both hashes. There is no copy of the items made; rather
+ * they are added into the new hash through a secondary hash
+ * hash handle that must be present in the structure. */
+#define HASH_SELECT(hh_dst, dst, hh_src, src, cond)                            \
+    do {                                                                       \
+        unsigned _src_bkt, _dst_bkt;                                           \
+        void *_last_elt = NULL, *_elt;                                         \
+        UT_hash_handle *_src_hh, *_dst_hh, *_last_elt_hh = NULL;               \
+        ptrdiff_t _dst_hho = ((char *)(&(dst)->hh_dst) - (char *)(dst));       \
+        if ((src) != NULL) {                                                   \
+            for (_src_bkt = 0; _src_bkt < (src)->hh_src.tbl->num_buckets;      \
+                 _src_bkt++) {                                                 \
+                for (_src_hh = (src)->hh_src.tbl->buckets[_src_bkt].hh_head;   \
+                     _src_hh != NULL; _src_hh = _src_hh->hh_next) {            \
+                    _elt = ELMT_FROM_HH((src)->hh_src.tbl, _src_hh);           \
+                    if (cond(_elt)) {                                          \
+                        IF_HASH_NONFATAL_OOM(int _hs_oomed = 0;)               \
+                        _dst_hh = (UT_hash_handle *)(void *)(((char *)_elt) +  \
+                                                             _dst_hho);        \
+                        _dst_hh->key = _src_hh->key;                           \
+                        _dst_hh->keylen = _src_hh->keylen;                     \
+                        _dst_hh->hashv = _src_hh->hashv;                       \
+                        _dst_hh->prev = _last_elt;                             \
+                        _dst_hh->next = NULL;                                  \
+                        if (_last_elt_hh != NULL) {                            \
+                            _last_elt_hh->next = _elt;                         \
+                        }                                                      \
+                        if ((dst) == NULL) {                                   \
+                            DECLTYPE_ASSIGN(dst, _elt);                        \
+                            HASH_MAKE_TABLE(hh_dst, dst, _hs_oomed);           \
+                            IF_HASH_NONFATAL_OOM(if (_hs_oomed) {              \
+                                uthash_nonfatal_oom(_elt);                     \
+                                (dst) = NULL;                                  \
+                                continue;                                      \
+                            })                                                 \
+                        } else {                                               \
+                            _dst_hh->tbl = (dst)->hh_dst.tbl;                  \
+                        }                                                      \
+                        HASH_TO_BKT(_dst_hh->hashv, _dst_hh->tbl->num_buckets, \
+                                    _dst_bkt);                                 \
+                        HASH_ADD_TO_BKT(_dst_hh->tbl->buckets[_dst_bkt],       \
+                                        hh_dst, _dst_hh, _hs_oomed);           \
+                        (dst)->hh_dst.tbl->num_items++;                        \
+                        IF_HASH_NONFATAL_OOM(if (_hs_oomed) {                  \
+                            HASH_ROLLBACK_BKT(hh_dst, dst, _dst_hh);           \
+                            HASH_DELETE_HH(hh_dst, dst, _dst_hh);              \
+                            _dst_hh->tbl = NULL;                               \
+                            uthash_nonfatal_oom(_elt);                         \
+                            continue;                                          \
+                        })                                                     \
+                        HASH_BLOOM_ADD(_dst_hh->tbl, _dst_hh->hashv);          \
+                        _last_elt = _elt;                                      \
+                        _last_elt_hh = _dst_hh;                                \
+                    }                                                          \
+                }                                                              \
+            }                                                                  \
+        }                                                                      \
+        HASH_FSCK(hh_dst, dst, "HASH_SELECT");                                 \
+    } while (0)
+
+#define HASH_CLEAR(hh, head)                                                   \
+    do {                                                                       \
+        if ((head) != NULL) {                                                  \
+            HASH_BLOOM_FREE((head)->hh.tbl);                                   \
+            uthash_free((head)->hh.tbl->buckets,                               \
+                        (head)->hh.tbl->num_buckets *                          \
+                            sizeof(struct UT_hash_bucket));                    \
+            uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                \
+            (head) = NULL;                                                     \
+        }                                                                      \
+    } while (0)
+
+#define HASH_OVERHEAD(hh, head)                                                \
+    (((head) != NULL)                                                          \
+         ? ((size_t)(((head)->hh.tbl->num_items * sizeof(UT_hash_handle)) +    \
+                     ((head)->hh.tbl->num_buckets * sizeof(UT_hash_bucket)) +  \
+                     sizeof(UT_hash_table) + (HASH_BLOOM_BYTELEN)))            \
+         : 0U)
+
+#ifdef NO_DECLTYPE
+#define HASH_ITER(hh, head, el, tmp)                                           \
+    for (((el) = (head)),                                                      \
+         ((*(char **)(&(tmp))) =                                               \
+              (char *)((head != NULL) ? (head)->hh.next : NULL));              \
+         (el) != NULL; ((el) = (tmp)),                                         \
+                       ((*(char **)(&(tmp))) =                                 \
+                            (char *)((tmp != NULL) ? (tmp)->hh.next : NULL)))
+#else
+#define HASH_ITER(hh, head, el, tmp)                                           \
+    for (((el) = (head)),                                                      \
+         ((tmp) = DECLTYPE(el)((head != NULL) ? (head)->hh.next : NULL));      \
+         (el) != NULL;                                                         \
+         ((el) = (tmp)),                                                       \
+         ((tmp) = DECLTYPE(el)((tmp != NULL) ? (tmp)->hh.next : NULL)))
+#endif
+
+/* obtain a count of items in the hash */
+#define HASH_COUNT(head) HASH_CNT(hh, head)
+#define HASH_CNT(hh, head) ((head != NULL) ? ((head)->hh.tbl->num_items) : 0U)
+
+typedef struct UT_hash_bucket {
+    struct UT_hash_handle *hh_head;
+    unsigned count;
+
+    /* expand_mult is normally set to 0. In this situation, the max chain length
+    * threshold is enforced at its default value, HASH_BKT_CAPACITY_THRESH. (If
+    * the bucket's chain exceeds this length, bucket expansion is triggered).
+    * However, setting expand_mult to a non-zero value delays bucket expansion
+    * (that would be triggered by additions to this particular bucket)
+    * until its chain length reaches a *multiple* of HASH_BKT_CAPACITY_THRESH.
+    * (The multiplier is simply expand_mult+1). The whole idea of this
+    * multiplier is to reduce bucket expansions, since they are expensive, in
+    * situations where we know that a particular bucket tends to be overused.
+    * It is better to let its chain length grow to a longer yet-still-bounded
+    * value, than to do an O(n) bucket expansion too often.
+    */
+    unsigned expand_mult;
+
+} UT_hash_bucket;
+
+/* random signature used only to find hash tables in external analysis */
+#define HASH_SIGNATURE 0xa0111fe1u
+#define HASH_BLOOM_SIGNATURE 0xb12220f2u
+
+typedef struct UT_hash_table {
+    UT_hash_bucket *buckets;
+    unsigned num_buckets, log2_num_buckets;
+    unsigned num_items;
+    struct UT_hash_handle *tail; /* tail hh in app order, for fast append    */
+    ptrdiff_t hho; /* hash handle offset (byte pos of hash handle in element */
+
+    /* in an ideal situation (all buckets used equally), no bucket would have
+    * more than ceil(#items/#buckets) items. that's the ideal chain length. */
+    unsigned ideal_chain_maxlen;
+
+    /* nonideal_items is the number of items in the hash whose chain position
+    * exceeds the ideal chain maxlen. these items pay the penalty for an uneven
+    * hash distribution; reaching them in a chain traversal takes >ideal steps */
+    unsigned nonideal_items;
+
+    /* ineffective expands occur when a bucket doubling was performed, but
+    * afterward, more than half the items in the hash had nonideal chain
+    * positions. If this happens on two consecutive expansions we inhibit any
+    * further expansion, as it's not helping; this happens when the hash
+    * function isn't a good fit for the key domain. When expansion is inhibited
+    * the hash will still work, albeit no longer in constant time. */
+    unsigned ineff_expands, noexpand;
+
+    uint32_t signature; /* used only to find hash tables in external analysis */
+#ifdef HASH_BLOOM
+    uint32_t
+        bloom_sig; /* used only to test bloom exists in external analysis */
+    uint8_t *bloom_bv;
+    uint8_t bloom_nbits;
+#endif
+
+} UT_hash_table;
+
+typedef struct UT_hash_handle {
+    struct UT_hash_table *tbl;
+    void *prev;                     /* prev element in app order      */
+    void *next;                     /* next element in app order      */
+    struct UT_hash_handle *hh_prev; /* previous hh in bucket order    */
+    struct UT_hash_handle *hh_next; /* next hh in bucket order        */
+    const void *key;                /* ptr to enclosing struct's key  */
+    unsigned keylen;                /* enclosing struct's key len     */
+    unsigned hashv;                 /* result of hash-fcn(key)        */
+} UT_hash_handle;
+
+#endif /* UTHASH_H */
diff --git a/src/uthash/utlist.h b/src/uthash/utlist.h
new file mode 100644
index 000000000..ed4660b49
--- /dev/null
+++ b/src/uthash/utlist.h
@@ -0,0 +1,1148 @@
+/*
+Copyright (c) 2007-2022, Troy D. Hanson  https://troydhanson.github.io/uthash/
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef UTLIST_H
+#define UTLIST_H
+
+#define UTLIST_VERSION 2.3.0
+
+#include <assert.h>
+
+/*
+ * This file contains macros to manipulate singly and doubly-linked lists.
+ *
+ * 1. LL_ macros:  singly-linked lists.
+ * 2. DL_ macros:  doubly-linked lists.
+ * 3. CDL_ macros: circular doubly-linked lists.
+ *
+ * To use singly-linked lists, your structure must have a "next" pointer.
+ * To use doubly-linked lists, your structure must "prev" and "next" pointers.
+ * Either way, the pointer to the head of the list must be initialized to NULL.
+ *
+ * ----------------.EXAMPLE -------------------------
+ * struct item {
+ *      int id;
+ *      struct item *prev, *next;
+ * }
+ *
+ * struct item *list = NULL:
+ *
+ * int main() {
+ *      struct item *item;
+ *      ... allocate and populate item ...
+ *      DL_APPEND(list, item);
+ * }
+ * --------------------------------------------------
+ *
+ * For doubly-linked lists, the append and delete macros are O(1)
+ * For singly-linked lists, append and delete are O(n) but prepend is O(1)
+ * The sort macro is O(n log(n)) for all types of single/double/circular lists.
+ */
+
+/* These macros use decltype or the earlier __typeof GNU extension.
+   As decltype is only available in newer compilers (VS2010 or gcc 4.3+
+   when compiling c++ source) this code uses whatever method is needed
+   or, for VS2008 where neither is available, uses casting workarounds. */
+#if !defined(LDECLTYPE) && !defined(NO_DECLTYPE)
+#if defined(_MSC_VER)                        /* MS compiler */
+#if _MSC_VER >= 1600 && defined(__cplusplus) /* VS2010 or newer in C++ mode */
+#define LDECLTYPE(x) decltype(x)
+#else /* VS2008 or older (or VS2010 in C mode) */
+#define NO_DECLTYPE
+#endif
+#elif defined(__MCST__) /* Elbrus C Compiler */
+#define LDECLTYPE(x) __typeof(x)
+#elif defined(__BORLANDC__) || defined(__ICCARM__) || defined(__LCC__) ||      \
+    defined(__WATCOMC__)
+#define NO_DECLTYPE
+#else /* GNU, Sun and other compilers */
+#define LDECLTYPE(x) __typeof(x)
+#endif
+#endif
+
+/* for VS2008 we use some workarounds to get around the lack of decltype,
+ * namely, we always reassign our tmp variable to the list head if we need
+ * to dereference its prev/next pointers, and save/restore the real head.*/
+#ifdef NO_DECLTYPE
+#define IF_NO_DECLTYPE(x) x
+#define LDECLTYPE(x) char *
+#define UTLIST_SV(elt, list)                                                   \
+    _tmp = (char *)(list);                                                     \
+    {                                                                          \
+        char **_alias = (char **)&(list);                                      \
+        *_alias = (elt);                                                       \
+    }
+#define UTLIST_NEXT(elt, list, next) ((char *)((list)->next))
+#define UTLIST_NEXTASGN(elt, list, to, next)                                   \
+    {                                                                          \
+        char **_alias = (char **)&((list)->next);                              \
+        *_alias = (char *)(to);                                                \
+    }
+/* #define UTLIST_PREV(elt,list,prev) ((char*)((list)->prev)) */
+#define UTLIST_PREVASGN(elt, list, to, prev)                                   \
+    {                                                                          \
+        char **_alias = (char **)&((list)->prev);                              \
+        *_alias = (char *)(to);                                                \
+    }
+#define UTLIST_RS(list)                                                        \
+    {                                                                          \
+        char **_alias = (char **)&(list);                                      \
+        *_alias = _tmp;                                                        \
+    }
+#define UTLIST_CASTASGN(a, b)                                                  \
+    {                                                                          \
+        char **_alias = (char **)&(a);                                         \
+        *_alias = (char *)(b);                                                 \
+    }
+#else
+#define IF_NO_DECLTYPE(x)
+#define UTLIST_SV(elt, list)
+#define UTLIST_NEXT(elt, list, next) ((elt)->next)
+#define UTLIST_NEXTASGN(elt, list, to, next) ((elt)->next) = (to)
+/* #define UTLIST_PREV(elt,list,prev) ((elt)->prev) */
+#define UTLIST_PREVASGN(elt, list, to, prev) ((elt)->prev) = (to)
+#define UTLIST_RS(list)
+#define UTLIST_CASTASGN(a, b) (a) = (b)
+#endif
+
+/******************************************************************************
+ * The sort macro is an adaptation of Simon Tatham's O(n log(n)) mergesort    *
+ * Unwieldy variable names used here to avoid shadowing passed-in variables.  *
+ *****************************************************************************/
+#define LL_SORT(list, cmp) LL_SORT2(list, cmp, next)
+
+#define LL_SORT2(list, cmp, next)                                              \
+    do {                                                                       \
+        LDECLTYPE(list) _ls_p;                                                 \
+        LDECLTYPE(list) _ls_q;                                                 \
+        LDECLTYPE(list) _ls_e;                                                 \
+        LDECLTYPE(list) _ls_tail;                                              \
+        IF_NO_DECLTYPE(LDECLTYPE(list) _tmp;)                                  \
+        int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping; \
+        if (list) {                                                            \
+            _ls_insize = 1;                                                    \
+            _ls_looping = 1;                                                   \
+            while (_ls_looping) {                                              \
+                UTLIST_CASTASGN(_ls_p, list);                                  \
+                (list) = NULL;                                                 \
+                _ls_tail = NULL;                                               \
+                _ls_nmerges = 0;                                               \
+                while (_ls_p) {                                                \
+                    _ls_nmerges++;                                             \
+                    _ls_q = _ls_p;                                             \
+                    _ls_psize = 0;                                             \
+                    for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) {             \
+                        _ls_psize++;                                           \
+                        UTLIST_SV(_ls_q, list);                                \
+                        _ls_q = UTLIST_NEXT(_ls_q, list, next);                \
+                        UTLIST_RS(list);                                       \
+                        if (!_ls_q)                                            \
+                            break;                                             \
+                    }                                                          \
+                    _ls_qsize = _ls_insize;                                    \
+                    while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) {        \
+                        if (_ls_psize == 0) {                                  \
+                            _ls_e = _ls_q;                                     \
+                            UTLIST_SV(_ls_q, list);                            \
+                            _ls_q = UTLIST_NEXT(_ls_q, list, next);            \
+                            UTLIST_RS(list);                                   \
+                            _ls_qsize--;                                       \
+                        } else if (_ls_qsize == 0 || !_ls_q) {                 \
+                            _ls_e = _ls_p;                                     \
+                            UTLIST_SV(_ls_p, list);                            \
+                            _ls_p = UTLIST_NEXT(_ls_p, list, next);            \
+                            UTLIST_RS(list);                                   \
+                            _ls_psize--;                                       \
+                        } else if (cmp(_ls_p, _ls_q) <= 0) {                   \
+                            _ls_e = _ls_p;                                     \
+                            UTLIST_SV(_ls_p, list);                            \
+                            _ls_p = UTLIST_NEXT(_ls_p, list, next);            \
+                            UTLIST_RS(list);                                   \
+                            _ls_psize--;                                       \
+                        } else {                                               \
+                            _ls_e = _ls_q;                                     \
+                            UTLIST_SV(_ls_q, list);                            \
+                            _ls_q = UTLIST_NEXT(_ls_q, list, next);            \
+                            UTLIST_RS(list);                                   \
+                            _ls_qsize--;                                       \
+                        }                                                      \
+                        if (_ls_tail) {                                        \
+                            UTLIST_SV(_ls_tail, list);                         \
+                            UTLIST_NEXTASGN(_ls_tail, list, _ls_e, next);      \
+                            UTLIST_RS(list);                                   \
+                        } else {                                               \
+                            UTLIST_CASTASGN(list, _ls_e);                      \
+                        }                                                      \
+                        _ls_tail = _ls_e;                                      \
+                    }                                                          \
+                    _ls_p = _ls_q;                                             \
+                }                                                              \
+                if (_ls_tail) {                                                \
+                    UTLIST_SV(_ls_tail, list);                                 \
+                    UTLIST_NEXTASGN(_ls_tail, list, NULL, next);               \
+                    UTLIST_RS(list);                                           \
+                }                                                              \
+                if (_ls_nmerges <= 1) {                                        \
+                    _ls_looping = 0;                                           \
+                }                                                              \
+                _ls_insize *= 2;                                               \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+#define DL_SORT(list, cmp) DL_SORT2(list, cmp, prev, next)
+
+#define DL_SORT2(list, cmp, prev, next)                                        \
+    do {                                                                       \
+        LDECLTYPE(list) _ls_p;                                                 \
+        LDECLTYPE(list) _ls_q;                                                 \
+        LDECLTYPE(list) _ls_e;                                                 \
+        LDECLTYPE(list) _ls_tail;                                              \
+        IF_NO_DECLTYPE(LDECLTYPE(list) _tmp;)                                  \
+        int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping; \
+        if (list) {                                                            \
+            _ls_insize = 1;                                                    \
+            _ls_looping = 1;                                                   \
+            while (_ls_looping) {                                              \
+                UTLIST_CASTASGN(_ls_p, list);                                  \
+                (list) = NULL;                                                 \
+                _ls_tail = NULL;                                               \
+                _ls_nmerges = 0;                                               \
+                while (_ls_p) {                                                \
+                    _ls_nmerges++;                                             \
+                    _ls_q = _ls_p;                                             \
+                    _ls_psize = 0;                                             \
+                    for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) {             \
+                        _ls_psize++;                                           \
+                        UTLIST_SV(_ls_q, list);                                \
+                        _ls_q = UTLIST_NEXT(_ls_q, list, next);                \
+                        UTLIST_RS(list);                                       \
+                        if (!_ls_q)                                            \
+                            break;                                             \
+                    }                                                          \
+                    _ls_qsize = _ls_insize;                                    \
+                    while ((_ls_psize > 0) || ((_ls_qsize > 0) && _ls_q)) {    \
+                        if (_ls_psize == 0) {                                  \
+                            _ls_e = _ls_q;                                     \
+                            UTLIST_SV(_ls_q, list);                            \
+                            _ls_q = UTLIST_NEXT(_ls_q, list, next);            \
+                            UTLIST_RS(list);                                   \
+                            _ls_qsize--;                                       \
+                        } else if ((_ls_qsize == 0) || (!_ls_q)) {             \
+                            _ls_e = _ls_p;                                     \
+                            UTLIST_SV(_ls_p, list);                            \
+                            _ls_p = UTLIST_NEXT(_ls_p, list, next);            \
+                            UTLIST_RS(list);                                   \
+                            _ls_psize--;                                       \
+                        } else if (cmp(_ls_p, _ls_q) <= 0) {                   \
+                            _ls_e = _ls_p;                                     \
+                            UTLIST_SV(_ls_p, list);                            \
+                            _ls_p = UTLIST_NEXT(_ls_p, list, next);            \
+                            UTLIST_RS(list);                                   \
+                            _ls_psize--;                                       \
+                        } else {                                               \
+                            _ls_e = _ls_q;                                     \
+                            UTLIST_SV(_ls_q, list);                            \
+                            _ls_q = UTLIST_NEXT(_ls_q, list, next);            \
+                            UTLIST_RS(list);                                   \
+                            _ls_qsize--;                                       \
+                        }                                                      \
+                        if (_ls_tail) {                                        \
+                            UTLIST_SV(_ls_tail, list);                         \
+                            UTLIST_NEXTASGN(_ls_tail, list, _ls_e, next);      \
+                            UTLIST_RS(list);                                   \
+                        } else {                                               \
+                            UTLIST_CASTASGN(list, _ls_e);                      \
+                        }                                                      \
+                        UTLIST_SV(_ls_e, list);                                \
+                        UTLIST_PREVASGN(_ls_e, list, _ls_tail, prev);          \
+                        UTLIST_RS(list);                                       \
+                        _ls_tail = _ls_e;                                      \
+                    }                                                          \
+                    _ls_p = _ls_q;                                             \
+                }                                                              \
+                UTLIST_CASTASGN((list)->prev, _ls_tail);                       \
+                UTLIST_SV(_ls_tail, list);                                     \
+                UTLIST_NEXTASGN(_ls_tail, list, NULL, next);                   \
+                UTLIST_RS(list);                                               \
+                if (_ls_nmerges <= 1) {                                        \
+                    _ls_looping = 0;                                           \
+                }                                                              \
+                _ls_insize *= 2;                                               \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+#define CDL_SORT(list, cmp) CDL_SORT2(list, cmp, prev, next)
+
+#define CDL_SORT2(list, cmp, prev, next)                                       \
+    do {                                                                       \
+        LDECLTYPE(list) _ls_p;                                                 \
+        LDECLTYPE(list) _ls_q;                                                 \
+        LDECLTYPE(list) _ls_e;                                                 \
+        LDECLTYPE(list) _ls_tail;                                              \
+        LDECLTYPE(list) _ls_oldhead;                                           \
+        LDECLTYPE(list) _tmp;                                                  \
+        int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping; \
+        if (list) {                                                            \
+            _ls_insize = 1;                                                    \
+            _ls_looping = 1;                                                   \
+            while (_ls_looping) {                                              \
+                UTLIST_CASTASGN(_ls_p, list);                                  \
+                UTLIST_CASTASGN(_ls_oldhead, list);                            \
+                (list) = NULL;                                                 \
+                _ls_tail = NULL;                                               \
+                _ls_nmerges = 0;                                               \
+                while (_ls_p) {                                                \
+                    _ls_nmerges++;                                             \
+                    _ls_q = _ls_p;                                             \
+                    _ls_psize = 0;                                             \
+                    for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) {             \
+                        _ls_psize++;                                           \
+                        UTLIST_SV(_ls_q, list);                                \
+                        if (UTLIST_NEXT(_ls_q, list, next) == _ls_oldhead) {   \
+                            _ls_q = NULL;                                      \
+                        } else {                                               \
+                            _ls_q = UTLIST_NEXT(_ls_q, list, next);            \
+                        }                                                      \
+                        UTLIST_RS(list);                                       \
+                        if (!_ls_q)                                            \
+                            break;                                             \
+                    }                                                          \
+                    _ls_qsize = _ls_insize;                                    \
+                    while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) {        \
+                        if (_ls_psize == 0) {                                  \
+                            _ls_e = _ls_q;                                     \
+                            UTLIST_SV(_ls_q, list);                            \
+                            _ls_q = UTLIST_NEXT(_ls_q, list, next);            \
+                            UTLIST_RS(list);                                   \
+                            _ls_qsize--;                                       \
+                            if (_ls_q == _ls_oldhead) {                        \
+                                _ls_q = NULL;                                  \
+                            }                                                  \
+                        } else if (_ls_qsize == 0 || !_ls_q) {                 \
+                            _ls_e = _ls_p;                                     \
+                            UTLIST_SV(_ls_p, list);                            \
+                            _ls_p = UTLIST_NEXT(_ls_p, list, next);            \
+                            UTLIST_RS(list);                                   \
+                            _ls_psize--;                                       \
+                            if (_ls_p == _ls_oldhead) {                        \
+                                _ls_p = NULL;                                  \
+                            }                                                  \
+                        } else if (cmp(_ls_p, _ls_q) <= 0) {                   \
+                            _ls_e = _ls_p;                                     \
+                            UTLIST_SV(_ls_p, list);                            \
+                            _ls_p = UTLIST_NEXT(_ls_p, list, next);            \
+                            UTLIST_RS(list);                                   \
+                            _ls_psize--;                                       \
+                            if (_ls_p == _ls_oldhead) {                        \
+                                _ls_p = NULL;                                  \
+                            }                                                  \
+                        } else {                                               \
+                            _ls_e = _ls_q;                                     \
+                            UTLIST_SV(_ls_q, list);                            \
+                            _ls_q = UTLIST_NEXT(_ls_q, list, next);            \
+                            UTLIST_RS(list);                                   \
+                            _ls_qsize--;                                       \
+                            if (_ls_q == _ls_oldhead) {                        \
+                                _ls_q = NULL;                                  \
+                            }                                                  \
+                        }                                                      \
+                        if (_ls_tail) {                                        \
+                            UTLIST_SV(_ls_tail, list);                         \
+                            UTLIST_NEXTASGN(_ls_tail, list, _ls_e, next);      \
+                            UTLIST_RS(list);                                   \
+                        } else {                                               \
+                            UTLIST_CASTASGN(list, _ls_e);                      \
+                        }                                                      \
+                        UTLIST_SV(_ls_e, list);                                \
+                        UTLIST_PREVASGN(_ls_e, list, _ls_tail, prev);          \
+                        UTLIST_RS(list);                                       \
+                        _ls_tail = _ls_e;                                      \
+                    }                                                          \
+                    _ls_p = _ls_q;                                             \
+                }                                                              \
+                UTLIST_CASTASGN((list)->prev, _ls_tail);                       \
+                UTLIST_CASTASGN(_tmp, list);                                   \
+                UTLIST_SV(_ls_tail, list);                                     \
+                UTLIST_NEXTASGN(_ls_tail, list, _tmp, next);                   \
+                UTLIST_RS(list);                                               \
+                if (_ls_nmerges <= 1) {                                        \
+                    _ls_looping = 0;                                           \
+                }                                                              \
+                _ls_insize *= 2;                                               \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+/******************************************************************************
+ * singly linked list macros (non-circular)                                   *
+ *****************************************************************************/
+#define LL_PREPEND(head, add) LL_PREPEND2(head, add, next)
+
+#define LL_PREPEND2(head, add, next)                                           \
+    do {                                                                       \
+        (add)->next = (head);                                                  \
+        (head) = (add);                                                        \
+    } while (0)
+
+#define LL_CONCAT(head1, head2) LL_CONCAT2(head1, head2, next)
+
+#define LL_CONCAT2(head1, head2, next)                                         \
+    do {                                                                       \
+        LDECLTYPE(head1) _tmp;                                                 \
+        if (head1) {                                                           \
+            _tmp = (head1);                                                    \
+            while (_tmp->next) {                                               \
+                _tmp = _tmp->next;                                             \
+            }                                                                  \
+            _tmp->next = (head2);                                              \
+        } else {                                                               \
+            (head1) = (head2);                                                 \
+        }                                                                      \
+    } while (0)
+
+#define LL_APPEND(head, add) LL_APPEND2(head, add, next)
+
+#define LL_APPEND2(head, add, next)                                            \
+    do {                                                                       \
+        LDECLTYPE(head) _tmp;                                                  \
+        (add)->next = NULL;                                                    \
+        if (head) {                                                            \
+            _tmp = (head);                                                     \
+            while (_tmp->next) {                                               \
+                _tmp = _tmp->next;                                             \
+            }                                                                  \
+            _tmp->next = (add);                                                \
+        } else {                                                               \
+            (head) = (add);                                                    \
+        }                                                                      \
+    } while (0)
+
+#define LL_INSERT_INORDER(head, add, cmp)                                      \
+    LL_INSERT_INORDER2(head, add, cmp, next)
+
+#define LL_INSERT_INORDER2(head, add, cmp, next)                               \
+    do {                                                                       \
+        LDECLTYPE(head) _tmp;                                                  \
+        if (head) {                                                            \
+            LL_LOWER_BOUND2(head, _tmp, add, cmp, next);                       \
+            LL_APPEND_ELEM2(head, _tmp, add, next);                            \
+        } else {                                                               \
+            (head) = (add);                                                    \
+            (head)->next = NULL;                                               \
+        }                                                                      \
+    } while (0)
+
+#define LL_LOWER_BOUND(head, elt, like, cmp)                                   \
+    LL_LOWER_BOUND2(head, elt, like, cmp, next)
+
+#define LL_LOWER_BOUND2(head, elt, like, cmp, next)                            \
+    do {                                                                       \
+        if ((head) == NULL || (cmp(head, like)) >= 0) {                        \
+            (elt) = NULL;                                                      \
+        } else {                                                               \
+            for ((elt) = (head); (elt)->next != NULL; (elt) = (elt)->next) {   \
+                if (cmp((elt)->next, like) >= 0) {                             \
+                    break;                                                     \
+                }                                                              \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+#define LL_DELETE(head, del) LL_DELETE2(head, del, next)
+
+#define LL_DELETE2(head, del, next)                                            \
+    do {                                                                       \
+        LDECLTYPE(head) _tmp;                                                  \
+        if ((head) == (del)) {                                                 \
+            (head) = (head)->next;                                             \
+        } else {                                                               \
+            _tmp = (head);                                                     \
+            while (_tmp->next && (_tmp->next != (del))) {                      \
+                _tmp = _tmp->next;                                             \
+            }                                                                  \
+            if (_tmp->next) {                                                  \
+                _tmp->next = (del)->next;                                      \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+#define LL_COUNT(head, el, counter) LL_COUNT2(head, el, counter, next)
+
+#define LL_COUNT2(head, el, counter, next)                                     \
+    do {                                                                       \
+        (counter) = 0;                                                         \
+        LL_FOREACH2(head, el, next) { ++(counter); }                           \
+    } while (0)
+
+#define LL_FOREACH(head, el) LL_FOREACH2(head, el, next)
+
+#define LL_FOREACH2(head, el, next) for ((el) = (head); el; (el) = (el)->next)
+
+#define LL_FOREACH_SAFE(head, el, tmp) LL_FOREACH_SAFE2(head, el, tmp, next)
+
+#define LL_FOREACH_SAFE2(head, el, tmp, next)                                  \
+    for ((el) = (head); (el) && ((tmp) = (el)->next, 1); (el) = (tmp))
+
+#define LL_SEARCH_SCALAR(head, out, field, val)                                \
+    LL_SEARCH_SCALAR2(head, out, field, val, next)
+
+#define LL_SEARCH_SCALAR2(head, out, field, val, next)                         \
+    do {                                                                       \
+        LL_FOREACH2(head, out, next) {                                         \
+            if ((out)->field == (val))                                         \
+                break;                                                         \
+        }                                                                      \
+    } while (0)
+
+#define LL_SEARCH(head, out, elt, cmp) LL_SEARCH2(head, out, elt, cmp, next)
+
+#define LL_SEARCH2(head, out, elt, cmp, next)                                  \
+    do {                                                                       \
+        LL_FOREACH2(head, out, next) {                                         \
+            if ((cmp(out, elt)) == 0)                                          \
+                break;                                                         \
+        }                                                                      \
+    } while (0)
+
+#define LL_REPLACE_ELEM2(head, el, add, next)                                  \
+    do {                                                                       \
+        LDECLTYPE(head) _tmp;                                                  \
+        assert((head) != NULL);                                                \
+        assert((el) != NULL);                                                  \
+        assert((add) != NULL);                                                 \
+        (add)->next = (el)->next;                                              \
+        if ((head) == (el)) {                                                  \
+            (head) = (add);                                                    \
+        } else {                                                               \
+            _tmp = (head);                                                     \
+            while (_tmp->next && (_tmp->next != (el))) {                       \
+                _tmp = _tmp->next;                                             \
+            }                                                                  \
+            if (_tmp->next) {                                                  \
+                _tmp->next = (add);                                            \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+#define LL_REPLACE_ELEM(head, el, add) LL_REPLACE_ELEM2(head, el, add, next)
+
+#define LL_PREPEND_ELEM2(head, el, add, next)                                  \
+    do {                                                                       \
+        if (el) {                                                              \
+            LDECLTYPE(head) _tmp;                                              \
+            assert((head) != NULL);                                            \
+            assert((add) != NULL);                                             \
+            (add)->next = (el);                                                \
+            if ((head) == (el)) {                                              \
+                (head) = (add);                                                \
+            } else {                                                           \
+                _tmp = (head);                                                 \
+                while (_tmp->next && (_tmp->next != (el))) {                   \
+                    _tmp = _tmp->next;                                         \
+                }                                                              \
+                if (_tmp->next) {                                              \
+                    _tmp->next = (add);                                        \
+                }                                                              \
+            }                                                                  \
+        } else {                                                               \
+            LL_APPEND2(head, add, next);                                       \
+        }                                                                      \
+    } while (0)
+
+#define LL_PREPEND_ELEM(head, el, add) LL_PREPEND_ELEM2(head, el, add, next)
+
+#define LL_APPEND_ELEM2(head, el, add, next)                                   \
+    do {                                                                       \
+        if (el) {                                                              \
+            assert((head) != NULL);                                            \
+            assert((add) != NULL);                                             \
+            (add)->next = (el)->next;                                          \
+            (el)->next = (add);                                                \
+        } else {                                                               \
+            LL_PREPEND2(head, add, next);                                      \
+        }                                                                      \
+    } while (0)
+
+#define LL_APPEND_ELEM(head, el, add) LL_APPEND_ELEM2(head, el, add, next)
+
+#ifdef NO_DECLTYPE
+/* Here are VS2008 / NO_DECLTYPE replacements for a few functions */
+
+#undef LL_CONCAT2
+#define LL_CONCAT2(head1, head2, next)                                         \
+    do {                                                                       \
+        char *_tmp;                                                            \
+        if (head1) {                                                           \
+            _tmp = (char *)(head1);                                            \
+            while ((head1)->next) {                                            \
+                (head1) = (head1)->next;                                       \
+            }                                                                  \
+            (head1)->next = (head2);                                           \
+            UTLIST_RS(head1);                                                  \
+        } else {                                                               \
+            (head1) = (head2);                                                 \
+        }                                                                      \
+    } while (0)
+
+#undef LL_APPEND2
+#define LL_APPEND2(head, add, next)                                            \
+    do {                                                                       \
+        if (head) {                                                            \
+            (add)->next = head; /* use add->next as a temp variable */         \
+            while ((add)->next->next) {                                        \
+                (add)->next = (add)->next->next;                               \
+            }                                                                  \
+            (add)->next->next = (add);                                         \
+        } else {                                                               \
+            (head) = (add);                                                    \
+        }                                                                      \
+        (add)->next = NULL;                                                    \
+    } while (0)
+
+#undef LL_INSERT_INORDER2
+#define LL_INSERT_INORDER2(head, add, cmp, next)                               \
+    do {                                                                       \
+        if ((head) == NULL || (cmp(head, add)) >= 0) {                         \
+            (add)->next = (head);                                              \
+            (head) = (add);                                                    \
+        } else {                                                               \
+            char *_tmp = (char *)(head);                                       \
+            while ((head)->next != NULL && (cmp((head)->next, add)) < 0) {     \
+                (head) = (head)->next;                                         \
+            }                                                                  \
+            (add)->next = (head)->next;                                        \
+            (head)->next = (add);                                              \
+            UTLIST_RS(head);                                                   \
+        }                                                                      \
+    } while (0)
+
+#undef LL_DELETE2
+#define LL_DELETE2(head, del, next)                                            \
+    do {                                                                       \
+        if ((head) == (del)) {                                                 \
+            (head) = (head)->next;                                             \
+        } else {                                                               \
+            char *_tmp = (char *)(head);                                       \
+            while ((head)->next && ((head)->next != (del))) {                  \
+                (head) = (head)->next;                                         \
+            }                                                                  \
+            if ((head)->next) {                                                \
+                (head)->next = ((del)->next);                                  \
+            }                                                                  \
+            UTLIST_RS(head);                                                   \
+        }                                                                      \
+    } while (0)
+
+#undef LL_REPLACE_ELEM2
+#define LL_REPLACE_ELEM2(head, el, add, next)                                  \
+    do {                                                                       \
+        assert((head) != NULL);                                                \
+        assert((el) != NULL);                                                  \
+        assert((add) != NULL);                                                 \
+        if ((head) == (el)) {                                                  \
+            (head) = (add);                                                    \
+        } else {                                                               \
+            (add)->next = head;                                                \
+            while ((add)->next->next && ((add)->next->next != (el))) {         \
+                (add)->next = (add)->next->next;                               \
+            }                                                                  \
+            if ((add)->next->next) {                                           \
+                (add)->next->next = (add);                                     \
+            }                                                                  \
+        }                                                                      \
+        (add)->next = (el)->next;                                              \
+    } while (0)
+
+#undef LL_PREPEND_ELEM2
+#define LL_PREPEND_ELEM2(head, el, add, next)                                  \
+    do {                                                                       \
+        if (el) {                                                              \
+            assert((head) != NULL);                                            \
+            assert((add) != NULL);                                             \
+            if ((head) == (el)) {                                              \
+                (head) = (add);                                                \
+            } else {                                                           \
+                (add)->next = (head);                                          \
+                while ((add)->next->next && ((add)->next->next != (el))) {     \
+                    (add)->next = (add)->next->next;                           \
+                }                                                              \
+                if ((add)->next->next) {                                       \
+                    (add)->next->next = (add);                                 \
+                }                                                              \
+            }                                                                  \
+            (add)->next = (el);                                                \
+        } else {                                                               \
+            LL_APPEND2(head, add, next);                                       \
+        }                                                                      \
+    } while (0)
+
+#endif /* NO_DECLTYPE */
+
+/******************************************************************************
+ * doubly linked list macros (non-circular)                                   *
+ *****************************************************************************/
+#define DL_PREPEND(head, add) DL_PREPEND2(head, add, prev, next)
+
+#define DL_PREPEND2(head, add, prev, next)                                     \
+    do {                                                                       \
+        (add)->next = (head);                                                  \
+        if (head) {                                                            \
+            (add)->prev = (head)->prev;                                        \
+            (head)->prev = (add);                                              \
+        } else {                                                               \
+            (add)->prev = (add);                                               \
+        }                                                                      \
+        (head) = (add);                                                        \
+    } while (0)
+
+#define DL_APPEND(head, add) DL_APPEND2(head, add, prev, next)
+
+#define DL_APPEND2(head, add, prev, next)                                      \
+    do {                                                                       \
+        if (head) {                                                            \
+            (add)->prev = (head)->prev;                                        \
+            (head)->prev->next = (add);                                        \
+            (head)->prev = (add);                                              \
+            (add)->next = NULL;                                                \
+        } else {                                                               \
+            (head) = (add);                                                    \
+            (head)->prev = (head);                                             \
+            (head)->next = NULL;                                               \
+        }                                                                      \
+    } while (0)
+
+#define DL_INSERT_INORDER(head, add, cmp)                                      \
+    DL_INSERT_INORDER2(head, add, cmp, prev, next)
+
+#define DL_INSERT_INORDER2(head, add, cmp, prev, next)                         \
+    do {                                                                       \
+        LDECLTYPE(head) _tmp;                                                  \
+        if (head) {                                                            \
+            DL_LOWER_BOUND2(head, _tmp, add, cmp, next);                       \
+            DL_APPEND_ELEM2(head, _tmp, add, prev, next);                      \
+        } else {                                                               \
+            (head) = (add);                                                    \
+            (head)->prev = (head);                                             \
+            (head)->next = NULL;                                               \
+        }                                                                      \
+    } while (0)
+
+#define DL_LOWER_BOUND(head, elt, like, cmp)                                   \
+    DL_LOWER_BOUND2(head, elt, like, cmp, next)
+
+#define DL_LOWER_BOUND2(head, elt, like, cmp, next)                            \
+    do {                                                                       \
+        if ((head) == NULL || (cmp(head, like)) >= 0) {                        \
+            (elt) = NULL;                                                      \
+        } else {                                                               \
+            for ((elt) = (head); (elt)->next != NULL; (elt) = (elt)->next) {   \
+                if ((cmp((elt)->next, like)) >= 0) {                           \
+                    break;                                                     \
+                }                                                              \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+#define DL_CONCAT(head1, head2) DL_CONCAT2(head1, head2, prev, next)
+
+#define DL_CONCAT2(head1, head2, prev, next)                                   \
+    do {                                                                       \
+        LDECLTYPE(head1) _tmp;                                                 \
+        if (head2) {                                                           \
+            if (head1) {                                                       \
+                UTLIST_CASTASGN(_tmp, (head2)->prev);                          \
+                (head2)->prev = (head1)->prev;                                 \
+                (head1)->prev->next = (head2);                                 \
+                UTLIST_CASTASGN((head1)->prev, _tmp);                          \
+            } else {                                                           \
+                (head1) = (head2);                                             \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+#define DL_DELETE(head, del) DL_DELETE2(head, del, prev, next)
+
+#define DL_DELETE2(head, del, prev, next)                                      \
+    do {                                                                       \
+        assert((head) != NULL);                                                \
+        assert((del)->prev != NULL);                                           \
+        if ((del)->prev == (del)) {                                            \
+            (head) = NULL;                                                     \
+        } else if ((del) == (head)) {                                          \
+            assert((del)->next != NULL);                                       \
+            (del)->next->prev = (del)->prev;                                   \
+            (head) = (del)->next;                                              \
+        } else {                                                               \
+            (del)->prev->next = (del)->next;                                   \
+            if ((del)->next) {                                                 \
+                (del)->next->prev = (del)->prev;                               \
+            } else {                                                           \
+                (head)->prev = (del)->prev;                                    \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+#define DL_COUNT(head, el, counter) DL_COUNT2(head, el, counter, next)
+
+#define DL_COUNT2(head, el, counter, next)                                     \
+    do {                                                                       \
+        (counter) = 0;                                                         \
+        DL_FOREACH2(head, el, next) { ++(counter); }                           \
+    } while (0)
+
+#define DL_FOREACH(head, el) DL_FOREACH2(head, el, next)
+
+#define DL_FOREACH2(head, el, next) for ((el) = (head); el; (el) = (el)->next)
+
+/* this version is safe for deleting the elements during iteration */
+#define DL_FOREACH_SAFE(head, el, tmp) DL_FOREACH_SAFE2(head, el, tmp, next)
+
+#define DL_FOREACH_SAFE2(head, el, tmp, next)                                  \
+    for ((el) = (head); (el) && ((tmp) = (el)->next, 1); (el) = (tmp))
+
+/* these are identical to their singly-linked list counterparts */
+#define DL_SEARCH_SCALAR LL_SEARCH_SCALAR
+#define DL_SEARCH LL_SEARCH
+#define DL_SEARCH_SCALAR2 LL_SEARCH_SCALAR2
+#define DL_SEARCH2 LL_SEARCH2
+
+#define DL_REPLACE_ELEM2(head, el, add, prev, next)                            \
+    do {                                                                       \
+        assert((head) != NULL);                                                \
+        assert((el) != NULL);                                                  \
+        assert((add) != NULL);                                                 \
+        if ((head) == (el)) {                                                  \
+            (head) = (add);                                                    \
+            (add)->next = (el)->next;                                          \
+            if ((el)->next == NULL) {                                          \
+                (add)->prev = (add);                                           \
+            } else {                                                           \
+                (add)->prev = (el)->prev;                                      \
+                (add)->next->prev = (add);                                     \
+            }                                                                  \
+        } else {                                                               \
+            (add)->next = (el)->next;                                          \
+            (add)->prev = (el)->prev;                                          \
+            (add)->prev->next = (add);                                         \
+            if ((el)->next == NULL) {                                          \
+                (head)->prev = (add);                                          \
+            } else {                                                           \
+                (add)->next->prev = (add);                                     \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+#define DL_REPLACE_ELEM(head, el, add)                                         \
+    DL_REPLACE_ELEM2(head, el, add, prev, next)
+
+#define DL_PREPEND_ELEM2(head, el, add, prev, next)                            \
+    do {                                                                       \
+        if (el) {                                                              \
+            assert((head) != NULL);                                            \
+            assert((add) != NULL);                                             \
+            (add)->next = (el);                                                \
+            (add)->prev = (el)->prev;                                          \
+            (el)->prev = (add);                                                \
+            if ((head) == (el)) {                                              \
+                (head) = (add);                                                \
+            } else {                                                           \
+                (add)->prev->next = (add);                                     \
+            }                                                                  \
+        } else {                                                               \
+            DL_APPEND2(head, add, prev, next);                                 \
+        }                                                                      \
+    } while (0)
+
+#define DL_PREPEND_ELEM(head, el, add)                                         \
+    DL_PREPEND_ELEM2(head, el, add, prev, next)
+
+#define DL_APPEND_ELEM2(head, el, add, prev, next)                             \
+    do {                                                                       \
+        if (el) {                                                              \
+            assert((head) != NULL);                                            \
+            assert((add) != NULL);                                             \
+            (add)->next = (el)->next;                                          \
+            (add)->prev = (el);                                                \
+            (el)->next = (add);                                                \
+            if ((add)->next) {                                                 \
+                (add)->next->prev = (add);                                     \
+            } else {                                                           \
+                (head)->prev = (add);                                          \
+            }                                                                  \
+        } else {                                                               \
+            DL_PREPEND2(head, add, prev, next);                                \
+        }                                                                      \
+    } while (0)
+
+#define DL_APPEND_ELEM(head, el, add) DL_APPEND_ELEM2(head, el, add, prev, next)
+
+#ifdef NO_DECLTYPE
+/* Here are VS2008 / NO_DECLTYPE replacements for a few functions */
+
+#undef DL_INSERT_INORDER2
+#define DL_INSERT_INORDER2(head, add, cmp, prev, next)                         \
+    do {                                                                       \
+        if ((head) == NULL) {                                                  \
+            (add)->prev = (add);                                               \
+            (add)->next = NULL;                                                \
+            (head) = (add);                                                    \
+        } else if ((cmp(head, add)) >= 0) {                                    \
+            (add)->prev = (head)->prev;                                        \
+            (add)->next = (head);                                              \
+            (head)->prev = (add);                                              \
+            (head) = (add);                                                    \
+        } else {                                                               \
+            char *_tmp = (char *)(head);                                       \
+            while ((head)->next && (cmp((head)->next, add)) < 0) {             \
+                (head) = (head)->next;                                         \
+            }                                                                  \
+            (add)->prev = (head);                                              \
+            (add)->next = (head)->next;                                        \
+            (head)->next = (add);                                              \
+            UTLIST_RS(head);                                                   \
+            if ((add)->next) {                                                 \
+                (add)->next->prev = (add);                                     \
+            } else {                                                           \
+                (head)->prev = (add);                                          \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+#endif /* NO_DECLTYPE */
+
+/******************************************************************************
+ * circular doubly linked list macros                                         *
+ *****************************************************************************/
+#define CDL_APPEND(head, add) CDL_APPEND2(head, add, prev, next)
+
+#define CDL_APPEND2(head, add, prev, next)                                     \
+    do {                                                                       \
+        if (head) {                                                            \
+            (add)->prev = (head)->prev;                                        \
+            (add)->next = (head);                                              \
+            (head)->prev = (add);                                              \
+            (add)->prev->next = (add);                                         \
+        } else {                                                               \
+            (add)->prev = (add);                                               \
+            (add)->next = (add);                                               \
+            (head) = (add);                                                    \
+        }                                                                      \
+    } while (0)
+
+#define CDL_PREPEND(head, add) CDL_PREPEND2(head, add, prev, next)
+
+#define CDL_PREPEND2(head, add, prev, next)                                    \
+    do {                                                                       \
+        if (head) {                                                            \
+            (add)->prev = (head)->prev;                                        \
+            (add)->next = (head);                                              \
+            (head)->prev = (add);                                              \
+            (add)->prev->next = (add);                                         \
+        } else {                                                               \
+            (add)->prev = (add);                                               \
+            (add)->next = (add);                                               \
+        }                                                                      \
+        (head) = (add);                                                        \
+    } while (0)
+
+#define CDL_INSERT_INORDER(head, add, cmp)                                     \
+    CDL_INSERT_INORDER2(head, add, cmp, prev, next)
+
+#define CDL_INSERT_INORDER2(head, add, cmp, prev, next)                        \
+    do {                                                                       \
+        LDECLTYPE(head) _tmp;                                                  \
+        if (head) {                                                            \
+            CDL_LOWER_BOUND2(head, _tmp, add, cmp, next);                      \
+            CDL_APPEND_ELEM2(head, _tmp, add, prev, next);                     \
+        } else {                                                               \
+            (head) = (add);                                                    \
+            (head)->next = (head);                                             \
+            (head)->prev = (head);                                             \
+        }                                                                      \
+    } while (0)
+
+#define CDL_LOWER_BOUND(head, elt, like, cmp)                                  \
+    CDL_LOWER_BOUND2(head, elt, like, cmp, next)
+
+#define CDL_LOWER_BOUND2(head, elt, like, cmp, next)                           \
+    do {                                                                       \
+        if ((head) == NULL || (cmp(head, like)) >= 0) {                        \
+            (elt) = NULL;                                                      \
+        } else {                                                               \
+            for ((elt) = (head); (elt)->next != (head); (elt) = (elt)->next) { \
+                if ((cmp((elt)->next, like)) >= 0) {                           \
+                    break;                                                     \
+                }                                                              \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+#define CDL_DELETE(head, del) CDL_DELETE2(head, del, prev, next)
+
+#define CDL_DELETE2(head, del, prev, next)                                     \
+    do {                                                                       \
+        if (((head) == (del)) && ((head)->next == (head))) {                   \
+            (head) = NULL;                                                     \
+        } else {                                                               \
+            (del)->next->prev = (del)->prev;                                   \
+            (del)->prev->next = (del)->next;                                   \
+            if ((del) == (head))                                               \
+                (head) = (del)->next;                                          \
+        }                                                                      \
+    } while (0)
+
+#define CDL_COUNT(head, el, counter) CDL_COUNT2(head, el, counter, next)
+
+#define CDL_COUNT2(head, el, counter, next)                                    \
+    do {                                                                       \
+        (counter) = 0;                                                         \
+        CDL_FOREACH2(head, el, next) { ++(counter); }                          \
+    } while (0)
+
+#define CDL_FOREACH(head, el) CDL_FOREACH2(head, el, next)
+
+#define CDL_FOREACH2(head, el, next)                                           \
+    for ((el) = (head); el; (el) = (((el)->next == (head)) ? NULL : (el)->next))
+
+#define CDL_FOREACH_SAFE(head, el, tmp1, tmp2)                                 \
+    CDL_FOREACH_SAFE2(head, el, tmp1, tmp2, prev, next)
+
+#define CDL_FOREACH_SAFE2(head, el, tmp1, tmp2, prev, next)                    \
+    for ((el) = (head), (tmp1) = (head) ? (head)->prev : NULL;                 \
+         (el) && ((tmp2) = (el)->next, 1);                                     \
+         (el) = ((el) == (tmp1) ? NULL : (tmp2)))
+
+#define CDL_SEARCH_SCALAR(head, out, field, val)                               \
+    CDL_SEARCH_SCALAR2(head, out, field, val, next)
+
+#define CDL_SEARCH_SCALAR2(head, out, field, val, next)                        \
+    do {                                                                       \
+        CDL_FOREACH2(head, out, next) {                                        \
+            if ((out)->field == (val))                                         \
+                break;                                                         \
+        }                                                                      \
+    } while (0)
+
+#define CDL_SEARCH(head, out, elt, cmp) CDL_SEARCH2(head, out, elt, cmp, next)
+
+#define CDL_SEARCH2(head, out, elt, cmp, next)                                 \
+    do {                                                                       \
+        CDL_FOREACH2(head, out, next) {                                        \
+            if ((cmp(out, elt)) == 0)                                          \
+                break;                                                         \
+        }                                                                      \
+    } while (0)
+
+#define CDL_REPLACE_ELEM2(head, el, add, prev, next)                           \
+    do {                                                                       \
+        assert((head) != NULL);                                                \
+        assert((el) != NULL);                                                  \
+        assert((add) != NULL);                                                 \
+        if ((el)->next == (el)) {                                              \
+            (add)->next = (add);                                               \
+            (add)->prev = (add);                                               \
+            (head) = (add);                                                    \
+        } else {                                                               \
+            (add)->next = (el)->next;                                          \
+            (add)->prev = (el)->prev;                                          \
+            (add)->next->prev = (add);                                         \
+            (add)->prev->next = (add);                                         \
+            if ((head) == (el)) {                                              \
+                (head) = (add);                                                \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+#define CDL_REPLACE_ELEM(head, el, add)                                        \
+    CDL_REPLACE_ELEM2(head, el, add, prev, next)
+
+#define CDL_PREPEND_ELEM2(head, el, add, prev, next)                           \
+    do {                                                                       \
+        if (el) {                                                              \
+            assert((head) != NULL);                                            \
+            assert((add) != NULL);                                             \
+            (add)->next = (el);                                                \
+            (add)->prev = (el)->prev;                                          \
+            (el)->prev = (add);                                                \
+            (add)->prev->next = (add);                                         \
+            if ((head) == (el)) {                                              \
+                (head) = (add);                                                \
+            }                                                                  \
+        } else {                                                               \
+            CDL_APPEND2(head, add, prev, next);                                \
+        }                                                                      \
+    } while (0)
+
+#define CDL_PREPEND_ELEM(head, el, add)                                        \
+    CDL_PREPEND_ELEM2(head, el, add, prev, next)
+
+#define CDL_APPEND_ELEM2(head, el, add, prev, next)                            \
+    do {                                                                       \
+        if (el) {                                                              \
+            assert((head) != NULL);                                            \
+            assert((add) != NULL);                                             \
+            (add)->next = (el)->next;                                          \
+            (add)->prev = (el);                                                \
+            (el)->next = (add);                                                \
+            (add)->next->prev = (add);                                         \
+        } else {                                                               \
+            CDL_PREPEND2(head, add, prev, next);                               \
+        }                                                                      \
+    } while (0)
+
+#define CDL_APPEND_ELEM(head, el, add)                                         \
+    CDL_APPEND_ELEM2(head, el, add, prev, next)
+
+#ifdef NO_DECLTYPE
+/* Here are VS2008 / NO_DECLTYPE replacements for a few functions */
+
+#undef CDL_INSERT_INORDER2
+#define CDL_INSERT_INORDER2(head, add, cmp, prev, next)                        \
+    do {                                                                       \
+        if ((head) == NULL) {                                                  \
+            (add)->prev = (add);                                               \
+            (add)->next = (add);                                               \
+            (head) = (add);                                                    \
+        } else if ((cmp(head, add)) >= 0) {                                    \
+            (add)->prev = (head)->prev;                                        \
+            (add)->next = (head);                                              \
+            (add)->prev->next = (add);                                         \
+            (head)->prev = (add);                                              \
+            (head) = (add);                                                    \
+        } else {                                                               \
+            char *_tmp = (char *)(head);                                       \
+            while ((char *)(head)->next != _tmp &&                             \
+                   (cmp((head)->next, add)) < 0) {                             \
+                (head) = (head)->next;                                         \
+            }                                                                  \
+            (add)->prev = (head);                                              \
+            (add)->next = (head)->next;                                        \
+            (add)->next->prev = (add);                                         \
+            (head)->next = (add);                                              \
+            UTLIST_RS(head);                                                   \
+        }                                                                      \
+    } while (0)
+#endif /* NO_DECLTYPE */
+
+#endif /* UTLIST_H */
diff --git a/src/utils/CMakeLists.txt b/src/utils/CMakeLists.txt
index c7a285ce2..7125d2603 100644
--- a/src/utils/CMakeLists.txt
+++ b/src/utils/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (C) 2023-2024 Intel Corporation
+# Copyright (C) 2023-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -6,56 +6,34 @@ include(${UMF_CMAKE_SOURCE_DIR}/cmake/helpers.cmake)
 include(FindThreads)
 
 set(UMF_UTILS_SOURCES_COMMON utils_common.c utils_log.c utils_load_library.c)
-
-set(UMF_UTILS_SOURCES_POSIX utils_posix_common.c utils_posix_concurrency.c
-                            utils_posix_math.c)
-
+set(UMF_UTILS_SOURCES_POSIX utils_posix_common.c utils_posix_concurrency.c)
+set(UMF_UTILS_SOURCES_LINUX utils_linux_common.c)
+set(UMF_UTILS_SOURCES_MACOSX utils_macosx_common.c)
 set(UMF_UTILS_SOURCES_WINDOWS utils_windows_common.c
-                              utils_windows_concurrency.c utils_windows_math.c)
-
-if(UMF_USE_VALGRIND)
-    if(UMF_USE_ASAN
-       OR UMF_USE_TSAN
-       OR UMF_USE_UBSAN
-       OR UMF_USE_MSAN)
-        message(FATAL_ERROR "Cannot use valgrind and sanitizers together")
-    endif()
-
-    if(PkgConfig_FOUND)
-        pkg_check_modules(VALGRIND valgrind)
-    endif()
-    if(NOT VALGRIND_FOUND)
-        find_package(VALGRIND REQUIRED valgrind)
-    endif()
-endif()
+                              utils_windows_concurrency.c)
 
 if(LINUX OR MACOSX)
     set(UMF_UTILS_SOURCES ${UMF_UTILS_SOURCES_COMMON}
                           ${UMF_UTILS_SOURCES_POSIX})
     set(UMF_UTILS_LIBS dl)
+
+    if(LINUX)
+        set(UMF_UTILS_SOURCES ${UMF_UTILS_SOURCES} ${UMF_UTILS_SOURCES_LINUX})
+        set(UMF_UTILS_LIBS ${UMF_UTILS_LIBS} rt) # librt for shm_open()
+    elseif(MACOSX)
+        set(UMF_UTILS_SOURCES ${UMF_UTILS_SOURCES} ${UMF_UTILS_SOURCES_MACOSX})
+    endif()
 elseif(WINDOWS)
     set(UMF_UTILS_SOURCES ${UMF_UTILS_SOURCES_COMMON}
                           ${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.c b/src/utils/utils_common.c
index fc6bd58ef..225c02d2c 100644
--- a/src/utils/utils_common.c
+++ b/src/utils/utils_common.c
@@ -12,41 +12,53 @@
 #include "utils_assert.h"
 #include "utils_common.h"
 
-// align a pointer and a size
-void util_align_ptr_size(void **ptr, size_t *size, size_t alignment) {
+// align a pointer up and a size down
+void utils_align_ptr_up_size_down(void **ptr, size_t *size, size_t alignment) {
     uintptr_t p = (uintptr_t)*ptr;
     size_t s = *size;
 
-    // align pointer to 'alignment' bytes and adjust the size
+    // align the pointer up to 'alignment' bytes and adjust the size down
     size_t rest = p & (alignment - 1);
     if (rest) {
-        p += alignment - rest;
+        p = ALIGN_UP(p, alignment);
         s -= alignment - rest;
     }
 
-    ASSERT((p & (alignment - 1)) == 0);
-    ASSERT((s & (alignment - 1)) == 0);
+    ASSERT(IS_ALIGNED(p, alignment));
 
     *ptr = (void *)p;
     *size = s;
 }
 
-int util_env_var_has_str(const char *envvar, const char *str) {
-    char *value = getenv(envvar);
-    if (value && strstr(value, str)) {
-        return 1;
+// align a pointer down and a size up (for mmap()/munmap())
+void utils_align_ptr_down_size_up(void **ptr, size_t *size, size_t alignment) {
+    uintptr_t p = (uintptr_t)*ptr;
+    size_t s = *size;
+
+    // align the pointer down to 'alignment' bytes and adjust the size up
+    size_t rest = p & (alignment - 1);
+    if (rest) {
+        p = ALIGN_DOWN(p, alignment);
+        s += rest;
     }
 
-    return 0;
+    // align the size up to 'alignment' bytes
+    s = ALIGN_UP(s, alignment);
+
+    ASSERT(IS_ALIGNED(p, alignment));
+    ASSERT(IS_ALIGNED(s, alignment));
+
+    *ptr = (void *)p;
+    *size = s;
 }
 
-// check if we are running in the proxy library
-int util_is_running_in_proxy_lib(void) {
-    return util_env_var_has_str("LD_PRELOAD", "libumf_proxy.so");
+char *utils_env_var_get_str(const char *envvar, const char *str) {
+    char *value = getenv(envvar);
+    return value ? strstr(value, str) : NULL;
 }
 
-const char *util_parse_var(const char *var, const char *option,
-                           const char **extraArg) {
+const char *utils_parse_var(const char *var, const char *option,
+                            const char **extraArg) {
     const char *found = strstr(var, option);
     // ensure that found string is first on list or it's a separating semicolon
     if (!found) {
@@ -75,3 +87,47 @@ const char *util_parse_var(const char *var, const char *option,
 
     return found;
 }
+
+int utils_copy_path(const char *in_path, char out_path[], size_t path_max) {
+    // (- 1) because there should be a room for the terminating null byte ('\0')
+    size_t max_len = path_max - 1;
+
+    if (strlen(in_path) > max_len) {
+        LOG_ERR("path of the %s file is longer than %zu bytes", in_path,
+                max_len);
+        return -1;
+    }
+
+    strncpy(out_path, in_path, max_len);
+    out_path[path_max - 1] = '\0'; // the terminating null byte
+
+    return 0;
+}
+
+umf_result_t utils_translate_flags(unsigned in_flags, unsigned max,
+                                   umf_result_t (*translate_flag)(unsigned,
+                                                                  unsigned *),
+                                   unsigned *out_flags) {
+    unsigned out_f = 0;
+    for (unsigned n = 1; n < max; n <<= 1) {
+        if (in_flags & n) {
+            unsigned flag;
+            umf_result_t result = translate_flag(n, &flag);
+            if (result != UMF_RESULT_SUCCESS) {
+                return result;
+            }
+            out_f |= flag;
+            in_flags &= ~n; // clear this bit
+        }
+    }
+
+    if (in_flags != 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    *out_flags = out_f;
+    return UMF_RESULT_SUCCESS;
+}
+
+size_t utils_max(size_t a, size_t b) { return a > b ? a : b; }
+size_t utils_min(size_t a, size_t b) { return a < b ? a : b; }
diff --git a/src/utils/utils_common.h b/src/utils/utils_common.h
index 28579eb00..0fa860a0e 100644
--- a/src/utils/utils_common.h
+++ b/src/utils/utils_common.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -11,15 +11,24 @@
 #define UMF_COMMON_H 1
 
 #include <assert.h>
+#include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <umf/base.h>
+#include <umf/memory_provider.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+typedef enum umf_purge_advise_t {
+    UMF_PURGE_LAZY = 1,
+    UMF_PURGE_FORCE,
+
+    UMF_PURGE_MAX, // must be the last one
+} umf_purge_advise_t;
+
 #define DO_WHILE_EMPTY                                                         \
     do {                                                                       \
     } while (0)
@@ -29,11 +38,20 @@ extern "C" {
         expression;                                                            \
     } while (0)
 
+#define IS_POWER_OF_2(value) ((value) != 0 && ((value) & ((value)-1)) == 0)
+
+#define IS_ALIGNED(value, align)                                               \
+    ((align == 0 || (((value) & ((align)-1)) == 0)))
+#define IS_NOT_ALIGNED(value, align)                                           \
+    ((align != 0 && (((value) & ((align)-1)) != 0)))
 #define ALIGN_UP(value, align) (((value) + (align)-1) & ~((align)-1))
+#define ALIGN_UP_SAFE(value, align)                                            \
+    (((align) == 0)                                                            \
+         ? (value)                                                             \
+         : (((value) + (align)-1) < (value) ? 0 : ALIGN_UP((value), (align))))
 #define ALIGN_DOWN(value, align) ((value) & ~((align)-1))
-
-#define VALGRIND_ANNOTATE_NEW_MEMORY(p, s) DO_WHILE_EMPTY
-#define VALGRIND_HG_DRD_DISABLE_CHECKING(p, s) DO_WHILE_EMPTY
+#define ASSERT_IS_ALIGNED(value, align)                                        \
+    DO_WHILE_EXPRS(assert(IS_ALIGNED(value, align)))
 
 #ifdef _WIN32 /* Windows */
 
@@ -45,10 +63,28 @@ extern "C" {
 
 #endif /* _WIN32 */
 
+// get the address of the given string in the environment variable (or NULL)
+char *utils_env_var_get_str(const char *envvar, const char *str);
+
 // Check if the environment variable contains the given string.
-int util_env_var_has_str(const char *envvar, const char *str);
+static inline int utils_env_var_has_str(const char *envvar, const char *str) {
+    return utils_env_var_get_str(envvar, str) ? 1 : 0;
+}
 
-// util_parse_var - Parses var for a prefix,
+// check if we are running in the proxy library
+static inline int utils_is_running_in_proxy_lib(void) {
+    return utils_env_var_get_str("LD_PRELOAD", "libumf_proxy.so") ? 1 : 0;
+}
+
+// check if we are running in the proxy library with a size threshold
+static inline int utils_is_running_in_proxy_lib_with_size_threshold(void) {
+    return (utils_env_var_get_str("LD_PRELOAD", "libumf_proxy.so") &&
+            utils_env_var_get_str("UMF_PROXY", "size.threshold="))
+               ? 1
+               : 0;
+}
+
+// utils_parse_var - Parses var for a prefix,
 //                   optionally identifying a following argument.
 // Parameters:
 //   - var: String to parse  in "option1;option2,arg2;..." format, with options
@@ -62,16 +98,16 @@ int util_env_var_has_str(const char *envvar, const char *str);
 //
 // IMPORTANT: Both extraArg and return values are pointers within var,
 // and are not null-terminated.
-const char *util_parse_var(const char *var, const char *option,
-                           const char **extraArg);
+const char *utils_parse_var(const char *var, const char *option,
+                            const char **extraArg);
 
-// check if we are running in the proxy library
-int util_is_running_in_proxy_lib(void);
+size_t utils_get_page_size(void);
 
-size_t util_get_page_size(void);
+// align a pointer up and a size down
+void utils_align_ptr_up_size_down(void **ptr, size_t *size, size_t alignment);
 
-// align a pointer and a size
-void util_align_ptr_size(void **ptr, size_t *size, size_t alignment);
+// align a pointer down and a size up (for mmap()/munmap())
+void utils_align_ptr_down_size_up(void **ptr, size_t *size, size_t alignment);
 
 // get the current process ID
 int utils_getpid(void);
@@ -79,12 +115,73 @@ 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);
 
+umf_result_t utils_errno_to_umf_result(int err);
+
 // obtain a duplicate of another process's file descriptor
 umf_result_t utils_duplicate_fd(int pid, int fd_in, int *fd_out);
 
+int utils_copy_path(const char *in_path, char out_path[], size_t path_max);
+
+umf_result_t utils_translate_flags(unsigned in_flags, unsigned max,
+                                   umf_result_t (*translate_flag)(unsigned,
+                                                                  unsigned *),
+                                   unsigned *out_flags);
+
+umf_result_t utils_translate_mem_protection_flags(unsigned in_protection,
+                                                  unsigned *out_protection);
+
+int utils_translate_purge_advise(umf_purge_advise_t advise);
+
+umf_result_t
+utils_translate_mem_visibility_flag(umf_memory_visibility_t in_flag,
+                                    unsigned *out_flag);
+
+int utils_create_anonymous_fd(void);
+
+int utils_shm_create(const char *shm_name, size_t size);
+
+int utils_shm_open(const char *shm_name);
+
+int utils_shm_unlink(const char *shm_name);
+
+size_t get_max_file_size(void);
+
+int utils_get_file_size(int fd, size_t *size);
+
+int utils_set_file_size(int fd, size_t size);
+
+void *utils_mmap(void *hint_addr, size_t length, int prot, int flag, int fd,
+                 size_t fd_offset);
+
+void *utils_mmap_file(void *hint_addr, size_t length, int prot, int flags,
+                      int fd, size_t fd_offset, bool *map_sync);
+
+int utils_munmap(void *addr, size_t length);
+
+int utils_purge(void *addr, size_t length, int advice);
+
+void utils_strerror(int errnum, char *buf, size_t buflen);
+
+int utils_devdax_open(const char *path);
+
+int utils_file_open(const char *path);
+
+int utils_file_open_or_create(const char *path);
+
+int utils_fallocate(int fd, long offset, long len);
+
+long utils_get_size_threshold(char *str_threshold);
+
+size_t utils_max(size_t a, size_t b);
+
+size_t utils_min(size_t a, size_t b);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/utils/utils_concurrency.h b/src/utils/utils_concurrency.h
index dcc67dc42..14d7fe54e 100644
--- a/src/utils/utils_concurrency.h
+++ b/src/utils/utils_concurrency.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -10,7 +10,10 @@
 #ifndef UMF_UTILS_CONCURRENCY_H
 #define UMF_UTILS_CONCURRENCY_H 1
 
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdio.h>
+#include <stdlib.h>
 
 #ifdef _WIN32
 #include <windows.h>
@@ -18,7 +21,7 @@
 #include "utils_windows_intrin.h"
 
 #pragma intrinsic(_BitScanForward64)
-#else
+#else /* !_WIN32 */
 #include <pthread.h>
 
 #ifndef __cplusplus
@@ -26,29 +29,54 @@
 #else /* __cplusplus */
 #include <atomic>
 #define _Atomic(X) std::atomic<X>
+
+// TODO remove cpp code from this file
+using std::memory_order_acq_rel;
+using std::memory_order_acquire;
+using std::memory_order_relaxed;
+using std::memory_order_release;
+
 #endif /* __cplusplus */
 
-#endif /* _WIN32 */
+#endif /* !_WIN32 */
 
+#include "utils_assert.h"
+#include "utils_common.h"
 #include "utils_sanitizers.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef struct os_mutex_t {
+typedef struct utils_mutex_t {
 #ifdef _WIN32
     CRITICAL_SECTION lock;
 #else
     pthread_mutex_t lock;
 #endif
-} os_mutex_t;
+} utils_mutex_t;
 
-size_t util_mutex_get_size(void);
-os_mutex_t *util_mutex_init(void *ptr);
-void util_mutex_destroy_not_free(os_mutex_t *m);
-int util_mutex_lock(os_mutex_t *mutex);
-int util_mutex_unlock(os_mutex_t *mutex);
+size_t utils_mutex_get_size(void);
+utils_mutex_t *utils_mutex_init(utils_mutex_t *ptr);
+void utils_mutex_destroy_not_free(utils_mutex_t *m);
+int utils_mutex_lock(utils_mutex_t *mutex);
+int utils_mutex_unlock(utils_mutex_t *mutex);
+
+typedef struct utils_rwlock_t {
+#ifdef _WIN32
+    // Slim Read/Wrtiter lock
+    SRWLOCK lock;
+#else
+    pthread_rwlock_t rwlock;
+#endif
+} utils_rwlock_t;
+
+utils_rwlock_t *utils_rwlock_init(utils_rwlock_t *ptr);
+void utils_rwlock_destroy_not_free(utils_rwlock_t *rwlock);
+int utils_read_lock(utils_rwlock_t *rwlock);
+int utils_write_lock(utils_rwlock_t *rwlock);
+int utils_read_unlock(utils_rwlock_t *rwlock);
+int utils_write_unlock(utils_rwlock_t *rwlock);
 
 #if defined(_WIN32)
 #define UTIL_ONCE_FLAG INIT_ONCE
@@ -58,51 +86,199 @@ int util_mutex_unlock(os_mutex_t *mutex);
 #define UTIL_ONCE_FLAG_INIT PTHREAD_ONCE_INIT
 #endif
 
-void util_init_once(UTIL_ONCE_FLAG *flag, void (*onceCb)(void));
+void utils_init_once(UTIL_ONCE_FLAG *flag, void (*onceCb)(void));
 
 #if defined(_WIN32)
-static __inline unsigned char util_lssb_index(long long value) {
-    unsigned long ret;
-    _BitScanForward64(&ret, value);
-    return (unsigned char)ret;
-}
-static __inline unsigned char util_mssb_index(long long value) {
-    unsigned long ret;
-    _BitScanReverse64(&ret, value);
-    return (unsigned char)ret;
+
+// There is no good way to do atomic_load on windows...
+static inline void utils_atomic_load_acquire_u64(uint64_t *ptr, uint64_t *out) {
+    // NOTE: Windows cl complains about direct accessing 'ptr' which is next
+    // accessed using Interlocked* functions (warning 28112 - disabled)
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+
+    // On Windows, there is no equivalent to __atomic_load, so we use cmpxchg
+    // with 0, 0 here. This will always return the value under the pointer
+    // without writing anything.
+    LONG64 ret = InterlockedCompareExchange64((LONG64 volatile *)ptr, 0, 0);
+    *out = *(uint64_t *)&ret;
 }
 
 // There is no good way to do atomic_load on windows...
-#define util_atomic_load_acquire(object, dest)                                 \
-    do {                                                                       \
-        *dest = InterlockedOr64Acquire((LONG64 volatile *)object, 0);          \
-    } while (0)
-
-#define util_atomic_store_release(object, desired)                             \
-    InterlockedExchange64((LONG64 volatile *)object, (LONG64)desired)
-#define util_atomic_increment(object)                                          \
-    InterlockedIncrement64((LONG64 volatile *)object)
-#define util_fetch_and_add64(ptr, value)                                       \
-    InterlockedExchangeAdd64((LONG64 *)(ptr), value)
-#else
-#define util_lssb_index(x) ((unsigned char)__builtin_ctzll(x))
-#define util_mssb_index(x) ((unsigned char)(63 - __builtin_clzll(x)))
-#define util_atomic_load_acquire(object, dest)                                 \
-    do {                                                                       \
-        utils_annotate_acquire((void *)object);                                \
-        __atomic_load(object, dest, memory_order_acquire);                     \
-    } while (0)
-
-#define util_atomic_store_release(object, desired)                             \
-    do {                                                                       \
-        __atomic_store_n(object, desired, memory_order_release);               \
-        utils_annotate_release((void *)object);                                \
-    } while (0)
-
-#define util_atomic_increment(object)                                          \
-    __atomic_add_fetch(object, 1, __ATOMIC_ACQ_REL)
-#define util_fetch_and_add64 __sync_fetch_and_add
-#endif
+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);
+}
+
+static inline uint64_t utils_atomic_increment_u64(uint64_t *ptr) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    // return incremented value
+    return InterlockedIncrement64((LONG64 volatile *)ptr);
+}
+
+static inline uint64_t utils_atomic_decrement_u64(uint64_t *ptr) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    // return decremented value
+    return InterlockedDecrement64((LONG64 volatile *)ptr);
+}
+
+static inline uint64_t utils_fetch_and_add_u64(uint64_t *ptr, uint64_t val) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    // return the value that had previously been in *ptr
+    return InterlockedExchangeAdd64((LONG64 volatile *)(ptr), val);
+}
+
+static inline uint64_t utils_fetch_and_sub_u64(uint64_t *ptr, uint64_t val) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    // return the value that had previously been in *ptr
+    // NOTE: on Windows there is no *Sub* version of InterlockedExchange
+    return InterlockedExchangeAdd64((LONG64 volatile *)(ptr), -(LONG64)val);
+}
+
+static inline bool utils_compare_exchange_u64(uint64_t *ptr, uint64_t *expected,
+                                              uint64_t *desired) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    LONG64 out = InterlockedCompareExchange64(
+        (LONG64 volatile *)ptr, *(LONG64 *)desired, *(LONG64 *)expected);
+    if (out == *(LONG64 *)expected) {
+        return true;
+    }
+
+    // else
+    *expected = out;
+    return false;
+}
+
+#else // !defined(_WIN32)
+
+static inline void utils_atomic_load_acquire_u64(uint64_t *ptr, uint64_t *out) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    ASSERT_IS_ALIGNED((uintptr_t)out, 8);
+    __atomic_load(ptr, out, memory_order_acquire);
+    utils_annotate_acquire(ptr);
+}
+
+static inline void utils_atomic_load_acquire_u8(uint8_t *ptr, uint8_t *out) {
+    __atomic_load(ptr, out, memory_order_acquire);
+    utils_annotate_acquire(ptr);
+}
+
+static inline void utils_atomic_load_acquire_ptr(void **ptr, void **out) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    ASSERT_IS_ALIGNED((uintptr_t)out, 8);
+    __atomic_load((uintptr_t *)ptr, (uintptr_t *)out, memory_order_acquire);
+    utils_annotate_acquire(ptr);
+}
+
+static inline void utils_atomic_store_release_u64(uint64_t *ptr, uint64_t val) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    utils_annotate_release(ptr);
+    __atomic_store_n(ptr, val, memory_order_release);
+}
+
+static inline void utils_atomic_store_release_u8(uint8_t *ptr, uint8_t val) {
+    utils_annotate_release(ptr);
+    __atomic_store_n(ptr, val, memory_order_release);
+}
+
+static inline void utils_atomic_store_release_ptr(void **ptr, void *val) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    utils_annotate_release(ptr);
+    __atomic_store_n((uintptr_t *)ptr, (uintptr_t)val, memory_order_release);
+}
+
+static inline uint64_t utils_atomic_increment_u64(uint64_t *val) {
+    ASSERT_IS_ALIGNED((uintptr_t)val, 8);
+    // return incremented value
+    return __atomic_add_fetch(val, 1, memory_order_acq_rel);
+}
+
+static inline uint64_t utils_atomic_decrement_u64(uint64_t *val) {
+    ASSERT_IS_ALIGNED((uintptr_t)val, 8);
+    // return decremented value
+    return __atomic_sub_fetch(val, 1, memory_order_acq_rel);
+}
+
+static inline uint64_t utils_fetch_and_add_u64(uint64_t *ptr, uint64_t val) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    // return the value that had previously been in *ptr
+    return __atomic_fetch_add(ptr, val, memory_order_acq_rel);
+}
+
+static inline uint64_t utils_fetch_and_sub_u64(uint64_t *ptr, uint64_t val) {
+    // return the value that had previously been in *ptr
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    return __atomic_fetch_sub(ptr, val, memory_order_acq_rel);
+}
+
+static inline bool utils_compare_exchange_u64(uint64_t *ptr, uint64_t *expected,
+                                              uint64_t *desired) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 8);
+    return __atomic_compare_exchange(ptr, expected, desired, 0 /* strong */,
+                                     memory_order_acq_rel,
+                                     memory_order_relaxed);
+}
+
+#endif // !defined(_WIN32)
+
+static inline void utils_atomic_load_acquire_size_t(size_t *ptr, size_t *out) {
+    COMPILE_ERROR_ON(sizeof(size_t) != sizeof(uint64_t));
+    utils_atomic_load_acquire_u64((uint64_t *)ptr, (uint64_t *)out);
+}
+
+static inline void utils_atomic_store_release_size_t(size_t *ptr, size_t val) {
+    COMPILE_ERROR_ON(sizeof(size_t) != sizeof(uint64_t));
+    utils_atomic_store_release_u64((uint64_t *)ptr, (uint64_t)val);
+}
+
+static inline size_t utils_fetch_and_add_size_t(size_t *ptr, size_t val) {
+    COMPILE_ERROR_ON(sizeof(size_t) != sizeof(uint64_t));
+    return utils_fetch_and_add_u64((uint64_t *)ptr, (uint64_t)val);
+}
+
+static inline size_t utils_fetch_and_sub_size_t(size_t *ptr, size_t val) {
+    COMPILE_ERROR_ON(sizeof(size_t) != sizeof(uint64_t));
+    return utils_fetch_and_sub_u64((uint64_t *)ptr, (uint64_t)val);
+}
+
+static inline bool utils_compare_exchange_size_t(size_t *ptr, size_t *expected,
+                                                 size_t *desired) {
+    COMPILE_ERROR_ON(sizeof(size_t) != sizeof(uint64_t));
+    return utils_compare_exchange_u64((uint64_t *)ptr, (uint64_t *)expected,
+                                      (uint64_t *)desired);
+}
+
+static inline size_t utils_atomic_increment_size_t(size_t *val) {
+    COMPILE_ERROR_ON(sizeof(size_t) != sizeof(uint64_t));
+    return utils_atomic_increment_u64((uint64_t *)val);
+}
+
+static inline size_t utils_atomic_decrement_size_t(size_t *val) {
+    COMPILE_ERROR_ON(sizeof(size_t) != sizeof(uint64_t));
+    return utils_atomic_decrement_u64((uint64_t *)val);
+}
 
 #ifdef __cplusplus
 }
diff --git a/test/providers/level_zero_helpers.cpp b/src/utils/utils_level_zero.cpp
similarity index 73%
rename from test/providers/level_zero_helpers.cpp
rename to src/utils/utils_level_zero.cpp
index 067bf6a15..6daab3e69 100644
--- a/test/providers/level_zero_helpers.cpp
+++ b/src/utils/utils_level_zero.cpp
@@ -1,11 +1,11 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  */
 
-#include "level_zero_helpers.h"
+#include "utils_level_zero.h"
 
 #include <memory>
 #include <stdlib.h>
@@ -60,13 +60,78 @@ struct libze_ops {
                                     const ze_device_mem_alloc_desc_t *, size_t,
                                     size_t, ze_device_handle_t, void **);
     ze_result_t (*zeMemFree)(ze_context_handle_t, void *);
+    ze_result_t (*zeDeviceGetMemoryProperties)(
+        ze_device_handle_t hDevice, uint32_t *pCount,
+        ze_device_memory_properties_t *pMemProperties);
 } libze_ops;
 
 #if USE_DLOPEN
+// Generic no-op stub function for all callbacks
+template <typename... Args> ze_result_t noop_stub(Args &&...) {
+    return ZE_RESULT_SUCCESS; // Always return ZE_RESULT_SUCCESS
+}
+
 struct DlHandleCloser {
     void operator()(void *dlHandle) {
         if (dlHandle) {
-            util_close_library(dlHandle);
+            // Reset all function pointers to no-op stubs in case the library
+            // but some other global object still try to call Level Zero functions.
+            libze_ops.zeInit = [](auto... args) { return noop_stub(args...); };
+            libze_ops.zeDriverGet = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libze_ops.zeDeviceGet = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libze_ops.zeDeviceGetProperties = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libze_ops.zeContextCreate = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libze_ops.zeContextDestroy = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libze_ops.zeCommandQueueCreate = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libze_ops.zeCommandQueueDestroy = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libze_ops.zeCommandQueueExecuteCommandLists = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libze_ops.zeCommandQueueSynchronize = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libze_ops.zeCommandListCreate = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libze_ops.zeCommandListDestroy = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libze_ops.zeCommandListClose = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libze_ops.zeCommandListAppendMemoryCopy = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libze_ops.zeCommandListAppendMemoryFill = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libze_ops.zeMemGetAllocProperties = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libze_ops.zeMemAllocDevice = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libze_ops.zeMemFree = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libze_ops.zeDeviceGetMemoryProperties = [](auto... args) {
+                return noop_stub(args...);
+            };
+            utils_close_library(dlHandle);
         }
     }
 };
@@ -76,32 +141,37 @@ int InitLevelZeroOps() {
 #ifdef _WIN32
     const char *lib_name = "ze_loader.dll";
 #else
-    const char *lib_name = "libze_loader.so";
+    const char *lib_name = "libze_loader.so.1";
 #endif
     // Load Level Zero symbols
-    // NOTE that we use UMF_UTIL_OPEN_LIBRARY_GLOBAL which add all loaded symbols to the
+#if OPEN_ZE_LIBRARY_GLOBAL
+    // NOTE UMF_UTIL_OPEN_LIBRARY_GLOBAL adds all loaded symbols to the
     // global symbol table.
+    int open_flags = UMF_UTIL_OPEN_LIBRARY_GLOBAL;
+#else
+    int open_flags = 0;
+#endif
     zeDlHandle = std::unique_ptr<void, DlHandleCloser>(
-        util_open_library(lib_name, UMF_UTIL_OPEN_LIBRARY_GLOBAL));
+        utils_open_library(lib_name, open_flags));
     *(void **)&libze_ops.zeInit =
-        util_get_symbol_addr(zeDlHandle.get(), "zeInit", lib_name);
+        utils_get_symbol_addr(zeDlHandle.get(), "zeInit", lib_name);
     if (libze_ops.zeInit == nullptr) {
         fprintf(stderr, "zeInit symbol not found in %s\n", lib_name);
         return -1;
     }
     *(void **)&libze_ops.zeDriverGet =
-        util_get_symbol_addr(zeDlHandle.get(), "zeDriverGet", lib_name);
+        utils_get_symbol_addr(zeDlHandle.get(), "zeDriverGet", lib_name);
     if (libze_ops.zeDriverGet == nullptr) {
         fprintf(stderr, "zeDriverGet symbol not found in %s\n", lib_name);
         return -1;
     }
     *(void **)&libze_ops.zeDeviceGet =
-        util_get_symbol_addr(zeDlHandle.get(), "zeDeviceGet", lib_name);
+        utils_get_symbol_addr(zeDlHandle.get(), "zeDeviceGet", lib_name);
     if (libze_ops.zeDeviceGet == nullptr) {
         fprintf(stderr, "zeDeviceGet symbol not found in %s\n", lib_name);
         return -1;
     }
-    *(void **)&libze_ops.zeDeviceGetProperties = util_get_symbol_addr(
+    *(void **)&libze_ops.zeDeviceGetProperties = utils_get_symbol_addr(
         zeDlHandle.get(), "zeDeviceGetProperties", lib_name);
     if (libze_ops.zeDeviceGetProperties == nullptr) {
         fprintf(stderr, "zeDeviceGetProperties symbol not found in %s\n",
@@ -109,25 +179,25 @@ int InitLevelZeroOps() {
         return -1;
     }
     *(void **)&libze_ops.zeContextCreate =
-        util_get_symbol_addr(zeDlHandle.get(), "zeContextCreate", lib_name);
+        utils_get_symbol_addr(zeDlHandle.get(), "zeContextCreate", lib_name);
     if (libze_ops.zeContextCreate == nullptr) {
         fprintf(stderr, "zeContextCreate symbol not found in %s\n", lib_name);
         return -1;
     }
     *(void **)&libze_ops.zeContextDestroy =
-        util_get_symbol_addr(zeDlHandle.get(), "zeContextDestroy", lib_name);
+        utils_get_symbol_addr(zeDlHandle.get(), "zeContextDestroy", lib_name);
     if (libze_ops.zeContextDestroy == nullptr) {
         fprintf(stderr, "zeContextDestroy symbol not found in %s\n", lib_name);
         return -1;
     }
-    *(void **)&libze_ops.zeCommandQueueCreate = util_get_symbol_addr(
+    *(void **)&libze_ops.zeCommandQueueCreate = utils_get_symbol_addr(
         zeDlHandle.get(), "zeCommandQueueCreate", lib_name);
     if (libze_ops.zeCommandQueueCreate == nullptr) {
         fprintf(stderr, "zeCommandQueueCreate symbol not found in %s\n",
                 lib_name);
         return -1;
     }
-    *(void **)&libze_ops.zeCommandQueueDestroy = util_get_symbol_addr(
+    *(void **)&libze_ops.zeCommandQueueDestroy = utils_get_symbol_addr(
         zeDlHandle.get(), "zeCommandQueueDestroy", lib_name);
     if (libze_ops.zeCommandQueueDestroy == nullptr) {
         fprintf(stderr, "zeCommandQueueDestroy symbol not found in %s\n",
@@ -135,29 +205,29 @@ int InitLevelZeroOps() {
         return -1;
     }
     *(void **)&libze_ops.zeCommandQueueExecuteCommandLists =
-        util_get_symbol_addr(zeDlHandle.get(),
-                             "zeCommandQueueExecuteCommandLists", lib_name);
+        utils_get_symbol_addr(zeDlHandle.get(),
+                              "zeCommandQueueExecuteCommandLists", lib_name);
     if (libze_ops.zeCommandQueueExecuteCommandLists == nullptr) {
         fprintf(stderr,
                 "zeCommandQueueExecuteCommandLists symbol not found in %s\n",
                 lib_name);
         return -1;
     }
-    *(void **)&libze_ops.zeCommandQueueSynchronize = util_get_symbol_addr(
+    *(void **)&libze_ops.zeCommandQueueSynchronize = utils_get_symbol_addr(
         zeDlHandle.get(), "zeCommandQueueSynchronize", lib_name);
     if (libze_ops.zeCommandQueueSynchronize == nullptr) {
         fprintf(stderr, "zeCommandQueueSynchronize symbol not found in %s\n",
                 lib_name);
         return -1;
     }
-    *(void **)&libze_ops.zeCommandListCreate =
-        util_get_symbol_addr(zeDlHandle.get(), "zeCommandListCreate", lib_name);
+    *(void **)&libze_ops.zeCommandListCreate = utils_get_symbol_addr(
+        zeDlHandle.get(), "zeCommandListCreate", lib_name);
     if (libze_ops.zeCommandListCreate == nullptr) {
         fprintf(stderr, "zeCommandListCreate symbol not found in %s\n",
                 lib_name);
         return -1;
     }
-    *(void **)&libze_ops.zeCommandListDestroy = util_get_symbol_addr(
+    *(void **)&libze_ops.zeCommandListDestroy = utils_get_symbol_addr(
         zeDlHandle.get(), "zeCommandListDestroy", lib_name);
     if (libze_ops.zeCommandListDestroy == nullptr) {
         fprintf(stderr, "zeCommandListDestroy symbol not found in %s\n",
@@ -165,13 +235,13 @@ int InitLevelZeroOps() {
         return -1;
     }
     *(void **)&libze_ops.zeCommandListClose =
-        util_get_symbol_addr(zeDlHandle.get(), "zeCommandListClose", lib_name);
+        utils_get_symbol_addr(zeDlHandle.get(), "zeCommandListClose", lib_name);
     if (libze_ops.zeCommandListClose == nullptr) {
         fprintf(stderr, "zeCommandListClose symbol not found in %s\n",
                 lib_name);
         return -1;
     }
-    *(void **)&libze_ops.zeCommandListAppendMemoryCopy = util_get_symbol_addr(
+    *(void **)&libze_ops.zeCommandListAppendMemoryCopy = utils_get_symbol_addr(
         zeDlHandle.get(), "zeCommandListAppendMemoryCopy", lib_name);
     if (libze_ops.zeCommandListAppendMemoryCopy == nullptr) {
         fprintf(stderr,
@@ -179,7 +249,7 @@ int InitLevelZeroOps() {
                 lib_name);
         return -1;
     }
-    *(void **)&libze_ops.zeCommandListAppendMemoryFill = util_get_symbol_addr(
+    *(void **)&libze_ops.zeCommandListAppendMemoryFill = utils_get_symbol_addr(
         zeDlHandle.get(), "zeCommandListAppendMemoryFill", lib_name);
     if (libze_ops.zeCommandListAppendMemoryFill == nullptr) {
         fprintf(stderr,
@@ -187,7 +257,7 @@ int InitLevelZeroOps() {
                 lib_name);
         return -1;
     }
-    *(void **)&libze_ops.zeMemGetAllocProperties = util_get_symbol_addr(
+    *(void **)&libze_ops.zeMemGetAllocProperties = utils_get_symbol_addr(
         zeDlHandle.get(), "zeMemGetAllocProperties", lib_name);
     if (libze_ops.zeMemGetAllocProperties == nullptr) {
         fprintf(stderr, "zeMemGetAllocProperties symbol not found in %s\n",
@@ -195,17 +265,24 @@ int InitLevelZeroOps() {
         return -1;
     }
     *(void **)&libze_ops.zeMemAllocDevice =
-        util_get_symbol_addr(zeDlHandle.get(), "zeMemAllocDevice", lib_name);
+        utils_get_symbol_addr(zeDlHandle.get(), "zeMemAllocDevice", lib_name);
     if (libze_ops.zeMemAllocDevice == nullptr) {
         fprintf(stderr, "zeMemAllocDevice symbol not found in %s\n", lib_name);
         return -1;
     }
     *(void **)&libze_ops.zeMemFree =
-        util_get_symbol_addr(zeDlHandle.get(), "zeMemFree", lib_name);
+        utils_get_symbol_addr(zeDlHandle.get(), "zeMemFree", lib_name);
     if (libze_ops.zeMemFree == nullptr) {
         fprintf(stderr, "zeMemFree symbol not found in %s\n", lib_name);
         return -1;
     }
+    *(void **)&libze_ops.zeDeviceGetMemoryProperties = utils_get_symbol_addr(
+        zeDlHandle.get(), "zeDeviceGetMemoryProperties", lib_name);
+    if (libze_ops.zeDeviceGetMemoryProperties == nullptr) {
+        fprintf(stderr, "zeDeviceGetMemoryProperties symbol not found in %s\n",
+                lib_name);
+        return -1;
+    }
 
     return 0;
 }
@@ -233,12 +310,13 @@ int InitLevelZeroOps() {
     libze_ops.zeMemGetAllocProperties = zeMemGetAllocProperties;
     libze_ops.zeMemAllocDevice = zeMemAllocDevice;
     libze_ops.zeMemFree = zeMemFree;
+    libze_ops.zeDeviceGetMemoryProperties = zeDeviceGetMemoryProperties;
 
     return 0;
 }
 #endif // USE_DLOPEN
 
-static int init_level_zero_lib(void) {
+static int utils_ze_init_level_zero_lib(void) {
     ze_init_flag_t flags = ZE_INIT_FLAG_GPU_ONLY;
     ze_result_t result = libze_ops.zeInit(flags);
     if (result != ZE_RESULT_SUCCESS) {
@@ -247,7 +325,25 @@ static int init_level_zero_lib(void) {
     return 0;
 }
 
-int get_drivers(uint32_t *drivers_num_, ze_driver_handle_t **drivers_) {
+static UTIL_ONCE_FLAG level_zero_init_flag = UTIL_ONCE_FLAG_INIT;
+static int InitResult;
+
+static void utils_ze_init_level_zero_once(void) {
+    InitResult = InitLevelZeroOps();
+    if (InitResult != 0) {
+        return;
+    }
+    InitResult = utils_ze_init_level_zero_lib();
+}
+
+int utils_ze_init_level_zero(void) {
+    utils_init_once(&level_zero_init_flag, utils_ze_init_level_zero_once);
+
+    return InitResult;
+}
+
+int utils_ze_get_drivers(uint32_t *drivers_num_,
+                         ze_driver_handle_t **drivers_) {
     int ret = 0;
     ze_result_t ze_result;
     ze_driver_handle_t *drivers = NULL;
@@ -288,11 +384,12 @@ int get_drivers(uint32_t *drivers_num_, ze_driver_handle_t **drivers_) {
         free(drivers);
         *drivers_ = NULL;
     }
+
     return ret;
 }
 
-int get_devices(ze_driver_handle_t driver, uint32_t *devices_num_,
-                ze_device_handle_t **devices_) {
+int utils_ze_get_devices(ze_driver_handle_t driver, uint32_t *devices_num_,
+                         ze_device_handle_t **devices_) {
     ze_result_t ze_result;
     int ret = 0;
     uint32_t devices_num = 0;
@@ -333,10 +430,12 @@ int get_devices(ze_driver_handle_t driver, uint32_t *devices_num_,
         free(devices);
         devices = NULL;
     }
+
     return ret;
 }
 
-int find_driver_with_gpu(uint32_t *driver_idx, ze_driver_handle_t *driver_) {
+int utils_ze_find_driver_with_gpu(uint32_t *driver_idx,
+                                  ze_driver_handle_t *driver_) {
     int ret = 0;
     ze_result_t ze_result;
     uint32_t drivers_num = 0;
@@ -344,7 +443,7 @@ int find_driver_with_gpu(uint32_t *driver_idx, ze_driver_handle_t *driver_) {
     ze_driver_handle_t *drivers = NULL;
     ze_driver_handle_t driver_with_gpus = NULL;
 
-    ret = get_drivers(&drivers_num, &drivers);
+    ret = utils_ze_get_drivers(&drivers_num, &drivers);
     if (ret) {
         goto fn_fail;
     }
@@ -354,7 +453,7 @@ int find_driver_with_gpu(uint32_t *driver_idx, ze_driver_handle_t *driver_) {
         uint32_t devices_num = 0;
         ze_driver_handle_t driver = drivers[i];
 
-        ret = get_devices(driver, &devices_num, &devices);
+        ret = utils_ze_get_devices(driver, &devices_num, &devices);
         if (ret) {
             goto fn_fail;
         }
@@ -403,13 +502,14 @@ int find_driver_with_gpu(uint32_t *driver_idx, ze_driver_handle_t *driver_) {
     return ret;
 }
 
-int find_gpu_device(ze_driver_handle_t driver, ze_device_handle_t *device_) {
+int utils_ze_find_gpu_device(ze_driver_handle_t driver,
+                             ze_device_handle_t *device_) {
     int ret = -1;
     uint32_t devices_num = 0;
     ze_device_handle_t *devices = NULL;
     ze_device_handle_t device;
 
-    ret = get_devices(driver, &devices_num, &devices);
+    ret = utils_ze_get_devices(driver, &devices_num, &devices);
     if (ret) {
         return ret;
     }
@@ -441,9 +541,9 @@ int find_gpu_device(ze_driver_handle_t driver, ze_device_handle_t *device_) {
     return ret;
 }
 
-int level_zero_fill(ze_context_handle_t context, ze_device_handle_t device,
-                    void *ptr, size_t size, const void *pattern,
-                    size_t pattern_size) {
+int utils_ze_level_zero_fill(ze_context_handle_t context,
+                             ze_device_handle_t device, void *ptr, size_t size,
+                             const void *pattern, size_t pattern_size) {
     int ret = 0;
 
     ze_command_queue_desc_t commandQueueDesc = {
@@ -527,8 +627,9 @@ int level_zero_fill(ze_context_handle_t context, ze_device_handle_t device,
     return ret;
 }
 
-int level_zero_copy(ze_context_handle_t context, ze_device_handle_t device,
-                    void *dst_ptr, const void *src_ptr, size_t size) {
+int utils_ze_level_zero_copy(ze_context_handle_t context,
+                             ze_device_handle_t device, void *dst_ptr,
+                             const void *src_ptr, size_t size) {
     int ret = 0;
     ze_command_queue_desc_t commandQueueDesc = {
         ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC,
@@ -610,7 +711,8 @@ int level_zero_copy(ze_context_handle_t context, ze_device_handle_t device,
     return ret;
 }
 
-int create_context(ze_driver_handle_t driver, ze_context_handle_t *context) {
+int utils_ze_create_context(ze_driver_handle_t driver,
+                            ze_context_handle_t *context) {
     ze_result_t ze_result;
     ze_context_desc_t ctxtDesc;
     ctxtDesc.stype = ZE_STRUCTURE_TYPE_CONTEXT_DESC;
@@ -626,7 +728,7 @@ int create_context(ze_driver_handle_t driver, ze_context_handle_t *context) {
     return 0;
 }
 
-int destroy_context(ze_context_handle_t context) {
+int utils_ze_destroy_context(ze_context_handle_t context) {
     ze_result_t ze_result;
     ze_result = libze_ops.zeContextDestroy(context);
     if (ze_result != ZE_RESULT_SUCCESS) {
@@ -637,7 +739,7 @@ int destroy_context(ze_context_handle_t context) {
     return 0;
 }
 
-ze_memory_type_t get_mem_type(ze_context_handle_t context, void *ptr) {
+ze_memory_type_t utils_ze_get_mem_type(ze_context_handle_t context, void *ptr) {
     ze_device_handle_t device = NULL;
     ze_memory_allocation_properties_t alloc_props;
     alloc_props.stype = ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES;
@@ -650,59 +752,14 @@ ze_memory_type_t get_mem_type(ze_context_handle_t context, void *ptr) {
     return alloc_props.type;
 }
 
-UTIL_ONCE_FLAG level_zero_init_flag;
-int InitResult;
-void init_level_zero_once() {
-    InitResult = InitLevelZeroOps();
-    if (InitResult != 0) {
-        return;
+int64_t utils_ze_get_num_memory_properties(ze_device_handle_t device) {
+    uint32_t pCount = 0;
+    ze_result_t ze_result =
+        libze_ops.zeDeviceGetMemoryProperties(device, &pCount, nullptr);
+    if (ze_result != ZE_RESULT_SUCCESS) {
+        fprintf(stderr, "zeDeviceGetMemoryProperties() failed!\n");
+        return -1;
     }
-    InitResult = init_level_zero_lib();
-}
-
-int init_level_zero() {
-    util_init_once(&level_zero_init_flag, init_level_zero_once);
 
-    return InitResult;
+    return static_cast<int64_t>(pCount);
 }
-
-level_zero_memory_provider_params_t
-create_level_zero_prov_params(umf_usm_memory_type_t memory_type) {
-    level_zero_memory_provider_params_t params = {NULL, NULL,
-                                                  UMF_MEMORY_TYPE_UNKNOWN};
-    uint32_t driver_idx = 0;
-    ze_driver_handle_t hDriver;
-    ze_device_handle_t hDevice;
-    ze_context_handle_t hContext;
-    int ret = -1;
-
-    ret = init_level_zero();
-    if (ret != 0) {
-        // Return empty params. Test will be skipped.
-        return params;
-    }
-
-    ret = find_driver_with_gpu(&driver_idx, &hDriver);
-    if (ret != 0 || hDriver == NULL) {
-        // Return empty params. Test will be skipped.
-        return params;
-    }
-
-    ret = find_gpu_device(hDriver, &hDevice);
-    if (ret != 0 || hDevice == NULL) {
-        // Return empty params. Test will be skipped.
-        return params;
-    }
-
-    ret = create_context(hDriver, &hContext);
-    if (ret != 0) {
-        // Return empty params. Test will be skipped.
-        return params;
-    }
-
-    params.level_zero_context_handle = hContext;
-    params.level_zero_device_handle = hDevice;
-    params.memory_type = memory_type;
-
-    return params;
-}
\ No newline at end of file
diff --git a/src/utils/utils_level_zero.h b/src/utils/utils_level_zero.h
new file mode 100644
index 000000000..00f55b351
--- /dev/null
+++ b/src/utils/utils_level_zero.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef UMF_UTILS_LEVEL_ZERO_H
+#define UMF_UTILS_LEVEL_ZERO_H
+
+#include <umf/providers/provider_level_zero.h>
+
+#include "ze_api.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int utils_ze_init_level_zero(void);
+
+int utils_ze_get_drivers(uint32_t *drivers_num_, ze_driver_handle_t **drivers_);
+
+int utils_ze_get_devices(ze_driver_handle_t driver, uint32_t *devices_num_,
+                         ze_device_handle_t **devices_);
+
+int utils_ze_find_driver_with_gpu(uint32_t *driver_idx,
+                                  ze_driver_handle_t *driver_);
+
+int utils_ze_find_gpu_device(ze_driver_handle_t driver,
+                             ze_device_handle_t *device_);
+
+int utils_ze_level_zero_fill(ze_context_handle_t context,
+                             ze_device_handle_t device, void *ptr, size_t size,
+                             const void *pattern, size_t pattern_size);
+
+int utils_ze_level_zero_copy(ze_context_handle_t context,
+                             ze_device_handle_t device, void *dst_ptr,
+                             const void *src_ptr, size_t size);
+
+int utils_ze_create_context(ze_driver_handle_t driver,
+                            ze_context_handle_t *context);
+
+int utils_ze_destroy_context(ze_context_handle_t context);
+
+ze_memory_type_t utils_ze_get_mem_type(ze_context_handle_t context, void *ptr);
+
+int64_t utils_ze_get_num_memory_properties(ze_device_handle_t device);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // UMF_UTILS_LEVEL_ZERO_H
diff --git a/src/utils/utils_linux_common.c b/src/utils/utils_linux_common.c
new file mode 100644
index 000000000..cd0fefd2a
--- /dev/null
+++ b/src/utils/utils_linux_common.c
@@ -0,0 +1,242 @@
+/*
+ *
+ * Copyright (C) 2023-2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdbool.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <umf/base.h>
+#include <umf/memory_provider.h>
+
+#include "utils_common.h"
+#include "utils_log.h"
+
+umf_result_t
+utils_translate_mem_visibility_flag(umf_memory_visibility_t in_flag,
+                                    unsigned *out_flag) {
+    switch (in_flag) {
+    case UMF_MEM_MAP_PRIVATE:
+        *out_flag = MAP_PRIVATE;
+        return UMF_RESULT_SUCCESS;
+    case UMF_MEM_MAP_SHARED:
+        *out_flag = MAP_SHARED;
+        return UMF_RESULT_SUCCESS;
+    }
+    return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+}
+
+/*
+ * Map given file into memory.
+ * If (flags & MAP_PRIVATE) it uses just mmap. Otherwise, it tries to mmap
+ * with (flags | MAP_SHARED_VALIDATE | MAP_SYNC) which allows flushing
+ * from the user-space. If MAP_SYNC fails and if the user did not specify
+ * this flag by himself, it falls back to the mmap with (flags | MAP_SHARED).
+ */
+void *utils_mmap_file(void *hint_addr, size_t length, int prot, int flags,
+                      int fd, size_t fd_offset, bool *map_sync) {
+    void *addr;
+
+    if (map_sync) {
+        *map_sync = false;
+    }
+
+    /*
+     * MAP_PRIVATE and MAP_SHARED are mutually exclusive,
+     * therefore mmap with MAP_PRIVATE is executed separately.
+     */
+    if (flags & MAP_PRIVATE) {
+        addr = utils_mmap(hint_addr, length, prot, flags, fd, fd_offset);
+        if (addr == NULL) {
+            LOG_PERR("mapping file with the MAP_PRIVATE flag failed (fd=%i, "
+                     "offset=%zu, length=%zu, flags=%i)",
+                     fd, fd_offset, length, flags);
+            return NULL;
+        }
+
+        LOG_DEBUG("file mapped with the MAP_PRIVATE flag (fd=%i, offset=%zu, "
+                  "length=%zu, flags=%i)",
+                  fd, fd_offset, length, flags);
+
+        return addr;
+    }
+
+    errno = 0;
+
+    /* try to mmap with MAP_SYNC flag */
+    const int sync_flags = flags | MAP_SHARED_VALIDATE | MAP_SYNC;
+    addr = utils_mmap(hint_addr, length, prot, sync_flags, fd, fd_offset);
+    if (addr) {
+        LOG_DEBUG("file mapped with the MAP_SYNC flag (fd=%i, offset=%zu, "
+                  "length=%zu, flags=%i)",
+                  fd, fd_offset, length, sync_flags);
+        if (map_sync) {
+            *map_sync = true;
+        }
+        return addr;
+    }
+
+    /* try to mmap with MAP_SHARED flag (without MAP_SYNC) */
+    if (errno == EINVAL || errno == ENOTSUP || errno == EOPNOTSUPP) {
+        const int shared_flags = flags | MAP_SHARED;
+        addr = utils_mmap(hint_addr, length, prot, shared_flags, fd, fd_offset);
+        if (addr) {
+            LOG_DEBUG("file mapped with the MAP_SHARED flag (fd=%i, "
+                      "offset=%zu, length=%zu, flags=%i)",
+                      fd, fd_offset, length, shared_flags);
+            return addr;
+        }
+
+        LOG_PERR("mapping file with the MAP_SHARED flag failed (fd=%i, "
+                 "offset=%zu, length=%zu, flags=%i)",
+                 fd, fd_offset, length, shared_flags);
+    } else {
+        LOG_PERR(
+            "mapping file with the MAP_SYNC flag failed (fd=%i, offset=%zu, "
+            "length=%zu, flags=%i)",
+            fd, fd_offset, length, sync_flags);
+    }
+
+    return NULL;
+}
+
+int utils_get_file_size(int fd, size_t *size) {
+    struct stat statbuf;
+    int ret = fstat(fd, &statbuf);
+    if (ret) {
+        LOG_PERR("fstat(%i) failed", fd);
+        return ret;
+    }
+
+    *size = statbuf.st_size;
+    return 0;
+}
+
+int utils_set_file_size(int fd, size_t size) {
+    errno = 0;
+    int ret = ftruncate(fd, size);
+    if (ret) {
+        LOG_PERR("setting size %zu of a file failed", size);
+    } else {
+        LOG_DEBUG("set size of a file to %zu bytes", size);
+    }
+
+    return ret;
+}
+
+int utils_fallocate(int fd, long offset, long len) {
+    return posix_fallocate(fd, offset, len);
+}
+
+// create a shared memory file
+int utils_shm_create(const char *shm_name, size_t size) {
+    if (shm_name == NULL) {
+        LOG_ERR("empty name of a shared memory file");
+        return -1;
+    }
+
+    (void)shm_unlink(shm_name);
+
+    int fd = shm_open(shm_name, O_RDWR | O_CREAT | O_EXCL, 0600);
+    if (fd == -1) {
+        LOG_PERR("cannot create a shared memory file /dev/shm/%s", shm_name);
+        return fd;
+    }
+
+    int ret = utils_set_file_size(fd, size);
+    if (ret) {
+        LOG_ERR("setting size (%zu) of a file /dev/shm/%s failed", size,
+                shm_name);
+        close(fd);
+        (void)shm_unlink(shm_name);
+        return -1;
+    }
+
+    return fd;
+}
+
+// open a shared memory file
+int utils_shm_open(const char *shm_name) {
+    if (shm_name == NULL) {
+        LOG_ERR("empty name of a shared memory file");
+        return -1;
+    }
+
+    int fd = shm_open(shm_name, O_RDWR, 0600);
+    if (fd == -1) {
+        LOG_PERR("cannot open a shared memory file /dev/shm/%s", shm_name);
+    }
+
+    return fd;
+}
+
+// unlink a shared memory file
+int utils_shm_unlink(const char *shm_name) { return shm_unlink(shm_name); }
+
+static int syscall_memfd_secret(void) {
+    int fd = -1;
+#ifdef __NR_memfd_secret
+    // SYS_memfd_secret is supported since Linux 5.14
+    // not using SYS_memfd_secret as SLES does not define it
+    fd = syscall(__NR_memfd_secret, 0);
+    if (fd == -1) {
+        LOG_PERR("memfd_secret() failed");
+    }
+    if (fd > 0) {
+        LOG_DEBUG("anonymous file descriptor created using memfd_secret()");
+    }
+#endif /* __NR_memfd_secret */
+    return fd;
+}
+
+static int syscall_memfd_create(void) {
+    int fd = -1;
+#ifdef __NR_memfd_create
+    // SYS_memfd_create is supported since Linux 3.17, glibc 2.27
+    // not using SYS_memfd_create for consistency with syscall_memfd_secret
+    fd = syscall(__NR_memfd_create, "anon_fd_name", 0);
+    if (fd == -1) {
+        LOG_PERR("memfd_create() failed");
+    }
+    if (fd > 0) {
+        LOG_DEBUG("anonymous file descriptor created using memfd_create()");
+    }
+#endif /* __NR_memfd_create */
+    return fd;
+}
+
+// create an anonymous file descriptor
+int utils_create_anonymous_fd(void) {
+    int fd = -1;
+
+    if (!utils_env_var_has_str("UMF_MEM_FD_FUNC", "memfd_create")) {
+        fd = syscall_memfd_secret();
+        if (fd > 0) {
+            return fd;
+        }
+    }
+
+    // The SYS_memfd_secret syscall can fail with errno == ENOTSYS (function not implemented).
+    // We should try to call the SYS_memfd_create syscall in this case.
+
+    fd = syscall_memfd_create();
+
+#if !(defined __NR_memfd_secret) && !(defined __NR_memfd_create)
+    if (fd == -1) {
+        LOG_ERR("cannot create an anonymous file descriptor - neither "
+                "memfd_secret() nor memfd_create() are defined");
+    }
+#endif /* !(defined __NR_memfd_secret) && !(defined __NR_memfd_create) */
+
+    return fd;
+}
diff --git a/src/utils/utils_load_library.c b/src/utils/utils_load_library.c
index cc5fe29fc..d774fec84 100644
--- a/src/utils/utils_load_library.c
+++ b/src/utils/utils_load_library.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -16,59 +16,87 @@
 #include <libloaderapi.h>
 // clang-format on
 
-#else
+#else // _WIN32
 
 #define _GNU_SOURCE 1
 
 #include <dlfcn.h> // forces linking with libdl on Linux
 
-#endif
+#endif // !_WIN32
+
+#include <stddef.h>
 
 #include "utils_load_library.h"
+#include "utils_log.h"
 
 #ifdef _WIN32
 
-void *util_open_library(const char *filename, int userFlags) {
-    (void)userFlags; //unused for win
+void *utils_open_library(const char *filename, int userFlags) {
+    if (userFlags & UMF_UTIL_OPEN_LIBRARY_NO_LOAD) {
+        HMODULE hModule;
+        BOOL ret = GetModuleHandleEx(0, TEXT(filename), &hModule);
+        return ret ? hModule : NULL;
+    }
     return LoadLibrary(TEXT(filename));
 }
 
-int util_close_library(void *handle) {
+int utils_close_library(void *handle) {
     // If the FreeLibrary function succeeds, the return value is nonzero.
     // If the FreeLibrary function fails, the return value is zero.
     return (FreeLibrary((HMODULE)handle) == 0);
 }
 
-void *util_get_symbol_addr(void *handle, const char *symbol,
-                           const char *libname) {
+void *utils_get_symbol_addr(void *handle, const char *symbol,
+                            const char *libname) {
     if (!handle) {
         if (libname == NULL) {
             return NULL;
         }
         handle = GetModuleHandle(libname);
     }
-    return (void *)GetProcAddress((HMODULE)handle, symbol);
+
+    void *addr = (void *)GetProcAddress((HMODULE)handle, symbol);
+    if (addr == NULL) {
+        LOG_ERR("Required symbol not found: %s", symbol);
+    }
+
+    return addr;
 }
 
 #else /* Linux */
 
-void *util_open_library(const char *filename, int userFlags) {
+void *utils_open_library(const char *filename, int userFlags) {
     int dlopenFlags = RTLD_LAZY;
     if (userFlags & UMF_UTIL_OPEN_LIBRARY_GLOBAL) {
         dlopenFlags |= RTLD_GLOBAL;
     }
-    return dlopen(filename, dlopenFlags);
+    if (userFlags & UMF_UTIL_OPEN_LIBRARY_NO_LOAD) {
+        dlopenFlags |= RTLD_NOLOAD;
+    }
+
+    void *handle = dlopen(filename, dlopenFlags);
+    if (handle == NULL) {
+        LOG_FATAL("dlopen(%s) failed with error: %s", filename, dlerror());
+    }
+
+    return handle;
 }
 
-int util_close_library(void *handle) { return dlclose(handle); }
+int utils_close_library(void *handle) { return dlclose(handle); }
 
-void *util_get_symbol_addr(void *handle, const char *symbol,
-                           const char *libname) {
+void *utils_get_symbol_addr(void *handle, const char *symbol,
+                            const char *libname) {
     (void)libname; //unused
     if (!handle) {
         handle = RTLD_DEFAULT;
     }
-    return dlsym(handle, symbol);
+
+    void *addr = dlsym(handle, symbol);
+    if (addr == NULL) {
+        LOG_ERR("required symbol not found: %s (error: %s)", symbol, dlerror());
+    }
+
+    return addr;
 }
 
 #endif
diff --git a/src/utils/utils_load_library.h b/src/utils/utils_load_library.h
index c066b548f..5b6e71239 100644
--- a/src/utils/utils_load_library.h
+++ b/src/utils/utils_load_library.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -17,12 +17,15 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+// The symbols defined by this library will be made available for symbol resolution of subsequently loaded libraries.
 #define UMF_UTIL_OPEN_LIBRARY_GLOBAL 1
+// Don't load the library. utils_open_library succeeds if the library is already loaded.
+#define UMF_UTIL_OPEN_LIBRARY_NO_LOAD 1 << 1
 
-void *util_open_library(const char *filename, int userFlags);
-int util_close_library(void *handle);
-void *util_get_symbol_addr(void *handle, const char *symbol,
-                           const char *libname);
+void *utils_open_library(const char *filename, int userFlags);
+int utils_close_library(void *handle);
+void *utils_get_symbol_addr(void *handle, const char *symbol,
+                            const char *libname);
 
 #ifdef __cplusplus
 }
diff --git a/src/utils/utils_log.c b/src/utils/utils_log.c
index ca16014f0..2fd28fc2c 100644
--- a/src/utils/utils_log.c
+++ b/src/utils/utils_log.c
@@ -32,6 +32,29 @@
 #include "utils_common.h"
 #include "utils_log.h"
 
+#define UMF_MAGIC_STR "\x00@(#) "
+#define UMF_PREF_STR "Intel(R) "
+#define UMF_PREFIX UMF_MAGIC_STR UMF_PREF_STR
+
+// convert a define to a C string
+#define STR_(X) #X
+#define STR(X) STR_(X)
+
+#ifdef UMF_VERSION
+#define STR_UMF_VERSION "UMF version: " STR(UMF_VERSION)
+#define LOG_STR_UMF_VERSION STR_UMF_VERSION ", "
+char const __umf_str_2_version[] = UMF_PREFIX STR_UMF_VERSION;
+#else /* !UMF_VERSION */
+#error "UMF_VERSION not defined!"
+#endif /* !UMF_VERSION */
+
+#ifdef UMF_ALL_CMAKE_VARIABLES
+char const __umf_str_1__all_cmake_vars[] =
+    UMF_PREFIX "UMF CMake variables: " STR(UMF_ALL_CMAKE_VARIABLES);
+#else /* !UMF_ALL_CMAKE_VARIABLES */
+#error "UMF_ALL_CMAKE_VARIABLES not defined!"
+#endif /* !UMF_ALL_CMAKE_VARIABLES */
+
 #define LOG_MAX 8192
 #define LOG_HEADER 256
 #define MAX_FILE_PATH 256
@@ -40,14 +63,14 @@
 typedef struct {
     int timestamp;
     int pid;
-    util_log_level_t level;
-    util_log_level_t flushLevel;
+    utils_log_level_t level;
+    utils_log_level_t flushLevel;
     FILE *output;
-} util_log_config_t;
+} utils_log_config_t;
 
-util_log_config_t loggerConfig = {0, 0, LOG_ERROR, LOG_ERROR, NULL};
+utils_log_config_t loggerConfig = {0, 0, LOG_ERROR, LOG_ERROR, NULL};
 
-static const char *level_to_str(util_log_level_t l) {
+static const char *level_to_str(utils_log_level_t l) {
     switch (l) {
     case LOG_DEBUG:
         return "DEBUG";
@@ -73,9 +96,9 @@ static const char *level_to_str(util_log_level_t l) {
 #pragma warning(disable : 6262)
 #endif // _MSC_VER
 
-static void util_log_internal(util_log_level_t level, int perror,
-                              const char *func, const char *format,
-                              va_list args) {
+static void utils_log_internal(utils_log_level_t level, int perror,
+                               const char *func, const char *format,
+                               va_list args) {
     if (!loggerConfig.output && level != LOG_FATAL) {
         return; //logger not enabled
     }
@@ -203,25 +226,25 @@ static void util_log_internal(util_log_level_t level, int perror,
 #pragma warning(pop)
 #endif // _MSC_VER
 
-void util_log(util_log_level_t level, const char *func, const char *format,
-              ...) {
+void utils_log(utils_log_level_t level, const char *func, const char *format,
+               ...) {
     va_list args;
     va_start(args, format);
-    util_log_internal(level, 0, func, format, args);
+    utils_log_internal(level, 0, func, format, args);
     va_end(args);
 }
 
-void util_plog(util_log_level_t level, const char *func, const char *format,
-               ...) {
+void utils_plog(utils_log_level_t level, const char *func, const char *format,
+                ...) {
     va_list args;
     va_start(args, format);
-    util_log_internal(level, 1, func, format, args);
+    utils_log_internal(level, 1, func, format, args);
     va_end(args);
 }
 
 static const char *bool_to_str(int b) { return b ? "yes" : "no"; }
 
-void util_log_init(void) {
+void utils_log_init(void) {
     const char *envVar = getenv("UMF_LOG");
 
     if (!envVar) {
@@ -229,11 +252,11 @@ void util_log_init(void) {
     }
 
     const char *arg;
-    if (util_parse_var(envVar, "output:stdout", NULL)) {
+    if (utils_parse_var(envVar, "output:stdout", NULL)) {
         loggerConfig.output = stdout;
-    } else if (util_parse_var(envVar, "output:stderr", NULL)) {
+    } else if (utils_parse_var(envVar, "output:stderr", NULL)) {
         loggerConfig.output = stderr;
-    } else if (util_parse_var(envVar, "output:file", &arg)) {
+    } else if (utils_parse_var(envVar, "output:file", &arg)) {
         loggerConfig.output = NULL;
         const char *argEnd = strstr(arg, ";");
         char file[MAX_FILE_PATH + 1];
@@ -269,53 +292,44 @@ void util_log_init(void) {
         return;
     }
 
-    if (util_parse_var(envVar, "timestamp:yes", NULL)) {
+    if (utils_parse_var(envVar, "timestamp:yes", NULL)) {
         loggerConfig.timestamp = 1;
-    } else if (util_parse_var(envVar, "timestamp:no", NULL)) {
+    } else if (utils_parse_var(envVar, "timestamp:no", NULL)) {
         loggerConfig.timestamp = 0;
     }
 
-    if (util_parse_var(envVar, "pid:yes", NULL)) {
+    if (utils_parse_var(envVar, "pid:yes", NULL)) {
         loggerConfig.pid = 1;
-    } else if (util_parse_var(envVar, "pid:no", NULL)) {
+    } else if (utils_parse_var(envVar, "pid:no", NULL)) {
         loggerConfig.pid = 0;
     }
 
-    if (util_parse_var(envVar, "level:debug", NULL)) {
+    if (utils_parse_var(envVar, "level:debug", NULL)) {
         loggerConfig.level = LOG_DEBUG;
-    } else if (util_parse_var(envVar, "level:info", NULL)) {
+    } else if (utils_parse_var(envVar, "level:info", NULL)) {
         loggerConfig.level = LOG_INFO;
-    } else if (util_parse_var(envVar, "level:warning", NULL)) {
+    } else if (utils_parse_var(envVar, "level:warning", NULL)) {
         loggerConfig.level = LOG_WARNING;
-    } else if (util_parse_var(envVar, "level:error", NULL)) {
+    } else if (utils_parse_var(envVar, "level:error", NULL)) {
         loggerConfig.level = LOG_ERROR;
-    } else if (util_parse_var(envVar, "level:fatal", NULL)) {
+    } else if (utils_parse_var(envVar, "level:fatal", NULL)) {
         loggerConfig.level = LOG_FATAL;
     }
 
-    if (util_parse_var(envVar, "flush:debug", NULL)) {
+    if (utils_parse_var(envVar, "flush:debug", NULL)) {
         loggerConfig.flushLevel = LOG_DEBUG;
-    } else if (util_parse_var(envVar, "flush:info", NULL)) {
+    } else if (utils_parse_var(envVar, "flush:info", NULL)) {
         loggerConfig.flushLevel = LOG_INFO;
-    } else if (util_parse_var(envVar, "flush:warning", NULL)) {
+    } else if (utils_parse_var(envVar, "flush:warning", NULL)) {
         loggerConfig.flushLevel = LOG_WARNING;
-    } else if (util_parse_var(envVar, "flush:error", NULL)) {
+    } else if (utils_parse_var(envVar, "flush:error", NULL)) {
         loggerConfig.flushLevel = LOG_ERROR;
-    } else if (util_parse_var(envVar, "flush:fatal", NULL)) {
+    } else if (utils_parse_var(envVar, "flush:fatal", NULL)) {
         loggerConfig.flushLevel = LOG_FATAL;
     }
 
-#ifdef UMF_VERSION
-// convert a define to a C string
-#define STR_(X) #X
-#define STR(X) STR_(X)
-#define STR_UMF_VERSION "UMF version: " STR(UMF_VERSION) ", "
-#else /* !UMF_VERSION */
-#error "UMF_VERSION not defined!"
-#endif /* !UMF_VERSION */
-
     LOG_INFO(
-        "Logger enabled (" STR_UMF_VERSION
+        "Logger enabled (" LOG_STR_UMF_VERSION
         "level: %s, flush: %s, pid: %s, timestamp: %s)",
         level_to_str(loggerConfig.level), level_to_str(loggerConfig.flushLevel),
         bool_to_str(loggerConfig.pid), bool_to_str(loggerConfig.timestamp));
diff --git a/src/utils/utils_log.h b/src/utils/utils_log.h
index 4e9e98690..ab40121ce 100644
--- a/src/utils/utils_log.h
+++ b/src/utils/utils_log.h
@@ -20,31 +20,31 @@ typedef enum {
     LOG_WARNING,
     LOG_ERROR,
     LOG_FATAL
-} util_log_level_t;
+} utils_log_level_t;
 
-#define LOG_DEBUG(...) util_log(LOG_DEBUG, __func__, __VA_ARGS__);
-#define LOG_INFO(...) util_log(LOG_INFO, __func__, __VA_ARGS__);
-#define LOG_WARN(...) util_log(LOG_WARNING, __func__, __VA_ARGS__);
-#define LOG_ERR(...) util_log(LOG_ERROR, __func__, __VA_ARGS__);
-#define LOG_FATAL(...) util_log(LOG_FATAL, __func__, __VA_ARGS__);
+#define LOG_DEBUG(...) utils_log(LOG_DEBUG, __func__, __VA_ARGS__);
+#define LOG_INFO(...) utils_log(LOG_INFO, __func__, __VA_ARGS__);
+#define LOG_WARN(...) utils_log(LOG_WARNING, __func__, __VA_ARGS__);
+#define LOG_ERR(...) utils_log(LOG_ERROR, __func__, __VA_ARGS__);
+#define LOG_FATAL(...) utils_log(LOG_FATAL, __func__, __VA_ARGS__);
 
-#define LOG_PDEBUG(...) util_plog(LOG_DEBUG, __func__, __VA_ARGS__);
-#define LOG_PINFO(...) util_plog(LOG_INFO, __func__, __VA_ARGS__);
-#define LOG_PWARN(...) util_plog(LOG_WARNING, __func__, __VA_ARGS__);
-#define LOG_PERR(...) util_plog(LOG_ERROR, __func__, __VA_ARGS__);
-#define LOG_PFATAL(...) util_plog(LOG_FATAL, __func__, __VA_ARGS__);
+#define LOG_PDEBUG(...) utils_plog(LOG_DEBUG, __func__, __VA_ARGS__);
+#define LOG_PINFO(...) utils_plog(LOG_INFO, __func__, __VA_ARGS__);
+#define LOG_PWARN(...) utils_plog(LOG_WARNING, __func__, __VA_ARGS__);
+#define LOG_PERR(...) utils_plog(LOG_ERROR, __func__, __VA_ARGS__);
+#define LOG_PFATAL(...) utils_plog(LOG_FATAL, __func__, __VA_ARGS__);
 
-void util_log_init(void);
+void utils_log_init(void);
 #ifdef _WIN32
-void util_log(util_log_level_t level, const char *func, const char *format,
-              ...);
-void util_plog(util_log_level_t level, const char *func, const char *format,
+void utils_log(utils_log_level_t level, const char *func, const char *format,
                ...);
+void utils_plog(utils_log_level_t level, const char *func, const char *format,
+                ...);
 #else
-void util_log(util_log_level_t level, const char *func, const char *format, ...)
-    __attribute__((format(printf, 3, 4)));
-void util_plog(util_log_level_t level, const char *func, const char *format,
+void utils_log(utils_log_level_t level, const char *func, const char *format,
                ...) __attribute__((format(printf, 3, 4)));
+void utils_plog(utils_log_level_t level, const char *func, const char *format,
+                ...) __attribute__((format(printf, 3, 4)));
 #endif
 
 #ifdef __cplusplus
diff --git a/src/provider/provider_os_memory_macosx.c b/src/utils/utils_macosx_common.c
similarity index 51%
rename from src/provider/provider_os_memory_macosx.c
rename to src/utils/utils_macosx_common.c
index 0075ece64..ad1de12fd 100644
--- a/src/provider/provider_os_memory_macosx.c
+++ b/src/utils/utils_macosx_common.c
@@ -1,19 +1,23 @@
 /*
+ *
  * Copyright (C) 2023-2024 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-*/
+ *
+ */
 
 #include <sys/mman.h>
 
-#include <umf/providers/provider_os_memory.h>
+#include <umf/base.h>
+#include <umf/memory_provider.h>
 
-#include "provider_os_memory_internal.h"
+#include "utils_common.h"
 #include "utils_log.h"
 
-umf_result_t os_translate_mem_visibility_flag(umf_memory_visibility_t in_flag,
-                                              unsigned *out_flag) {
+umf_result_t
+utils_translate_mem_visibility_flag(umf_memory_visibility_t in_flag,
+                                    unsigned *out_flag) {
     switch (in_flag) {
     case UMF_MEM_MAP_PRIVATE:
         *out_flag = MAP_PRIVATE;
@@ -24,38 +28,58 @@ umf_result_t os_translate_mem_visibility_flag(umf_memory_visibility_t in_flag,
     return UMF_RESULT_ERROR_INVALID_ARGUMENT;
 }
 
+void *utils_mmap_file(void *hint_addr, size_t length, int prot, int flags,
+                      int fd, size_t fd_offset, bool *map_sync) {
+    (void)hint_addr; // unused
+    (void)length;    // unused
+    (void)prot;      // unused
+    (void)flags;     // unused
+    (void)fd;        // unused
+    (void)fd_offset; // unused
+    (void)map_sync;  // unused
+    return NULL;     // not supported
+}
+
+int utils_get_file_size(int fd, size_t *size) {
+    (void)fd;   // unused
+    (void)size; // unused
+    return -1;  // not supported on MacOSX
+}
+
+int utils_set_file_size(int fd, size_t size) {
+    (void)fd;   // unused
+    (void)size; // unused
+    return 0;   // ignored on MacOSX
+}
+
+int utils_fallocate(int fd, long offset, long len) {
+    (void)fd;     // unused
+    (void)offset; // unused
+    (void)len;    // unused
+
+    return -1;
+}
+
 // create a shared memory file
-int os_shm_create(const char *shm_name, size_t size) {
+int utils_shm_create(const char *shm_name, size_t size) {
     (void)shm_name; // unused
     (void)size;     // unused
     return 0;       // ignored on MacOSX
 }
 
 // open a shared memory file
-int os_shm_open(const char *shm_name) {
+int utils_shm_open(const char *shm_name) {
     (void)shm_name; // unused
     return 0;       // ignored on MacOSX
 }
 
 // unlink a shared memory file
-int os_shm_unlink(const char *shm_name) {
+int utils_shm_unlink(const char *shm_name) {
     (void)shm_name; // unused
     return 0;       // ignored on MacOSX
 }
 
 // create an anonymous file descriptor
-int os_create_anonymous_fd(void) {
+int utils_create_anonymous_fd(void) {
     return 0; // ignored on MacOSX
 }
-
-int os_get_file_size(int fd, size_t *size) {
-    (void)fd;   // unused
-    (void)size; // unused
-    return -1;  // not supported on MacOSX
-}
-
-int os_set_file_size(int fd, size_t size) {
-    (void)fd;   // unused
-    (void)size; // unused
-    return 0;   // ignored on MacOSX
-}
diff --git a/src/utils/utils_math.h b/src/utils/utils_math.h
index c78be1136..0e58fc38d 100644
--- a/src/utils/utils_math.h
+++ b/src/utils/utils_math.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -11,16 +11,58 @@
 #define UMF_MATH_H 1
 
 #include <assert.h>
+#include <limits.h>
 #include <stddef.h>
+#include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-size_t getLeftmostSetBitPos(size_t num);
+#if defined(_WIN32)
 
-// Logarithm is an index of the most significant non-zero bit.
-static inline size_t log2Utils(size_t num) { return getLeftmostSetBitPos(num); }
+#include "utils_windows_intrin.h"
+
+#pragma intrinsic(_BitScanReverse64)
+#pragma intrinsic(_BitScanForward64)
+
+// Retrieves the position of the leftmost set bit.
+// The position of the bit is counted from 0
+// e.g. for 01000011110 the position equals 9.
+static inline size_t utils_msb64(uint64_t num) {
+    assert(num != 0 &&
+           "Finding leftmost set bit when number equals zero is undefined");
+    unsigned long index = 0;
+    _BitScanReverse64(&index, num);
+    return (size_t)index;
+}
+
+static inline size_t utils_lsb64(uint64_t num) {
+    assert(num != 0 &&
+           "Finding rightmost set bit when number equals zero is undefined");
+    unsigned long index = 0;
+    _BitScanForward64(&index, num);
+    return (size_t)index;
+}
+
+#else // !defined(_WIN32)
+
+// Retrieves the position of the leftmost set bit.
+// The position of the bit is counted from 0
+// e.g. for 01000011110 the position equals 9.
+static inline size_t utils_msb64(uint64_t num) {
+    assert(num != 0 &&
+           "Finding leftmost set bit when number equals zero is undefined");
+    return 63 - __builtin_clzll(num);
+}
+
+static inline size_t utils_lsb64(uint64_t num) {
+    assert(num != 0 &&
+           "Finding rightmost set bit when number equals zero is undefined");
+    return __builtin_ctzll(num);
+}
+
+#endif // !defined(_WIN32)
 
 #ifdef __cplusplus
 }
diff --git a/src/utils/utils_posix_common.c b/src/utils/utils_posix_common.c
index 51049e613..da051695b 100644
--- a/src/utils/utils_posix_common.c
+++ b/src/utils/utils_posix_common.c
@@ -1,21 +1,28 @@
 /*
  *
- * 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 <ctype.h>
 #include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
 #include <sys/syscall.h>
+#include <sys/types.h>
 #include <unistd.h>
 
 #include "utils_common.h"
 #include "utils_concurrency.h"
 #include "utils_log.h"
+#include "utils_sanitizers.h"
 
 #ifndef __NR_pidfd_open
 #define __NR_pidfd_open 434 /* Syscall id */
@@ -24,13 +31,23 @@
 #define __NR_pidfd_getfd 438 /* Syscall id */
 #endif
 
-static UTIL_ONCE_FLAG Page_size_is_initialized = UTIL_ONCE_FLAG_INIT;
+// maximum value of the off_t type
+#define OFF_T_MAX                                                              \
+    (sizeof(off_t) == sizeof(long long)                                        \
+         ? LLONG_MAX                                                           \
+         : (sizeof(off_t) == sizeof(long) ? LONG_MAX : INT_MAX))
+
+static UTIL_ONCE_FLAG System_info_is_initialized = UTIL_ONCE_FLAG_INIT;
 static size_t Page_size;
+static unsigned Core_count;
 
-static void _util_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 util_get_page_size(void) {
-    util_init_once(&Page_size_is_initialized, _util_get_page_size);
+size_t utils_get_page_size(void) {
+    utils_init_once(&System_info_is_initialized, _utils_get_system_info);
     return Page_size;
 }
 
@@ -49,10 +66,14 @@ 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); }
 
-#ifndef __APPLE__
-static umf_result_t errno_to_umf_result(int err) {
+umf_result_t utils_errno_to_umf_result(int err) {
     switch (err) {
     case EBADF:
     case EINVAL:
@@ -70,7 +91,6 @@ static umf_result_t errno_to_umf_result(int err) {
         return UMF_RESULT_ERROR_UNKNOWN;
     }
 }
-#endif
 
 umf_result_t utils_duplicate_fd(int pid, int fd_in, int *fd_out) {
 #ifdef __APPLE__
@@ -80,23 +100,22 @@ umf_result_t utils_duplicate_fd(int pid, int fd_in, int *fd_out) {
     return UMF_RESULT_ERROR_NOT_SUPPORTED;
 #else
     // pidfd_getfd(2) is used to obtain a duplicate of another process's file descriptor.
-    // Permission to duplicate another process's file descriptor
-    // is governed by a ptrace access mode PTRACE_MODE_ATTACH_REALCREDS check (see ptrace(2))
-    // that can be changed using the /proc/sys/kernel/yama/ptrace_scope interface.
+    // Calling prctl(PR_SET_PTRACER, getppid()) in a producer binary that creates IPC handle
+    // allows file descriptor duplication for parent process and its children.
     // pidfd_getfd(2) is supported since Linux 5.6
     // pidfd_open(2) is supported since Linux 5.3
     errno = 0;
     int pid_fd = syscall(__NR_pidfd_open, pid, 0);
     if (pid_fd == -1) {
         LOG_PERR("__NR_pidfd_open");
-        return errno_to_umf_result(errno);
+        return utils_errno_to_umf_result(errno);
     }
 
     int fd_dup = syscall(__NR_pidfd_getfd, pid_fd, fd_in, 0);
     close(pid_fd);
     if (fd_dup == -1) {
         LOG_PERR("__NR_pidfd_open");
-        return errno_to_umf_result(errno);
+        return utils_errno_to_umf_result(errno);
     }
 
     *fd_out = fd_dup;
@@ -104,3 +123,178 @@ umf_result_t utils_duplicate_fd(int pid, int fd_in, int *fd_out) {
     return UMF_RESULT_SUCCESS;
 #endif
 }
+
+umf_result_t utils_translate_mem_protection_one_flag(unsigned in_protection,
+                                                     unsigned *out_protection) {
+    switch (in_protection) {
+    case UMF_PROTECTION_NONE:
+        *out_protection = PROT_NONE;
+        return UMF_RESULT_SUCCESS;
+    case UMF_PROTECTION_READ:
+        *out_protection = PROT_READ;
+        return UMF_RESULT_SUCCESS;
+    case UMF_PROTECTION_WRITE:
+        *out_protection = PROT_WRITE;
+        return UMF_RESULT_SUCCESS;
+    case UMF_PROTECTION_EXEC:
+        *out_protection = PROT_EXEC;
+        return UMF_RESULT_SUCCESS;
+    }
+    return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+}
+
+size_t get_max_file_size(void) { return OFF_T_MAX; }
+
+umf_result_t utils_translate_mem_protection_flags(unsigned in_protection,
+                                                  unsigned *out_protection) {
+    // translate protection - combination of 'umf_mem_protection_flags_t' flags
+    return utils_translate_flags(in_protection, UMF_PROTECTION_MAX,
+                                 utils_translate_mem_protection_one_flag,
+                                 out_protection);
+}
+
+int utils_translate_purge_advise(umf_purge_advise_t advise) {
+    switch (advise) {
+    case UMF_PURGE_LAZY:
+        return MADV_FREE;
+    case UMF_PURGE_FORCE:
+        return MADV_DONTNEED;
+    default:
+        return -1;
+    }
+}
+
+void *utils_mmap(void *hint_addr, size_t length, int prot, int flag, int fd,
+                 size_t fd_offset) {
+    fd = (fd == 0) ? -1 : fd;
+    if (fd == -1) {
+        // MAP_ANONYMOUS - the mapping is not backed by any file
+        flag |= MAP_ANONYMOUS;
+    }
+
+    void *ptr = mmap(hint_addr, length, prot, flag, fd, fd_offset);
+    if (ptr == MAP_FAILED) {
+        return NULL;
+    }
+    // this should be unnecessary but pairs of mmap/munmap do not reset
+    // asan's user-poisoning flags, leading to invalid error reports
+    // Bug 81619: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81619
+    utils_annotate_memory_defined(ptr, length);
+    return ptr;
+}
+
+int utils_munmap(void *addr, size_t length) {
+    // this should be unnecessary but pairs of mmap/munmap do not reset
+    // asan's user-poisoning flags, leading to invalid error reports
+    // Bug 81619: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81619
+    utils_annotate_memory_defined(addr, length);
+    return munmap(addr, length);
+}
+
+int utils_purge(void *addr, size_t length, int advice) {
+    return madvise(addr, length, utils_translate_purge_advise(advice));
+}
+
+void utils_strerror(int errnum, char *buf, size_t buflen) {
+// 'strerror_r' implementation is XSI-compliant (returns 0 on success)
+#if (_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && !_GNU_SOURCE
+    if (strerror_r(errnum, buf, buflen)) {
+#else // 'strerror_r' implementation is GNU-specific (returns pointer on success)
+    if (!strerror_r(errnum, buf, buflen)) {
+#endif
+        LOG_PERR("Retrieving error code description failed");
+    }
+}
+
+// open a devdax
+int utils_devdax_open(const char *path) {
+    if (path == NULL) {
+        LOG_ERR("empty path");
+        return -1;
+    }
+
+    if (strstr(path, "/dev/dax") != path) {
+        LOG_ERR("path of the file \"%s\" does not start with \"/dev/dax\"",
+                path);
+        return -1;
+    }
+
+    int fd = open(path, O_RDWR);
+    if (fd == -1) {
+        LOG_PERR("cannot open the file: %s", path);
+        return -1;
+    }
+
+    struct stat statbuf;
+    int ret = stat(path, &statbuf);
+    if (ret) {
+        LOG_PERR("stat(%s) failed", path);
+        close(fd);
+        return -1;
+    }
+
+    if (!S_ISCHR(statbuf.st_mode)) {
+        LOG_ERR("file %s is not a character device", path);
+        close(fd);
+        return -1;
+    }
+
+    return fd;
+}
+
+// open a file
+int utils_file_open(const char *path) {
+    if (!path) {
+        LOG_ERR("empty path");
+        return -1;
+    }
+
+    int fd = open(path, O_RDWR);
+    if (fd == -1) {
+        LOG_PERR("cannot open the file: %s", path);
+    }
+
+    return fd;
+}
+
+// open a file or create
+int utils_file_open_or_create(const char *path) {
+    if (!path) {
+        LOG_ERR("empty path");
+        return -1;
+    }
+
+    int fd = open(path, O_RDWR | O_CREAT, 0600);
+    if (fd == -1) {
+        LOG_PERR("cannot open/create the file: %s", path);
+        return -1;
+    }
+
+    LOG_DEBUG("opened/created the file: %s", path);
+
+    return fd;
+}
+
+// Expected input:
+// char *str_threshold = utils_env_var_get_str("UMF_PROXY", "size.threshold=");
+long utils_get_size_threshold(char *str_threshold) {
+    if (!str_threshold) {
+        return 0;
+    }
+
+    // move to the beginning of the number
+    str_threshold += strlen("size.threshold=");
+
+    // check if the first character is a digit
+    if (!isdigit(str_threshold[0])) {
+        LOG_ERR("incorrect size threshold, expected numerical value >=0: %s",
+                str_threshold);
+        return -1;
+    }
+
+    size_t threshold = atol(str_threshold);
+    LOG_DEBUG("Size_threshold_value = (char *) %s, (size_t) %zu", str_threshold,
+              threshold);
+
+    return threshold;
+}
diff --git a/src/utils/utils_posix_concurrency.c b/src/utils/utils_posix_concurrency.c
index 5f2b2569d..44a317361 100644
--- a/src/utils/utils_posix_concurrency.c
+++ b/src/utils/utils_posix_concurrency.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -11,29 +11,62 @@
 #include <stdlib.h>
 
 #include "utils_concurrency.h"
+#include "utils_log.h"
 
-size_t util_mutex_get_size(void) { return sizeof(pthread_mutex_t); }
+size_t utils_mutex_get_size(void) { return sizeof(pthread_mutex_t); }
 
-os_mutex_t *util_mutex_init(void *ptr) {
+utils_mutex_t *utils_mutex_init(utils_mutex_t *ptr) {
     pthread_mutex_t *mutex = (pthread_mutex_t *)ptr;
     int ret = pthread_mutex_init(mutex, NULL);
-    return ret == 0 ? ((os_mutex_t *)mutex) : NULL;
+    return ret == 0 ? ((utils_mutex_t *)mutex) : NULL;
 }
 
-void util_mutex_destroy_not_free(os_mutex_t *m) {
+void utils_mutex_destroy_not_free(utils_mutex_t *m) {
     pthread_mutex_t *mutex = (pthread_mutex_t *)m;
     int ret = pthread_mutex_destroy(mutex);
-    (void)ret; // TODO: add logging
+    if (ret) {
+        LOG_ERR("pthread_mutex_destroy failed");
+    }
 }
 
-int util_mutex_lock(os_mutex_t *m) {
+int utils_mutex_lock(utils_mutex_t *m) {
     return pthread_mutex_lock((pthread_mutex_t *)m);
 }
 
-int util_mutex_unlock(os_mutex_t *m) {
+int utils_mutex_unlock(utils_mutex_t *m) {
     return pthread_mutex_unlock((pthread_mutex_t *)m);
 }
 
-void util_init_once(UTIL_ONCE_FLAG *flag, void (*oneCb)(void)) {
+void utils_init_once(UTIL_ONCE_FLAG *flag, void (*oneCb)(void)) {
     pthread_once(flag, oneCb);
 }
+
+utils_rwlock_t *utils_rwlock_init(utils_rwlock_t *ptr) {
+    pthread_rwlock_t *rwlock = (pthread_rwlock_t *)ptr;
+    int ret = pthread_rwlock_init(rwlock, NULL);
+    return ret == 0 ? ((utils_rwlock_t *)rwlock) : NULL;
+}
+
+void utils_rwlock_destroy_not_free(utils_rwlock_t *ptr) {
+    pthread_rwlock_t *rwlock = (pthread_rwlock_t *)ptr;
+    int ret = pthread_rwlock_destroy(rwlock);
+    if (ret) {
+        LOG_ERR("pthread_rwlock_destroy failed");
+    }
+}
+
+int utils_read_lock(utils_rwlock_t *rwlock) {
+    return pthread_rwlock_rdlock((pthread_rwlock_t *)rwlock);
+}
+
+int utils_write_lock(utils_rwlock_t *rwlock) {
+    return pthread_rwlock_wrlock((pthread_rwlock_t *)rwlock);
+}
+
+int utils_read_unlock(utils_rwlock_t *rwlock) {
+    return pthread_rwlock_unlock((pthread_rwlock_t *)rwlock);
+}
+
+int utils_write_unlock(utils_rwlock_t *rwlock) {
+    return pthread_rwlock_unlock((pthread_rwlock_t *)rwlock);
+}
diff --git a/src/utils/utils_posix_math.c b/src/utils/utils_posix_math.c
deleted file mode 100644
index 465b68772..000000000
--- a/src/utils/utils_posix_math.c
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- *
- * Copyright (C) 2023 Intel Corporation
- *
- * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- *
- */
-
-#include "utils_math.h"
-#include <limits.h>
-
-// Retrieves the position of the leftmost set bit.
-// The position of the bit is counted from 0
-// e.g. for 01000011110 the position equals 9.
-size_t getLeftmostSetBitPos(size_t num) {
-    assert(num != 0 &&
-           "Finding leftmost set bit when number equals zero is undefined");
-    return (sizeof(num) * CHAR_BIT - 1) - __builtin_clzll(num);
-}
diff --git a/src/utils/utils_sanitizers.h b/src/utils/utils_sanitizers.h
index 3498e4b70..f8896d0ae 100644
--- a/src/utils/utils_sanitizers.h
+++ b/src/utils/utils_sanitizers.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -168,6 +168,24 @@ static inline void utils_annotate_memory_inaccessible(void *ptr, size_t size) {
 #endif
 }
 
+static inline void utils_annotate_memory_new(void *ptr, size_t size) {
+#ifdef UMF_VG_DRD_ENABLED
+    ANNOTATE_NEW_MEMORY(ptr, size);
+#else
+    (void)ptr;
+    (void)size;
+#endif
+}
+
+static inline void utils_annotate_memory_no_check(void *ptr, size_t size) {
+#ifdef UMF_VG_HELGRIND_ENABLED
+    VALGRIND_HG_DISABLE_CHECKING(ptr, size);
+#else
+    (void)ptr;
+    (void)size;
+#endif
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/utils/utils_windows_common.c b/src/utils/utils_windows_common.c
index 9358891ad..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
@@ -9,28 +9,40 @@
 
 #include <windows.h>
 
+#include <assert.h>
 #include <processenv.h>
 #include <processthreadsapi.h>
+#include <stdio.h>
+#include <string.h>
+#include <sysinfoapi.h>
 
 #include "utils_common.h"
 #include "utils_concurrency.h"
+#include "utils_log.h"
 
 #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 _util_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 util_get_page_size(void) {
-    util_init_once(&Page_size_is_initialized, _util_get_page_size);
+size_t utils_get_page_size(void) {
+    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(); }
@@ -40,9 +52,190 @@ int utils_close_fd(int fd) {
     return -1;
 }
 
+umf_result_t utils_errno_to_umf_result(int err) {
+    (void)err; // unused
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
 umf_result_t utils_duplicate_fd(int pid, int fd_in, int *fd_out) {
     (void)pid;    // unused
     (void)fd_in;  // unused
     (void)fd_out; // unused
     return UMF_RESULT_ERROR_NOT_SUPPORTED;
 }
+
+umf_result_t utils_translate_mem_protection_flags(unsigned in_protection,
+                                                  unsigned *out_protection) {
+    switch (in_protection) {
+    case UMF_PROTECTION_NONE:
+        *out_protection = PAGE_NOACCESS;
+        return UMF_RESULT_SUCCESS;
+    case UMF_PROTECTION_EXEC:
+        *out_protection = PAGE_EXECUTE;
+        return UMF_RESULT_SUCCESS;
+    case (UMF_PROTECTION_EXEC | UMF_PROTECTION_READ):
+        *out_protection = PAGE_EXECUTE_READ;
+        return UMF_RESULT_SUCCESS;
+    case (UMF_PROTECTION_EXEC | UMF_PROTECTION_READ | UMF_PROTECTION_WRITE):
+        *out_protection = PAGE_EXECUTE_READWRITE;
+        return UMF_RESULT_SUCCESS;
+    case (UMF_PROTECTION_EXEC | UMF_PROTECTION_WRITE):
+        *out_protection = PAGE_EXECUTE_WRITECOPY;
+        return UMF_RESULT_SUCCESS;
+    case UMF_PROTECTION_READ:
+        *out_protection = PAGE_READONLY;
+        return UMF_RESULT_SUCCESS;
+    case (UMF_PROTECTION_READ | UMF_PROTECTION_WRITE):
+        *out_protection = PAGE_READWRITE;
+        return UMF_RESULT_SUCCESS;
+    case UMF_PROTECTION_WRITE:
+        *out_protection = PAGE_WRITECOPY;
+        return UMF_RESULT_SUCCESS;
+    }
+    LOG_ERR(
+        "utils_translate_mem_protection_flags(): unsupported protection flag: "
+        "%u",
+        in_protection);
+    return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+}
+
+int utils_translate_purge_advise(umf_purge_advise_t advise) {
+    (void)advise; // unused
+    return -1;
+}
+
+umf_result_t
+utils_translate_mem_visibility_flag(umf_memory_visibility_t in_flag,
+                                    unsigned *out_flag) {
+    switch (in_flag) {
+    case UMF_MEM_MAP_PRIVATE:
+        *out_flag = 0; // ignored on Windows
+        return UMF_RESULT_SUCCESS;
+    case UMF_MEM_MAP_SHARED:
+        return UMF_RESULT_ERROR_NOT_SUPPORTED; // not supported on Windows yet
+    }
+    return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+}
+
+// create a shared memory file
+int utils_shm_create(const char *shm_name, size_t size) {
+    (void)shm_name; // unused
+    (void)size;     // unused
+    return 0;       // ignored on Windows
+}
+
+// open a shared memory file
+int utils_shm_open(const char *shm_name) {
+    (void)shm_name; // unused
+    return 0;       // ignored on Windows
+}
+
+// unlink a shared memory file
+int utils_shm_unlink(const char *shm_name) {
+    (void)shm_name; // unused
+    return 0;       // ignored on Windows
+}
+
+int utils_create_anonymous_fd(void) {
+    return 0; // ignored on Windows
+}
+
+size_t get_max_file_size(void) { return SIZE_MAX; }
+
+int utils_get_file_size(int fd, size_t *size) {
+    (void)fd;   // unused
+    (void)size; // unused
+    return -1;  // not supported on Windows
+}
+
+int utils_set_file_size(int fd, size_t size) {
+    (void)fd;   // unused
+    (void)size; // unused
+    return 0;   // ignored on Windows
+}
+
+void *utils_mmap(void *hint_addr, size_t length, int prot, int flag, int fd,
+                 size_t fd_offset) {
+    (void)flag;      // ignored on Windows
+    (void)fd;        // ignored on Windows
+    (void)fd_offset; // ignored on Windows
+    return VirtualAlloc(hint_addr, length, MEM_RESERVE | MEM_COMMIT, prot);
+}
+
+void *utils_mmap_file(void *hint_addr, size_t length, int prot, int flags,
+                      int fd, size_t fd_offset, bool *map_sync) {
+    (void)hint_addr; // unused
+    (void)length;    // unused
+    (void)prot;      // unused
+    (void)flags;     // unused
+    (void)fd;        // unused
+    (void)fd_offset; // unused
+    (void)map_sync;  // unused
+    return NULL;     // not supported
+}
+
+int utils_munmap(void *addr, size_t length) {
+    // If VirtualFree() succeeds, the return value is nonzero.
+    // If VirtualFree() fails, the return value is 0 (zero).
+    (void)length; // unused
+    return (VirtualFree(addr, 0, MEM_RELEASE) == 0);
+}
+
+int utils_purge(void *addr, size_t length, int advice) {
+    // If VirtualFree() succeeds, the return value is nonzero.
+    // If VirtualFree() fails, the return value is 0 (zero).
+    (void)advice; // unused
+
+    // temporarily disable the C6250 warning as we intentionally use the
+    // MEM_DECOMMIT flag only
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 6250)
+#endif // _MSC_VER
+
+    return (VirtualFree(addr, length, MEM_DECOMMIT) == 0);
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif // _MSC_VER
+}
+
+void utils_strerror(int errnum, char *buf, size_t buflen) {
+    strerror_s(buf, buflen, errnum);
+}
+
+// open a devdax
+int utils_devdax_open(const char *path) {
+    (void)path; // unused
+
+    return -1;
+}
+
+// open a file
+int utils_file_open(const char *path) {
+    (void)path; // unused
+
+    return -1;
+}
+
+// open a file or create
+int utils_file_open_or_create(const char *path) {
+    (void)path; // unused
+
+    return -1;
+}
+
+int utils_fallocate(int fd, long offset, long len) {
+    (void)fd;     // unused
+    (void)offset; // unused
+    (void)len;    // unused
+
+    return -1;
+}
+
+// Expected input:
+// char *str_threshold = utils_env_var_get_str("UMF_PROXY", "size.threshold=");
+long utils_get_size_threshold(char *str_threshold) {
+    (void)str_threshold; // unused
+    return 0;
+}
diff --git a/src/utils/utils_windows_concurrency.c b/src/utils/utils_windows_concurrency.c
index 50bc71c66..faa302be3 100644
--- a/src/utils/utils_windows_concurrency.c
+++ b/src/utils/utils_windows_concurrency.c
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -9,37 +9,63 @@
 
 #include "utils_concurrency.h"
 
-size_t util_mutex_get_size(void) { return sizeof(os_mutex_t); }
+size_t utils_mutex_get_size(void) { return sizeof(utils_mutex_t); }
 
-os_mutex_t *util_mutex_init(void *ptr) {
-    os_mutex_t *mutex_internal = (os_mutex_t *)ptr;
-    InitializeCriticalSection(&mutex_internal->lock);
-    return (os_mutex_t *)mutex_internal;
+utils_mutex_t *utils_mutex_init(utils_mutex_t *mutex) {
+    InitializeCriticalSection(&mutex->lock);
+    return mutex;
 }
 
-void util_mutex_destroy_not_free(os_mutex_t *mutex) {
-    os_mutex_t *mutex_internal = (os_mutex_t *)mutex;
-    DeleteCriticalSection(&mutex_internal->lock);
+void utils_mutex_destroy_not_free(utils_mutex_t *mutex) {
+    DeleteCriticalSection(&mutex->lock);
 }
 
-int util_mutex_lock(os_mutex_t *mutex) {
-    os_mutex_t *mutex_internal = (os_mutex_t *)mutex;
-    EnterCriticalSection(&mutex_internal->lock);
+int utils_mutex_lock(utils_mutex_t *mutex) {
+    EnterCriticalSection(&mutex->lock);
 
-    if (mutex_internal->lock.RecursionCount > 1) {
-        LeaveCriticalSection(&mutex_internal->lock);
+    if (mutex->lock.RecursionCount > 1) {
+        LeaveCriticalSection(&mutex->lock);
         /* deadlock detected */
-        return -1;
+        abort();
     }
     return 0;
 }
 
-int util_mutex_unlock(os_mutex_t *mutex) {
-    os_mutex_t *mutex_internal = (os_mutex_t *)mutex;
-    LeaveCriticalSection(&mutex_internal->lock);
+int utils_mutex_unlock(utils_mutex_t *mutex) {
+    LeaveCriticalSection(&mutex->lock);
     return 0;
 }
 
+utils_rwlock_t *utils_rwlock_init(utils_rwlock_t *rwlock) {
+    InitializeSRWLock(&rwlock->lock);
+    return 0; // never fails
+}
+
+void utils_rwlock_destroy_not_free(utils_rwlock_t *rwlock) {
+    // there is no call to destroy SWR lock
+    (void)rwlock;
+}
+
+int utils_read_lock(utils_rwlock_t *rwlock) {
+    AcquireSRWLockShared(&rwlock->lock);
+    return 0; // never fails
+}
+
+int utils_write_lock(utils_rwlock_t *rwlock) {
+    AcquireSRWLockExclusive(&rwlock->lock);
+    return 0; // never fails
+}
+
+int utils_read_unlock(utils_rwlock_t *rwlock) {
+    ReleaseSRWLockShared(&rwlock->lock);
+    return 0; // never fails
+}
+
+int utils_write_unlock(utils_rwlock_t *rwlock) {
+    ReleaseSRWLockExclusive(&rwlock->lock);
+    return 0; // never fails
+}
+
 static BOOL CALLBACK initOnceCb(PINIT_ONCE InitOnce, PVOID Parameter,
                                 PVOID *lpContext) {
     (void)InitOnce;  // unused
@@ -50,6 +76,6 @@ static BOOL CALLBACK initOnceCb(PINIT_ONCE InitOnce, PVOID Parameter,
     return TRUE;
 }
 
-void util_init_once(UTIL_ONCE_FLAG *flag, void (*onceCb)(void)) {
+void utils_init_once(UTIL_ONCE_FLAG *flag, void (*onceCb)(void)) {
     InitOnceExecuteOnce(flag, initOnceCb, (void *)onceCb, NULL);
 }
diff --git a/src/utils/utils_windows_math.c b/src/utils/utils_windows_math.c
deleted file mode 100644
index 07c4c9978..000000000
--- a/src/utils/utils_windows_math.c
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- *
- * Copyright (C) 2023 Intel Corporation
- *
- * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- *
- */
-
-#include "utils_math.h"
-#include "utils_windows_intrin.h"
-
-#pragma intrinsic(_BitScanReverse)
-
-// Retrieves the position of the leftmost set bit.
-// The position of the bit is counted from 0
-// e.g. for 01000011110 the position equals 9.
-size_t getLeftmostSetBitPos(size_t num) {
-    assert(num != 0 &&
-           "Finding leftmost set bit when number equals zero is undefined");
-    unsigned long index = 0;
-    _BitScanReverse(&index, (unsigned long)num);
-    return (size_t)index;
-}
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 9af694489..bda44ea04 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,15 +1,21 @@
-# Copyright (C) 2022-2024 Intel Corporation
+# Copyright (C) 2022-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED YES)
 
+if(CMAKE_C_COMPILER_ID STREQUAL "IntelLLVM")
+    # Compiler dependencies needs to be in library path or to be linked
+    # statically
+    add_link_options(-static-intel)
+endif()
+
 include(FetchContent)
 FetchContent_Declare(
     googletest
     GIT_REPOSITORY https://github.com/google/googletest.git
-    GIT_TAG release-1.12.1)
+    GIT_TAG v1.15.2)
 
 # For Windows: Prevent overriding the parent project's compiler/linker settings
 set(gtest_force_shared_crt
@@ -22,10 +28,15 @@ FetchContent_MakeAvailable(googletest)
 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: * NAME - a name of the test * SRCS - source files * LIBS -
-    # libraries to be linked with
+    # Parameters:
+    #
+    # * NAME - a name of the test
+    # * SRCS - source files
+    # * LIBS - libraries to be linked with
     set(oneValueArgs NAME)
     set(multiValueArgs SRCS LIBS)
     cmake_parse_arguments(
@@ -35,32 +46,51 @@ function(build_umf_test)
         "${multiValueArgs}"
         ${ARGN})
 
-    set(TEST_NAME umf-${ARG_NAME})
-    set(TEST_TARGET_NAME umf_test-${ARG_NAME})
+    set(TEST_NAME test_${ARG_NAME})
+    set(TEST_TARGET_NAME test_${ARG_NAME})
 
     set(LIB_DIRS ${LIB_DIRS} ${LIBHWLOC_LIBRARY_DIRS})
 
-    if(UMF_BUILD_LIBUMF_POOL_JEMALLOC)
-        set(LIB_DIRS ${LIB_DIRS} ${JEMALLOC_LIBRARY_DIRS})
+    if(UMF_CUDA_ENABLED)
+        set(INC_DIRS ${INC_DIRS} ${CUDA_INCLUDE_DIRS})
+        set(LIB_DIRS ${LIB_DIRS} ${CUDA_LIBRARY_DIRS})
     endif()
 
-    set(TEST_LIBS
-        umf_test_common
-        ${ARG_LIBS}
-        GTest::gtest_main
-        ${LIBS_OPTIONAL}
-        umf)
+    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)
+        set(INC_DIRS ${INC_DIRS} ${LIBHWLOC_INCLUDE_DIRS})
+    endif()
+
+    if(UMF_POOL_JEMALLOC_ENABLED)
+        set(CPL_DEFS ${CPL_DEFS} UMF_POOL_JEMALLOC_ENABLED=1)
+    endif()
+
+    if(UMF_POOL_SCALABLE_ENABLED)
+        set(CPL_DEFS ${CPL_DEFS} UMF_POOL_SCALABLE_ENABLED=1)
+    endif()
+
+    set(TEST_LIBS umf_test_common ${ARG_LIBS} GTest::gtest_main umf)
 
     add_umf_executable(
         NAME ${TEST_TARGET_NAME}
         SRCS ${ARG_SRCS}
         LIBS ${TEST_LIBS})
 
+    target_compile_definitions(${TEST_TARGET_NAME} PRIVATE ${CPL_DEFS})
+
     if(NOT MSVC)
         # Suppress 'cast discards const qualifier' warnings. Parametrized GTEST
         # tests retrieve arguments using 'GetParam()', which applies a 'const'
         # qualifier often discarded in the test scenarios.
         target_compile_options(${TEST_TARGET_NAME} PRIVATE -Wno-cast-qual)
+
+        if(UMF_DEVELOPER_MODE)
+            target_compile_options(${TEST_TARGET_NAME} PRIVATE -Werror)
+        endif()
     endif()
 
     target_link_directories(${TEST_TARGET_NAME} PRIVATE ${LIB_DIRS})
@@ -70,16 +100,22 @@ function(build_umf_test)
         PRIVATE ${UMF_CMAKE_SOURCE_DIR}/include
                 ${UMF_CMAKE_SOURCE_DIR}/src
                 ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc
+                ${UMF_CMAKE_SOURCE_DIR}/src/coarse
                 ${UMF_CMAKE_SOURCE_DIR}/src/utils
                 ${UMF_TEST_DIR}/common
-                ${UMF_TEST_DIR})
+                ${UMF_TEST_DIR}
+                ${INC_DIRS})
 endfunction()
 
 function(add_umf_test)
-    # Parameters: * NAME - a name of the test * SRCS - source files * LIBS -
-    # libraries to be linked with
+    # Parameters:
+    #
+    # * NAME - a name of the test
+    # * SRCS - source files
+    # * LIBS - libraries to be linked with
+    # * ENVS - environment variables
     set(oneValueArgs NAME)
-    set(multiValueArgs SRCS LIBS)
+    set(multiValueArgs SRCS LIBS ENVS)
     cmake_parse_arguments(
         ARG
         ""
@@ -88,15 +124,12 @@ function(add_umf_test)
         ${ARGN})
 
     build_umf_test(
-        NAME
-        ${ARG_NAME}
-        SRCS
-        ${ARG_SRCS}
-        LIBS
-        ${ARG_LIBS})
+        NAME ${ARG_NAME}
+        SRCS ${ARG_SRCS}
+        LIBS ${ARG_LIBS})
 
-    set(TEST_NAME umf-${ARG_NAME})
-    set(TEST_TARGET_NAME umf_test-${ARG_NAME})
+    set(TEST_NAME test_${ARG_NAME})
+    set(TEST_TARGET_NAME test_${ARG_NAME})
 
     add_test(
         NAME ${TEST_NAME}
@@ -104,9 +137,19 @@ function(add_umf_test)
         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
     set_tests_properties(${TEST_NAME} PROPERTIES LABELS "umf")
+    if(ARG_ENVS)
+        set_tests_properties(${TEST_NAME} PROPERTIES ENVIRONMENT ${ARG_ENVS})
+    endif()
 
     if(WINDOWS)
-        # append PATH to DLLs
+        # add PATH to DLL on Windows
+        set(DLL_PATH_LIST
+            "${DLL_PATH_LIST};PATH=path_list_append:${CMAKE_BINARY_DIR}/bin/;PATH=path_list_append:${CMAKE_BINARY_DIR}/bin/$<CONFIG>/"
+        )
+
+        # append PATH to DLLs NOTE: this would work only for the CMake ver >= #
+        # 3.22. For the older versions, the PATH variable should be set in the
+        # test script)
         set_property(TEST ${TEST_NAME} PROPERTY ENVIRONMENT_MODIFICATION
                                                 "${DLL_PATH_LIST}")
     endif()
@@ -114,67 +157,122 @@ endfunction()
 
 add_subdirectory(common)
 
-add_umf_test(NAME base SRCS base.cpp)
-add_umf_test(NAME memoryPool SRCS memoryPoolAPI.cpp malloc_compliance_tests.cpp)
-add_umf_test(NAME memoryProvider SRCS memoryProviderAPI.cpp)
-
 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
-            ../src/utils/utils_common.c ../src/utils/utils_posix_common.c
-            ../src/utils/utils_posix_concurrency.c)
+            ${UMF_UTILS_DIR}/utils_common.c
+            ${UMF_UTILS_DIR}/utils_posix_common.c
+            ${UMF_UTILS_DIR}/utils_posix_concurrency.c)
+        if(LINUX)
+            set(UMF_UTILS_SOURCES ${UMF_UTILS_SOURCES}
+                                  ${UMF_UTILS_DIR}/utils_linux_common.c)
+            set(UMF_LOGGER_LIBS rt) # librt for shm_open()
+        elseif(MACOSX)
+            set(UMF_UTILS_SOURCES ${UMF_UTILS_SOURCES}
+                                  ${UMF_UTILS_DIR}/utils_macosx_common.c)
+        endif()
     elseif(WINDOWS)
         set(UMF_UTILS_SOURCES
-            ../src/utils/utils_common.c ../src/utils/utils_windows_common.c
-            ../src/utils/utils_windows_concurrency.c)
+            ${UMF_UTILS_DIR}/utils_common.c
+            ${UMF_UTILS_DIR}/utils_windows_common.c
+            ${UMF_UTILS_DIR}/utils_windows_concurrency.c)
     endif()
 endif()
 
-add_umf_test(NAME logger SRCS utils/utils_log.cpp ${UMF_UTILS_SOURCES})
+add_umf_test(NAME base SRCS base.cpp)
+
+add_umf_test(
+    NAME memoryPool
+    SRCS memoryPoolAPI.cpp malloc_compliance_tests.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+
+add_umf_test(
+    NAME memoryProvider
+    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_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(
     NAME utils_common
     SRCS utils/utils.cpp
     LIBS ${UMF_UTILS_FOR_TEST})
 
-if(UMF_BUILD_LIBUMF_POOL_DISJOINT)
+if(LINUX)
     add_umf_test(
-        NAME disjointPool
-        SRCS pools/disjoint_pool.cpp malloc_compliance_tests.cpp
-        LIBS disjoint_pool)
+        NAME utils_linux_common
+        SRCS utils/utils_linux.cpp
+        LIBS ${UMF_UTILS_FOR_TEST})
+endif()
+
+add_umf_test(
+    NAME coarse_lib
+    SRCS coarse_lib.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} umf_coarse)
+
+add_umf_test(
+    NAME disjoint_pool
+    SRCS pools/disjoint_pool.cpp malloc_compliance_tests.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+
+add_umf_test(
+    NAME disjoint_pool_ctl
+    SRCS pools/disjoint_pool_ctl.cpp malloc_compliance_tests.cpp
+         ${BA_SOURCES_FOR_TEST}
+    LIBS ${UMF_UTILS_FOR_TEST})
+
+add_umf_test(
+    NAME c_api_disjoint_pool
+    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 c_api_disjoint_pool
-        SRCS c_api/disjoint_pool.c
-        LIBS disjoint_pool)
+        NAME disjoint_pool_file_prov
+        SRCS disjoint_pool_file_prov.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 endif()
 
-if(UMF_BUILD_LIBUMF_POOL_DISJOINT
-   AND UMF_BUILD_LIBUMF_POOL_JEMALLOC
+if(UMF_POOL_JEMALLOC_ENABLED
    AND UMF_POOL_SCALABLE_ENABLED
    AND (NOT UMF_DISABLE_HWLOC))
-    add_umf_test(
-        NAME c_api_multi_pool
-        SRCS c_api/multi_pool.c
-        LIBS disjoint_pool jemalloc_pool ${JEMALLOC_LIBRARIES})
+    add_umf_test(NAME c_api_multi_pool SRCS c_api/multi_pool.c)
 endif()
 
-if(UMF_BUILD_LIBUMF_POOL_JEMALLOC AND (NOT UMF_DISABLE_HWLOC))
+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
-        LIBS jemalloc_pool)
+        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)
+    add_umf_test(
+        NAME scalable_pool
+        SRCS pools/scalable_pool.cpp malloc_compliance_tests.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
 endif()
 
 if(LINUX AND (NOT UMF_DISABLE_HWLOC)) # OS-specific functions are implemented
-                                      # only for
-    # Linux now
+                                      # only for Linux now
     if(PkgConfig_FOUND)
         pkg_check_modules(LIBNUMA numa)
     endif()
@@ -185,110 +283,257 @@ if(LINUX AND (NOT UMF_DISABLE_HWLOC)) # OS-specific functions are implemented
     add_umf_test(
         NAME provider_os_memory
         SRCS provider_os_memory.cpp
-        LIBS ${UMF_UTILS_FOR_TEST})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
     add_umf_test(
         NAME provider_os_memory_multiple_numa_nodes
         SRCS provider_os_memory_multiple_numa_nodes.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES})
     add_umf_test(
         NAME memspace_numa
         SRCS memspaces/memspace_numa.cpp
-        LIBS ${LIBNUMA_LIBRARIES} ${LIBHWLOC_LIBRARIES})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME provider_os_memory_config
         SRCS provider_os_memory_config.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES} ${LIBHWLOC_LIBRARIES})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME memspace_host_all
         SRCS memspaces/memspace_host_all.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES} ${LIBHWLOC_LIBRARIES})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME memspace_highest_capacity
         SRCS memspaces/memspace_highest_capacity.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES} ${LIBHWLOC_LIBRARIES})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME memspace_highest_bandwidth
         SRCS memspaces/memspace_highest_bandwidth.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES} ${LIBHWLOC_LIBRARIES})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME memspace_lowest_latency
         SRCS memspaces/memspace_lowest_latency.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES} ${LIBHWLOC_LIBRARIES})
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES}
+             ${UMF_HWLOC_NAME})
     add_umf_test(
         NAME mempolicy
         SRCS memspaces/mempolicy.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} ${LIBNUMA_LIBRARIES})
+    add_umf_test(
+        NAME memspace
+        SRCS memspaces/memspace.cpp
         LIBS ${LIBNUMA_LIBRARIES})
-    if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND UMF_BUILD_FUZZTESTS)
+    add_umf_test(
+        NAME memtarget
+        SRCS memspaces/memtarget.cpp
+        LIBS ${LIBNUMA_LIBRARIES} ${UMF_HWLOC_NAME})
+    add_umf_test(
+        NAME provider_devdax_memory
+        SRCS provider_devdax_memory.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+    add_umf_test(
+        NAME provider_devdax_memory_ipc
+        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} ${UMF_BA_FOR_TEST})
+    add_umf_test(
+        NAME provider_file_memory_ipc
+        SRCS provider_file_memory_ipc.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+    add_umf_test(
+        NAME provider_fixed_memory
+        SRCS provider_fixed_memory.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+    add_umf_test(
+        NAME provider_tracking
+        SRCS provider_tracking.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+    add_umf_test(
+        NAME provider_tracking_fixture_tests
+        SRCS provider_tracking_fixture_tests.cpp malloc_compliance_tests.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+
+    # This test requires Linux-only file memory provider
+    if(UMF_POOL_JEMALLOC_ENABLED)
+        add_umf_test(
+            NAME jemalloc_coarse_file
+            SRCS pools/jemalloc_coarse_file.cpp malloc_compliance_tests.cpp
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+        add_umf_test(
+            NAME jemalloc_coarse_devdax
+            SRCS pools/jemalloc_coarse_devdax.cpp malloc_compliance_tests.cpp
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+    endif()
+
+    # This test requires Linux-only file memory provider
+    if(UMF_POOL_SCALABLE_ENABLED)
+        add_umf_test(
+            NAME scalable_coarse_file
+            SRCS pools/scalable_coarse_file.cpp malloc_compliance_tests.cpp
+            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
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+    endif()
+
+    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} ${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} ${UMF_BA_FOR_TEST})
 endif()
 
-if(UMF_BUILD_GPU_TESTS AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
+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} ${UMF_BA_FOR_TEST})
+endif()
+
+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 providers/level_zero_helpers.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} ze_loader)
-    target_include_directories(umf_test-provider_level_zero
-                               PRIVATE ${LEVEL_ZERO_INCLUDE_DIRS})
+        SRCS providers/provider_level_zero.cpp
+             ${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
-        SRCS providers/provider_level_zero.cpp providers/level_zero_helpers.cpp
+        NAME provider_level_zero_dlopen_global
+        SRCS providers/provider_level_zero.cpp
+             ${UMF_UTILS_DIR}/utils_level_zero.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+    target_compile_definitions(test_provider_level_zero_dlopen_global
+                               PUBLIC USE_DLOPEN=1 OPEN_ZE_LIBRARY_GLOBAL=1)
+
+    add_umf_test(
+        NAME provider_level_zero_dlopen_local
+        SRCS providers/provider_level_zero.cpp
+             ${UMF_UTILS_DIR}/utils_level_zero.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+    target_compile_definitions(test_provider_level_zero_dlopen_local
+                               PUBLIC USE_DLOPEN=1 OPEN_ZE_LIBRARY_GLOBAL=0)
+endif()
+
+if(NOT UMF_BUILD_LEVEL_ZERO_PROVIDER)
+    add_umf_test(
+        NAME provider_level_zero_not_impl
+        SRCS providers/provider_level_zero_not_impl.cpp
         LIBS ${UMF_UTILS_FOR_TEST})
-    target_compile_definitions(umf_test-provider_level_zero_dlopen
-                               PUBLIC USE_DLOPEN=1)
-    target_include_directories(umf_test-provider_level_zero_dlopen
-                               PRIVATE ${LEVEL_ZERO_INCLUDE_DIRS})
 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})
+if(UMF_BUILD_GPU_TESTS AND UMF_BUILD_CUDA_PROVIDER)
+    if(UMF_CUDA_ENABLED)
+        # we have two test binaries here that use the same sources, but differ
+        # in the way they are linked to the CUDA (statically or at runtime using
+        # dlopen)
+        add_umf_test(
+            NAME provider_cuda
+            SRCS providers/provider_cuda.cpp providers/cuda_helpers.cpp
+            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
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+        target_compile_definitions(test_provider_cuda_dlopen_global
+                                   PUBLIC USE_DLOPEN=1 OPEN_CU_LIBRARY_GLOBAL=1)
+
+        add_umf_test(
+            NAME provider_cuda_dlopen_local
+            SRCS providers/provider_cuda.cpp providers/cuda_helpers.cpp
+            LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+        target_compile_definitions(test_provider_cuda_dlopen_local
+                                   PUBLIC USE_DLOPEN=1 OPEN_CU_LIBRARY_GLOBAL=0)
+    else()
+        message(
+            STATUS
+                "CUDA provider tests requires CUDA libraries to be installed and added to the default library search path - skipping"
+        )
+    endif()
+endif()
+
+if(NOT UMF_BUILD_CUDA_PROVIDER)
+    add_umf_test(
+        NAME provider_cuda_not_impl
+        SRCS providers/provider_cuda_not_impl.cpp
+        LIBS ${UMF_UTILS_FOR_TEST})
 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
-   AND NOT UMF_DISABLE_HWLOC
-   AND NOT UMF_LINK_HWLOC_STATICALLY)
+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 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")
+    endif()
+
     # the memoryPool test run with the proxy library
     add_umf_test(
         NAME proxy_lib_memoryPool
-        SRCS ${BA_SOURCES_FOR_TEST} memoryPoolAPI.cpp
-             malloc_compliance_tests.cpp
-        LIBS ${UMF_UTILS_FOR_TEST} umf_proxy)
-    target_compile_definitions(umf_test-proxy_lib_memoryPool
+        SRCS memoryPoolAPI.cpp malloc_compliance_tests.cpp
+        LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST} umf_proxy)
+    target_compile_definitions(test_proxy_lib_memoryPool
                                PUBLIC UMF_PROXY_LIB_ENABLED=1)
 endif()
 
-add_umf_test(NAME ipc SRCS ipcAPI.cpp)
+add_umf_test(
+    NAME ipc
+    SRCS ipcAPI.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+
+add_umf_test(
+    NAME ipc_max_opened_limit
+    SRCS ipcAPI.cpp
+    LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST}
+    ENVS "UMF_MAX_OPENED_IPC_HANDLES=10")
+
+add_umf_test(NAME ipc_negative SRCS ipc_negative.cpp)
 
 function(add_umf_ipc_test)
-    # Parameters: * TEST - a name of the test * SRC_DIR - source files directory
-    # path
+    # Parameters:
+    #
+    # * TEST - a name of the test
+    # * SRC_DIR - source files directory path
     set(oneValueArgs TEST SRC_DIR)
     cmake_parse_arguments(
         ARG
@@ -297,7 +542,7 @@ function(add_umf_ipc_test)
         ""
         ${ARGN})
 
-    set(TEST_NAME umf-${ARG_TEST})
+    set(TEST_NAME test_${ARG_TEST})
 
     if(DEFINED ARG_SRC_DIR)
         set(SRC_DIR ${ARG_SRC_DIR})
@@ -313,59 +558,86 @@ function(add_umf_ipc_test)
         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
     set_tests_properties(${TEST_NAME} PROPERTIES LABELS "umf")
+    set_tests_properties(${TEST_NAME} PROPERTIES TIMEOUT 60)
     if(NOT UMF_TESTS_FAIL_ON_SKIP)
         set_tests_properties(${TEST_NAME} PROPERTIES SKIP_RETURN_CODE 125)
     endif()
 endfunction()
 
 if(LINUX)
-    if(NOT UMF_DISABLE_HWLOC)
+    if(NOT UMF_DISABLE_HWLOC AND UMF_POOL_SCALABLE_ENABLED)
         build_umf_test(
-            NAME
-            ipc_os_prov_consumer
-            SRCS
-            ipc_os_prov_consumer.c
-            common/ipc_common.c
-            common/ipc_os_prov_common.c)
+            NAME ipc_os_prov_consumer
+            SRCS ipc_os_prov_consumer.c common/ipc_common.c
+                 common/ipc_os_prov_common.c)
         build_umf_test(
-            NAME
-            ipc_os_prov_producer
-            SRCS
-            ipc_os_prov_producer.c
-            common/ipc_common.c
-            common/ipc_os_prov_common.c)
+            NAME ipc_os_prov_producer
+            SRCS ipc_os_prov_producer.c common/ipc_common.c
+                 common/ipc_os_prov_common.c)
         add_umf_ipc_test(TEST ipc_os_prov_anon_fd)
         add_umf_ipc_test(TEST ipc_os_prov_shm)
+
+        if(UMF_PROXY_LIB_ENABLED AND UMF_BUILD_SHARED_LIBRARY)
+            build_umf_test(
+                NAME ipc_os_prov_proxy
+                SRCS ipc_os_prov_proxy.c common/ipc_common.c
+                LIBS ${UMF_UTILS_FOR_TEST})
+            add_umf_ipc_test(TEST ipc_os_prov_proxy)
+        endif()
+
+        build_umf_test(
+            NAME ipc_devdax_prov_consumer
+            SRCS ipc_devdax_prov_consumer.c common/ipc_common.c
+                 common/ipc_os_prov_common.c)
+        build_umf_test(
+            NAME ipc_devdax_prov_producer
+            SRCS ipc_devdax_prov_producer.c common/ipc_common.c
+                 common/ipc_os_prov_common.c)
+        add_umf_ipc_test(TEST ipc_devdax_prov)
+
+        build_umf_test(
+            NAME ipc_file_prov_consumer
+            SRCS ipc_file_prov_consumer.c common/ipc_common.c
+                 common/ipc_os_prov_common.c)
+        build_umf_test(
+            NAME ipc_file_prov_producer
+            SRCS ipc_file_prov_producer.c common/ipc_common.c
+                 common/ipc_os_prov_common.c)
+        add_umf_ipc_test(TEST ipc_file_prov)
+        add_umf_ipc_test(TEST ipc_file_prov_fsdax)
     endif()
-    if(UMF_BUILD_GPU_TESTS AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
+
+    # TODO add IPC tests for CUDA
+
+    if(UMF_BUILD_GPU_TESTS AND UMF_LEVEL_ZERO_ENABLED)
         build_umf_test(
-            NAME
-            ipc_level_zero_prov_consumer
-            SRCS
-            providers/ipc_level_zero_prov_consumer.c
-            common/ipc_common.c
-            providers/ipc_level_zero_prov_common.c
-            providers/level_zero_helpers.cpp
-            LIBS
-            ze_loader
-            ${UMF_UTILS_FOR_TEST})
+            NAME ipc_level_zero_prov_consumer
+            SRCS providers/ipc_level_zero_prov_consumer.c common/ipc_common.c
+                 providers/ipc_level_zero_prov_common.c
+                 ${UMF_UTILS_DIR}/utils_level_zero.cpp
+            LIBS ze_loader ${UMF_UTILS_FOR_TEST})
         build_umf_test(
-            NAME
-            ipc_level_zero_prov_producer
-            SRCS
-            providers/ipc_level_zero_prov_producer.c
-            common/ipc_common.c
-            providers/ipc_level_zero_prov_common.c
-            providers/level_zero_helpers.cpp
-            LIBS
-            ze_loader
-            ${UMF_UTILS_FOR_TEST})
-        target_include_directories(umf_test-ipc_level_zero_prov_producer
-                                   PRIVATE ${LEVEL_ZERO_INCLUDE_DIRS})
-        target_include_directories(umf_test-ipc_level_zero_prov_consumer
-                                   PRIVATE ${LEVEL_ZERO_INCLUDE_DIRS})
+            NAME ipc_level_zero_prov_producer
+            SRCS providers/ipc_level_zero_prov_producer.c common/ipc_common.c
+                 providers/ipc_level_zero_prov_common.c
+                 ${UMF_UTILS_DIR}/utils_level_zero.cpp
+            LIBS ze_loader ${UMF_UTILS_FOR_TEST})
         add_umf_ipc_test(TEST ipc_level_zero_prov SRC_DIR providers)
     endif()
+
+    if(UMF_BUILD_GPU_TESTS AND UMF_BUILD_CUDA_PROVIDER)
+        build_umf_test(
+            NAME ipc_cuda_prov_consumer
+            SRCS providers/ipc_cuda_prov_consumer.c common/ipc_common.c
+                 providers/ipc_cuda_prov_common.c providers/cuda_helpers.cpp
+            LIBS cuda ${UMF_UTILS_FOR_TEST})
+        build_umf_test(
+            NAME ipc_cuda_prov_producer
+            SRCS providers/ipc_cuda_prov_producer.c common/ipc_common.c
+                 providers/ipc_cuda_prov_common.c providers/cuda_helpers.cpp
+            LIBS cuda ${UMF_UTILS_FOR_TEST})
+        add_umf_ipc_test(TEST ipc_cuda_prov SRC_DIR providers)
+    endif()
 else()
     message(STATUS "IPC tests are supported on Linux only - skipping")
 endif()
@@ -380,7 +652,7 @@ if(LINUX
         LIBS dl)
     # append LD_LIBRARY_PATH to the libumf
     set_property(
-        TEST umf-init_teardown
+        TEST test_init_teardown
         PROPERTY ENVIRONMENT_MODIFICATION
                  "LD_LIBRARY_PATH=path_list_append:${CMAKE_BINARY_DIR}/lib")
 endif()
@@ -389,45 +661,63 @@ endif()
 # replace test_examples.sh with CMake script?)
 if(LINUX
    AND UMF_BUILD_SHARED_LIBRARY
+   AND UMF_BUILD_EXAMPLES
    AND NOT
        (UMF_USE_ASAN
         OR UMF_USE_UBSAN
         OR UMF_USE_TSAN
-        OR UMF_USE_MSAN))
+        OR UMF_USE_MSAN
+        OR UMF_USE_COVERAGE))
+
     set(EXAMPLES "")
+
     if(UMF_POOL_SCALABLE_ENABLED)
-        set(EXAMPLES ${EXAMPLES} basic)
+        set(EXAMPLES ${EXAMPLES} basic custom_file_provider)
     else()
         message(
             STATUS
-                "The basic example requires TBB to be installed and added to the default library search path - skipping"
+                "The basic and custom_file_provider examples require TBB to be installed and added to the default library search path - skipping"
         )
     endif()
 
-    if(UMF_BUILD_GPU_EXAMPLES
-       AND UMF_BUILD_LIBUMF_POOL_DISJOINT
-       AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
-        set(EXAMPLES ${EXAMPLES} gpu_shared_memory)
+    if(LIBNUMA_FOUND)
+        set(EXAMPLES ${EXAMPLES} memspace_hmat memspace_numa)
     else()
         message(
             STATUS
-                "GPU shared memory example requires UMF_BUILD_GPU_EXAMPLES, "
-                "UMF_BUILD_LEVEL_ZERO_PROVIDER and UMF_BUILD_LIBUMF_POOL_DISJOINT "
-                "to be turned ON - skipping")
+                "The memspace_hmat and memspace_numa examples require libnuma to be installed and added to the default library search path - skipping"
+        )
     endif()
 
-    if(UMF_BUILD_GPU_EXAMPLES
-       AND UMF_BUILD_LIBUMF_POOL_DISJOINT
-       AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
-        set(EXAMPLES ${EXAMPLES} ipc_level_zero)
+    if(UMF_BUILD_GPU_EXAMPLES AND UMF_LEVEL_ZERO_ENABLED)
+        set(EXAMPLES ${EXAMPLES} level_zero_shared_memory)
     else()
         message(
             STATUS
-                "IPC Level 0 example requires UMF_BUILD_GPU_EXAMPLES, UMF_BUILD_LEVEL_ZERO_PROVIDER and UMF_BUILD_LIBUMF_POOL_DISJOINT to be turned ON - skipping"
-        )
+                "GPU level zero shared memory example requires UMF_BUILD_GPU_EXAMPLES and "
+                "UMF_BUILD_LEVEL_ZERO_PROVIDER to be turned ON - skipping")
     endif()
 
-    if(LINUX AND UMF_POOL_SCALABLE_ENABLED)
+    if(UMF_BUILD_GPU_EXAMPLES AND UMF_CUDA_ENABLED)
+        set(EXAMPLES ${EXAMPLES} cuda_shared_memory)
+    else()
+        message(
+            STATUS
+                "GPU CUDA shared memory example requires UMF_BUILD_GPU_EXAMPLES "
+                "and UMF_BUILD_CUDA_PROVIDER to be turned ON and installed CUDA "
+                "libraries - skipping")
+    endif()
+
+    # TODO add IPC examples for CUDA
+    if(UMF_BUILD_GPU_EXAMPLES AND UMF_LEVEL_ZERO_ENABLED)
+        set(EXAMPLES ${EXAMPLES} ipc_level_zero)
+    else()
+        message(
+            STATUS "IPC Level Zero example requires UMF_BUILD_GPU_EXAMPLES and "
+                   "UMF_BUILD_LEVEL_ZERO_PROVIDER to be turned ON - skipping")
+    endif()
+
+    if(UMF_POOL_SCALABLE_ENABLED)
         set(EXAMPLES ${EXAMPLES} ipc_ipcapi)
     else()
         message(
@@ -436,13 +726,34 @@ if(LINUX
         )
     endif()
 
-    if(NOT UMF_DISABLE_HWLOC)
+    if(UMF_POOL_JEMALLOC_ENABLED)
+        set(EXAMPLES ${EXAMPLES} dram_and_fsdax)
+    else()
+        message(
+            STATUS
+                "The dram_and_fsdax example is supported on Linux only and requires the jemalloc pool, but it is disabled - skipping"
+        )
+    endif()
+
+    if(EXAMPLES AND NOT UMF_DISABLE_HWLOC)
+        set(STANDALONE_CMAKE_OPTIONS
+            "-DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
+        )
+        if(JEMALLOC_INCLUDE_DIRS)
+            # add custom jemalloc installation
+            set(STANDALONE_CMAKE_OPTIONS
+                "${STANDALONE_CMAKE_OPTIONS} -DCMAKE_PREFIX_PATH=${JEMALLOC_INCLUDE_DIRS}/../"
+            )
+        endif()
+
         add_test(
-            NAME umf_standalone_examples
+            NAME umf-standalone_examples
             COMMAND
                 ${UMF_CMAKE_SOURCE_DIR}/test/test_examples.sh
                 ${UMF_CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR}
-                ${CMAKE_INSTALL_PREFIX} ${EXAMPLES}
+                ${CMAKE_CURRENT_BINARY_DIR}/umf_standalone_examples/install-dir
+                "${CMAKE_INSTALL_PREFIX}" "${STANDALONE_CMAKE_OPTIONS}"
+                ${EXAMPLES}
             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
     endif()
 endif()
diff --git a/test/c_api/disjoint_pool.c b/test/c_api/disjoint_pool.c
index f63b28355..905835160 100644
--- a/test/c_api/disjoint_pool.c
+++ b/test/c_api/disjoint_pool.c
@@ -1,23 +1,29 @@
-// Copyright (C) 2023-2024 Intel Corporation
+// Copyright (C) 2023-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 #include <stdlib.h>
 
-#include "pool_disjoint.h"
+#include <umf/pools/pool_disjoint.h>
+
 #include "provider_null.h"
 #include "test_helpers.h"
+#include "test_ut_asserts.h"
 
 void test_disjoint_pool_default_params(void) {
     umf_memory_provider_handle_t provider = nullProviderCreate();
     umf_result_t retp;
     umf_memory_pool_handle_t pool = NULL;
-    umf_disjoint_pool_params_t params = umfDisjointPoolParamsDefault();
-    retp = umfPoolCreate(umfDisjointPoolOps(), provider, &params, 0, &pool);
+    umf_disjoint_pool_params_handle_t params = NULL;
+
+    retp = umfDisjointPoolParamsCreate(&params);
+    UT_ASSERTeq(retp, UMF_RESULT_SUCCESS);
 
+    retp = umfPoolCreate(umfDisjointPoolOps(), provider, params, 0, &pool);
     UT_ASSERTeq(retp, UMF_RESULT_SUCCESS);
 
     umfPoolDestroy(pool);
+    umfDisjointPoolParamsDestroy(params);
     umfMemoryProviderDestroy(provider);
 }
 
@@ -25,19 +31,28 @@ void test_disjoint_pool_shared_limits(void) {
     umf_memory_provider_handle_t provider = nullProviderCreate();
     umf_result_t retp;
     umf_memory_pool_handle_t pool = NULL;
-    umf_disjoint_pool_params_t params = umfDisjointPoolParamsDefault();
+    umf_disjoint_pool_params_handle_t params = NULL;
+
+    retp = umfDisjointPoolParamsCreate(&params);
+    UT_ASSERTeq(retp, UMF_RESULT_SUCCESS);
 
-    umf_disjoint_pool_shared_limits_t *limits =
+    umf_disjoint_pool_shared_limits_handle_t limits =
         umfDisjointPoolSharedLimitsCreate(1024);
-    params.SharedLimits = limits;
+    UT_ASSERTne(limits, NULL);
 
-    retp = umfPoolCreate(umfDisjointPoolOps(), provider, &params, 0, &pool);
+    retp = umfDisjointPoolParamsSetSharedLimits(params, limits);
+    UT_ASSERTeq(retp, UMF_RESULT_SUCCESS);
 
+    retp = umfPoolCreate(umfDisjointPoolOps(), provider, &params, 0, &pool);
     UT_ASSERTeq(retp, UMF_RESULT_SUCCESS);
 
     umfPoolDestroy(pool);
     umfMemoryProviderDestroy(provider);
-    umfDisjointPoolSharedLimitsDestroy(limits);
+    retp = umfDisjointPoolSharedLimitsDestroy(limits);
+    UT_ASSERTeq(retp, UMF_RESULT_SUCCESS);
+
+    retp = umfDisjointPoolParamsDestroy(params);
+    UT_ASSERTeq(retp, UMF_RESULT_SUCCESS);
 }
 
 int main(void) {
diff --git a/test/c_api/multi_pool.c b/test/c_api/multi_pool.c
index 9d4ee5d4c..bbd838312 100644
--- a/test/c_api/multi_pool.c
+++ b/test/c_api/multi_pool.c
@@ -12,14 +12,21 @@
 #include <umf/providers/provider_os_memory.h>
 
 #include "test_helpers.h"
+#include "test_ut_asserts.h"
 
 umf_memory_pool_handle_t
 createDisjointPool(umf_memory_provider_handle_t provider) {
     umf_memory_pool_handle_t pool = NULL;
-    umf_disjoint_pool_params_t params = umfDisjointPoolParamsDefault();
-    umf_result_t ret =
-        umfPoolCreate(umfDisjointPoolOps(), provider, &params, 0, &pool);
+    umf_disjoint_pool_params_handle_t params = NULL;
+
+    umf_result_t ret = umfDisjointPoolParamsCreate(&params);
     UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfPoolCreate(umfDisjointPoolOps(), provider, params, 0, &pool);
+    UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
+
+    umfDisjointPoolParamsDestroy(params);
+
     return pool;
 }
 
@@ -53,11 +60,15 @@ createScalablePool(umf_memory_provider_handle_t provider) {
 #define ALLOC_SIZE 64
 
 int main(void) {
-    umf_os_memory_provider_params_t params = umfOsMemoryProviderParamsDefault();
+    umf_os_memory_provider_params_handle_t params = NULL;
+    umf_result_t ret = umfOsMemoryProviderParamsCreate(&params);
+    UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
 
     umf_memory_provider_handle_t hProvider;
-    umf_result_t ret =
-        umfMemoryProviderCreate(umfOsMemoryProviderOps(), &params, &hProvider);
+    ret = umfMemoryProviderCreate(umfOsMemoryProviderOps(), params, &hProvider);
+    UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfOsMemoryProviderParamsDestroy(params);
     UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
 
     umf_memory_pool_handle_t pools[4];
diff --git a/test/c_api/test_ut_asserts.h b/test/c_api/test_ut_asserts.h
new file mode 100644
index 000000000..b73f0cd19
--- /dev/null
+++ b/test/c_api/test_ut_asserts.h
@@ -0,0 +1,75 @@
+/*
+ *
+ * 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
+ *
+ */
+
+/*
+ The project uses GTEST framework for testing, which is not supported in C
+ These asserts should NOT be used in other purposes than for testing C API
+ */
+
+#ifndef UMF_TEST_UT_ASSERTS_H
+#define UMF_TEST_UT_ASSERTS_H 1
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static inline void UT_FATAL(const char *format, ...) {
+    va_list args_list;
+    va_start(args_list, format);
+    vfprintf(stderr, format, args_list);
+    va_end(args_list);
+
+    fprintf(stderr, "\n");
+
+    abort();
+}
+
+static inline void UT_OUT(const char *format, ...) {
+    va_list args_list;
+    va_start(args_list, format);
+    vfprintf(stdout, format, args_list);
+    va_end(args_list);
+
+    fprintf(stdout, "\n");
+}
+
+// Assert a condition is true at runtime
+#define UT_ASSERT(cnd)                                                         \
+    ((void)((cnd) || (UT_FATAL("%s:%d %s - assertion failure: %s", __FILE__,   \
+                               __LINE__, __func__, #cnd),                      \
+                      0)))
+
+// Assertion with extra info printed if assertion fails at runtime
+#define UT_ASSERTinfo(cnd, info)                                               \
+    ((void)((cnd) ||                                                           \
+            (UT_FATAL("%s:%d %s - assertion failure: %s (%s = %s)", __FILE__,  \
+                      __LINE__, __func__, #cnd, #info, info),                  \
+             0)))
+
+// Assert two integer values are equal at runtime
+#define UT_ASSERTeq(lhs, rhs)                                                  \
+    ((void)(((lhs) == (rhs)) ||                                                \
+            (UT_FATAL("%s:%d %s - assertion failure: %s (0x%llx) == %s "       \
+                      "(0x%llx)",                                              \
+                      __FILE__, __LINE__, __func__, #lhs,                      \
+                      (unsigned long long)(lhs), #rhs,                         \
+                      (unsigned long long)(rhs)),                              \
+             0)))
+
+// Assert two integer values are not equal at runtime
+#define UT_ASSERTne(lhs, rhs)                                                  \
+    ((void)(((lhs) != (rhs)) ||                                                \
+            (UT_FATAL("%s:%d %s - assertion failure: %s (0x%llx) != %s "       \
+                      "(0x%llx)",                                              \
+                      __FILE__, __LINE__, __func__, #lhs,                      \
+                      (unsigned long long)(lhs), #rhs,                         \
+                      (unsigned long long)(rhs)),                              \
+             0)))
+
+#endif /* UMF_TEST_UT_ASSERTS_H */
diff --git a/test/coarse_lib.cpp b/test/coarse_lib.cpp
new file mode 100644
index 000000000..ceb4cd514
--- /dev/null
+++ b/test/coarse_lib.cpp
@@ -0,0 +1,1411 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#include "coarse.h"
+#include "provider.hpp"
+
+using umf_test::KB;
+using umf_test::MB;
+using umf_test::test;
+
+#define MOCKED_COARSE ((coarse_t *)0x01)
+#define MOCKED_PROVIDER ((umf_memory_provider_handle_t)0x02)
+#define INVALID_PTR ((void *)0x03)
+
+static umf_result_t alloc_cb(void *provider, size_t size, size_t alignment,
+                             void **ptr) {
+    return umfMemoryProviderAlloc((umf_memory_provider_handle_t)provider, size,
+                                  alignment, ptr);
+}
+
+static umf_result_t free_cb(void *provider, void *ptr, size_t size) {
+    return umfMemoryProviderFree((umf_memory_provider_handle_t)provider, ptr,
+                                 size);
+}
+
+static umf_result_t split_cb(void *provider, void *ptr, size_t totalSize,
+                             size_t firstSize) {
+    if (provider == NULL || ptr == NULL || (firstSize >= totalSize) ||
+        firstSize == 0 || totalSize == 0) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t merge_cb(void *provider, void *lowPtr, void *highPtr,
+                             size_t totalSize) {
+    if (provider == NULL || lowPtr == NULL || highPtr == NULL ||
+        totalSize == 0 || ((uintptr_t)highPtr <= (uintptr_t)lowPtr) ||
+        ((uintptr_t)highPtr - (uintptr_t)lowPtr >= totalSize)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t alloc_cb_fails(void *provider, size_t size,
+                                   size_t alignment, void **ptr) {
+    (void)provider;  //unused
+    (void)size;      //unused
+    (void)alignment; //unused
+    (void)ptr;       //unused
+    return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+}
+
+static umf_result_t free_cb_fails(void *provider, void *ptr, size_t size) {
+    (void)provider; //unused
+    (void)ptr;      //unused
+    (void)size;     //unused
+    return UMF_RESULT_ERROR_USER_SPECIFIC;
+}
+
+static umf_result_t split_cb_fails(void *provider, void *ptr, size_t totalSize,
+                                   size_t firstSize) {
+    (void)provider;  //unused
+    (void)ptr;       //unused
+    (void)totalSize; //unused
+    (void)firstSize; //unused
+    return UMF_RESULT_ERROR_USER_SPECIFIC;
+}
+
+static umf_result_t merge_cb_fails(void *provider, void *lowPtr, void *highPtr,
+                                   size_t totalSize) {
+    (void)provider;  //unused
+    (void)lowPtr;    //unused
+    (void)highPtr;   //unused
+    (void)totalSize; //unused
+    return UMF_RESULT_ERROR_USER_SPECIFIC;
+}
+
+static void coarse_params_set_default(coarse_params_t *coarse_params,
+                                      umf_memory_provider_handle_t provider,
+                                      coarse_strategy_t allocation_strategy) {
+    memset(coarse_params, 0, sizeof(*coarse_params));
+    coarse_params->provider = provider;
+    coarse_params->allocation_strategy = allocation_strategy;
+    coarse_params->cb.split = split_cb;
+    coarse_params->cb.merge = merge_cb;
+    coarse_params->page_size = utils_get_page_size();
+
+    if (provider) {
+        coarse_params->cb.alloc = alloc_cb;
+        coarse_params->cb.free = free_cb;
+    }
+}
+
+umf_memory_provider_ops_t UMF_MALLOC_MEMORY_PROVIDER_OPS =
+    umf_test::providerMakeCOps<umf_test::provider_ba_global, void>();
+
+struct CoarseWithMemoryStrategyTest
+    : umf_test::test,
+      ::testing::WithParamInterface<coarse_strategy_t> {
+    void SetUp() override {
+        test::SetUp();
+        allocation_strategy = this->GetParam();
+        coarse_params_set_default(&coarse_params, MOCKED_PROVIDER,
+                                  allocation_strategy);
+    }
+
+    coarse_t *coarse_handle = nullptr;
+    coarse_params_t coarse_params;
+    coarse_strategy_t allocation_strategy;
+    umf_result_t umf_result;
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    CoarseWithMemoryStrategyTest, CoarseWithMemoryStrategyTest,
+    ::testing::Values(UMF_COARSE_MEMORY_STRATEGY_FASTEST,
+                      UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE,
+                      UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE));
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_provider) {
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    const size_t alloc_size = 20 * MB;
+    void *ptr;
+
+    umf_result = coarse_add_memory_from_provider(ch, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    umf_result = coarse_free(ch, ptr, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // test double free
+    umf_result = coarse_free(ch, ptr, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    coarse_delete(ch);
+    umf_result = umfMemoryProviderDestroy(malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_fixed_memory) {
+    // preallocate some memory and initialize the vector with zeros
+    const size_t buff_size = 20 * MB + coarse_params.page_size;
+    std::vector<char> buffer(buff_size, 0);
+    void *buf = (void *)ALIGN_UP_SAFE((uintptr_t)buffer.data(),
+                                      coarse_params.page_size);
+    ASSERT_NE(buf, nullptr);
+
+    coarse_params.cb.alloc = NULL;
+    coarse_params.cb.free = NULL;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    char *ptr = nullptr;
+
+    umf_result = coarse_add_memory_fixed(ch, buf, buff_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    umf_result = coarse_free(ch, ptr, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // test double free
+    umf_result = coarse_free(ch, ptr, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    coarse_delete(ch);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_fixed_memory_various) {
+    // preallocate some memory and initialize the vector with zeros
+    const size_t buff_size = 20 * MB + coarse_params.page_size;
+    std::vector<char> buffer(buff_size, 0);
+    void *buf = (void *)ALIGN_UP_SAFE((uintptr_t)buffer.data(),
+                                      coarse_params.page_size);
+    ASSERT_NE(buf, nullptr);
+
+    coarse_params.cb.alloc = NULL;
+    coarse_params.cb.free = NULL;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    char *ptr = nullptr;
+
+    umf_result = coarse_add_memory_fixed(ch, buf, buff_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // free NULL
+    umf_result = coarse_free(ch, nullptr, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // free invalid pointer
+    umf_result = coarse_free(ch, INVALID_PTR, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // wrong alignment (3 bytes)
+    ptr = nullptr;
+    umf_result = coarse_alloc(ch, 2 * MB, 3, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ALIGNMENT);
+    ASSERT_EQ(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // not freed allocation
+    // coarse_delete() prints LOG_WARN() in Debug mode
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    coarse_delete(ch);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_merge) {
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    char *ptr = nullptr;
+    const size_t alloc_size = 20 * MB;
+
+    umf_result = coarse_add_memory_from_provider(ch, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    /* test coarse_split */
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    umf_result = coarse_split(ch, ptr, 2 * MB, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    umf_result = coarse_free(ch, (ptr + 1 * MB), 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 1 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    umf_result = coarse_free(ch, ptr, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    /* test coarse_merge */
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    umf_result = coarse_split(ch, ptr, 2 * MB, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    umf_result = coarse_merge(ch, ptr, (ptr + 1 * MB), 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    umf_result = coarse_free(ch, ptr, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    coarse_delete(coarse_handle);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+// negative tests
+
+// NULL parameters
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_no_params) {
+    umf_result = coarse_new(nullptr, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_handle, nullptr);
+}
+
+// no provider
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_no_provider) {
+    coarse_params.provider = NULL;
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_handle, nullptr);
+}
+
+// no page size
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_no_page_size) {
+    coarse_params.page_size = 0;
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_handle, nullptr);
+}
+
+// no split callback
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_no_split_cb) {
+    coarse_params.cb.split = NULL;
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_handle, nullptr);
+}
+
+// no merge callback
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_no_merge_cb) {
+    coarse_params.cb.merge = NULL;
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_handle, nullptr);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_alloc_invalid) {
+    void *ptr = nullptr;
+
+    umf_result = coarse_alloc(nullptr, MB, 0, nullptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(ptr, nullptr);
+
+    umf_result = coarse_alloc(nullptr, MB, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(ptr, nullptr);
+
+    umf_result = coarse_alloc(MOCKED_COARSE, MB, 0, nullptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(ptr, nullptr);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_free_invalid) {
+    // coarse handle is NULL
+    umf_result = coarse_free(nullptr, nullptr, MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_delete_null) {
+    coarse_delete(nullptr);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest,
+       coarseTest_add_memory_from_provider_null_0) {
+    umf_result = coarse_add_memory_from_provider(nullptr, 0);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_add_memory_fixed_null_0) {
+    umf_result = coarse_add_memory_fixed(nullptr, nullptr, 0);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_null_stats) {
+    ASSERT_EQ(coarse_get_stats(nullptr).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(nullptr).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(nullptr).num_all_blocks, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(nullptr).num_free_blocks, (size_t)0);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_merge_negative) {
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    char *ptr = nullptr;
+    const size_t alloc_size = 20 * MB;
+
+    umf_result = coarse_add_memory_from_provider(ch, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    /* test coarse_split */
+
+    umf_result = coarse_alloc(ch, 6 * MB, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 6 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    // firstSize >= totalSize
+    umf_result = coarse_split(ch, ptr, 6 * MB, 6 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // firstSize == 0
+    umf_result = coarse_split(ch, ptr, 6 * MB, 0);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // totalSize == 0
+    umf_result = coarse_split(ch, ptr, 0, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // wrong totalSize
+    umf_result = coarse_split(ch, ptr, 5 * MB, 1 * KB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // memory block not found
+    umf_result = coarse_split(ch, ptr + 1, 6 * MB, 1 * KB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result = coarse_free(ch, ptr, 6 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // split freed block
+    umf_result = coarse_split(ch, ptr, alloc_size, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    /* test coarse_merge */
+
+    umf_result = coarse_alloc(ch, 6 * MB, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 6 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    // split (6 * MB) block into (1 * MB) + (5 * MB)
+    umf_result = coarse_split(ch, ptr, 6 * MB, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 6 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    // split (5 * MB) block into (2 * MB) + (3 * MB)
+    umf_result = coarse_split(ch, (ptr + 1 * MB), 5 * MB, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 6 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)4);
+
+    // now we have 3 used blocks: (1 * MB) + (2 * MB) + (3 * MB)
+
+    // highPtr <= lowPtr
+    umf_result = coarse_merge(ch, (ptr + 1 * MB), ptr, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // highPtr - lowPtr >= totalSize
+    umf_result = coarse_merge(ch, ptr, (ptr + 1 * MB), 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // low ptr does not exist
+    umf_result = coarse_merge(ch, ptr + 1, (ptr + 1 * MB), 3 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // high ptr does not exist
+    umf_result = coarse_merge(ch, ptr, (ptr + 1 * MB + 1), 3 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // low_block->size + high_block->size != totalSize
+    umf_result = coarse_merge(ch, ptr, (ptr + 1 * MB), 5 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // not adjacent blocks
+    umf_result = coarse_merge(ch, ptr, (ptr + 3 * MB), 4 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // free the 2 MB block in the middle
+    umf_result = coarse_free(ch, (ptr + 1 * MB), 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 4 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)4);
+
+    // now we have 3 blocks: (1 * MB) used + (2 * MB) freed + (3 * MB) used
+
+    // the low ptr block is not allocated
+    umf_result = coarse_merge(ch, (ptr + 1 * MB), (ptr + 3 * MB), 5 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    // the high ptr block is not allocated
+    umf_result = coarse_merge(ch, ptr, (ptr + 1 * MB), 3 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result = coarse_free(ch, ptr, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 3 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    umf_result = coarse_free(ch, (ptr + 3 * MB), 3 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    coarse_delete(coarse_handle);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_alloc_cb_fails) {
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+    coarse_params.cb.alloc = alloc_cb_fails;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    const size_t alloc_size = 20 * MB;
+
+    umf_result = coarse_add_memory_from_provider(ch, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    coarse_delete(ch);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_free_cb_fails) {
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+    coarse_params.cb.free = free_cb_fails;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    const size_t alloc_size = 20 * MB;
+
+    umf_result = coarse_add_memory_from_provider(ch, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    coarse_delete(ch);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_split_cb_fails) {
+    if (coarse_params.allocation_strategy ==
+        UMF_COARSE_MEMORY_STRATEGY_FASTEST) {
+        // This test is designed for the UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE
+        // and UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE strategies,
+        // because the UMF_COARSE_MEMORY_STRATEGY_FASTEST strategy
+        // looks always for a block of size greater by the page size.
+        return;
+    }
+
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+    coarse_params.cb.split = split_cb_fails;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    void *ptr = nullptr;
+    const size_t alloc_size = 20 * MB;
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    umf_result = coarse_add_memory_from_provider(ch, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // coarse_alloc(alloc_size / 2, alignment = 0)
+    umf_result = coarse_alloc(ch, alloc_size / 2, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_USER_SPECIFIC);
+    ASSERT_EQ(ptr, nullptr);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // coarse_alloc(alloc_size / 2, alignment = 2 * MB)
+    umf_result = coarse_alloc(ch, alloc_size / 2, 2 * MB, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_USER_SPECIFIC);
+    ASSERT_EQ(ptr, nullptr);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // coarse_alloc(alloc_size, alignment = 0) - OK
+    umf_result = coarse_alloc(ch, alloc_size, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    umf_result = coarse_split(ch, ptr, alloc_size, alloc_size / 2);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_USER_SPECIFIC);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    umf_result = coarse_free(ch, ptr, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    coarse_delete(coarse_handle);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_merge_cb_fails) {
+    // preallocate some memory and initialize the vector with zeros
+    const size_t buff_size = 10 * MB + coarse_params.page_size;
+    std::vector<char> buffer(buff_size, 0);
+    void *buf = (void *)ALIGN_UP_SAFE((uintptr_t)buffer.data(),
+                                      coarse_params.page_size);
+    ASSERT_NE(buf, nullptr);
+
+    coarse_params.cb.alloc = NULL;
+    coarse_params.cb.free = NULL;
+    coarse_params.cb.merge = merge_cb_fails;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    char *ptr = nullptr;
+
+    umf_result = coarse_add_memory_fixed(ch, buf, buff_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    /* test coarse_merge */
+    umf_result = coarse_alloc(ch, 3 * MB, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 3 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    umf_result = coarse_split(ch, ptr, 3 * MB, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 3 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    umf_result = coarse_merge(ch, ptr, (ptr + 1 * MB), 3 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_USER_SPECIFIC);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 3 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    umf_result = coarse_free(ch, ptr, 3 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 3 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    umf_result = coarse_free(ch, ptr, 1 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    umf_result = coarse_free(ch, (ptr + 1 * MB), 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buff_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    coarse_delete(coarse_handle);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_fixed_memory_alloc_set) {
+    // preallocate some memory and initialize the vector with zeros
+    const size_t buff_size = 20 * MB;
+    std::vector<char> buffer(buff_size, 0);
+    void *buf = (void *)buffer.data();
+    ASSERT_NE(buf, nullptr);
+
+    coarse_params.cb.free = NULL;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    umf_result = coarse_add_memory_fixed(ch, buf, buff_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    coarse_delete(ch);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_fixed_memory_free_set) {
+    // preallocate some memory and initialize the vector with zeros
+    const size_t buff_size = 20 * MB;
+    std::vector<char> buffer(buff_size, 0);
+    void *buf = (void *)buffer.data();
+    ASSERT_NE(buf, nullptr);
+
+    coarse_params.cb.alloc = NULL;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    umf_result = coarse_add_memory_fixed(ch, buf, buff_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    coarse_delete(ch);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_fixed_memory_alloc_free_set) {
+    // preallocate some memory and initialize the vector with zeros
+    const size_t buff_size = 20 * MB;
+    std::vector<char> buffer(buff_size, 0);
+    void *buf = (void *)buffer.data();
+    ASSERT_NE(buf, nullptr);
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    umf_result = coarse_add_memory_fixed(ch, buf, buff_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    coarse_delete(ch);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_provider_alloc_not_set) {
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+    coarse_params.cb.alloc = NULL;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    const size_t alloc_size = 20 * MB;
+    void *ptr;
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    umf_result = coarse_add_memory_from_provider(ch, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    umf_result = coarse_alloc(ch, 2 * MB, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY);
+    ASSERT_EQ(ptr, nullptr);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    umf_result = coarse_alloc(ch, 2 * MB, 2 * MB, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY);
+    ASSERT_EQ(ptr, nullptr);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)0);
+
+    coarse_delete(ch);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic) {
+    if (coarse_params.allocation_strategy ==
+        UMF_COARSE_MEMORY_STRATEGY_FASTEST) {
+        // This test is designed for the UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE
+        // and UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE strategies,
+        // because the UMF_COARSE_MEMORY_STRATEGY_FASTEST strategy
+        // looks always for a block of size greater by the page size.
+        return;
+    }
+
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    const size_t init_buffer_size = 20 * MB;
+    void *p1, *p2;
+
+    umf_result = coarse_add_memory_from_provider(ch, init_buffer_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // alloc 2x 2MB
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&p1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(p1, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&p2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(p2, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 4 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+    ASSERT_NE(p1, p2);
+
+    // swap pointers to get p1 < p2
+    if (p1 > p2) {
+        std::swap(p1, p2);
+    }
+
+    // free + alloc first block
+    // the block should be reused
+    // currently there is no purging, so the alloc size shouldn't change
+    // there should be no block merging between used and not-used blocks
+    umf_result = coarse_free(ch, p1, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&p1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(p1, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 4 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+
+    // free all allocs
+    // overall alloc size shouldn't change
+    // block p2 should merge with the prev free block p1
+    // and the remaining init block
+    umf_result = coarse_free(ch, p1, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+    umf_result = coarse_free(ch, p2, 2 * MB);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // test allocations with alignment
+    // TODO: what about holes?
+    umf_result = coarse_alloc(ch, 1 * MB - 4, 128, (void **)&p1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(p1, nullptr);
+    ASSERT_EQ((uintptr_t)p1 & 127, 0ULL);
+
+    umf_result = coarse_alloc(ch, 1 * MB - 4, 128, (void **)&p2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(p2, nullptr);
+    ASSERT_EQ((uintptr_t)p2 & 127, 0ULL);
+
+    umf_result = coarse_free(ch, p1, 1 * MB - 4);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = coarse_free(ch, p2, 1 * MB - 4);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // alloc whole buffer
+    // after this, there should be one single block
+    umf_result = coarse_alloc(ch, init_buffer_size, 0, (void **)&p1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(p1, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // free all memory
+    umf_result = coarse_free(ch, p1, init_buffer_size);
+
+    // alloc 2 MB block - the init block should be split
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&p1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(p1, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)2);
+
+    // alloc additional 2 MB
+    // the non-used block should be used
+    umf_result = coarse_alloc(ch, 2 * MB, 0, (void **)&p2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(p2, nullptr);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 4 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)3);
+    ASSERT_NE(p1, p2);
+
+    // make sure that p1 < p2
+    if (p1 > p2) {
+        std::swap(p1, p2);
+    }
+
+    // free blocks in order: p2, p1
+    // block p1 should merge with the next block p2
+    // swap pointers to get p1 < p2
+    coarse_free(ch, p2, 2 * MB);
+    coarse_free(ch, p1, 2 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // alloc 10x 2 MB - this should occupy all allocated memory
+    constexpr size_t allocs_size = 10;
+    void *allocs[allocs_size] = {0};
+    for (size_t i = 0; i < allocs_size; i++) {
+        ASSERT_EQ(coarse_get_stats(ch).used_size, i * 2 * MB);
+        umf_result = coarse_alloc(ch, 2 * MB, 0, &allocs[i]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ASSERT_NE(allocs[i], nullptr);
+    }
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 20 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    // there should be no block with the free memory
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, allocs_size);
+
+    // free all memory
+    for (size_t i = 0; i < allocs_size; i++) {
+        umf_result = coarse_free(ch, allocs[i], 2 * MB);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+
+    coarse_delete(ch);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_simple1) {
+    if (coarse_params.allocation_strategy ==
+        UMF_COARSE_MEMORY_STRATEGY_FASTEST) {
+        // This test is designed for the UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE
+        // and UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE strategies,
+        // because the UMF_COARSE_MEMORY_STRATEGY_FASTEST strategy
+        // looks always for a block of size greater by the page size.
+        return;
+    }
+
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    const size_t init_buffer_size = 20 * MB;
+
+    umf_result = coarse_add_memory_from_provider(ch, init_buffer_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // test 1
+
+    size_t s1 = 74659 * KB;
+    size_t s2 = 8206 * KB;
+
+    size_t max_alloc_size = 0;
+
+    const int nreps = 2;
+    const int nptrs = 6;
+
+    // s1
+    for (int j = 0; j < nreps; j++) {
+        void *t[nptrs] = {0};
+        for (int i = 0; i < nptrs; i++) {
+            umf_result = coarse_alloc(ch, s1, 0, &t[i]);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+            ASSERT_NE(t[i], nullptr);
+        }
+
+        size_t alloc_size = coarse_get_stats(ch).alloc_size;
+        if (alloc_size > max_alloc_size) {
+            max_alloc_size = alloc_size;
+        }
+
+        for (int i = 0; i < nptrs; i++) {
+            umf_result = coarse_free(ch, t[i], s1);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+    }
+
+    // s2
+    for (int j = 0; j < nreps; j++) {
+        void *t[nptrs] = {0};
+        for (int i = 0; i < nptrs; i++) {
+            umf_result = coarse_alloc(ch, s2, 0, &t[i]);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+            ASSERT_NE(t[i], nullptr);
+        }
+
+        // all s2 should fit into single block leaved after freeing s1
+        ASSERT_LE(coarse_get_stats(ch).alloc_size, max_alloc_size);
+
+        for (int i = 0; i < nptrs; i++) {
+            umf_result = coarse_free(ch, t[i], s2);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+    }
+
+    coarse_delete(ch);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_simple2) {
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    const size_t init_buffer_size = 20 * MB;
+
+    umf_result = coarse_add_memory_from_provider(ch, init_buffer_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, init_buffer_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    // test
+    double sizes[] = {2, 4, 0.5, 1, 8, 0.25};
+    size_t alignment[] = {0, 4, 0, 16, 32, 128};
+    for (int i = 0; i < 6; i++) {
+        size_t s = (size_t)(sizes[i] * MB);
+        void *t[8] = {0};
+        for (int j = 0; j < 8; j++) {
+            umf_result = coarse_alloc(ch, s, alignment[i], &t[j]);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+            ASSERT_NE(t[j], nullptr);
+        }
+
+        for (int j = 0; j < 8; j++) {
+            umf_result = coarse_free(ch, t[j], s);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+    }
+
+    coarse_delete(ch);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_alignment_provider) {
+    umf_memory_provider_handle_t malloc_memory_provider;
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS, NULL,
+                                         &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    coarse_params.provider = malloc_memory_provider;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    const size_t alloc_size = 40 * MB;
+
+    umf_result = coarse_add_memory_from_provider(ch, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    const int niter = 10;
+    const size_t size = 1 * MB;
+    void *ptr[niter] = {0};
+
+    for (int i = 0; i < niter; i++) {
+        umf_result = coarse_alloc(ch, size, 0, &ptr[i]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ptr[i], nullptr);
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, niter * size);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)(niter + 1));
+
+    for (int i = 0; i < niter; i += 2) {
+        umf_result = coarse_free(ch, ptr[i], size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ptr[i] = nullptr;
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, niter * size / 2);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)(niter + 1));
+
+    for (int i = 0; i < niter; i += 2) {
+        ASSERT_EQ(ptr[i], nullptr);
+        umf_result = coarse_alloc(ch, size, 2 * MB, &ptr[i]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ptr[i], nullptr);
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, niter * size);
+
+    for (int i = 0; i < niter; i++) {
+        umf_result = coarse_free(ch, ptr[i], size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    coarse_delete(ch);
+    umfMemoryProviderDestroy(malloc_memory_provider);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest, coarseTest_alignment_fixed_memory) {
+    // preallocate some memory and initialize the vector with zeros
+    const size_t alloc_size = 40 * MB + coarse_params.page_size;
+    std::vector<char> buffer(alloc_size, 0);
+    void *buf = (void *)ALIGN_UP_SAFE((uintptr_t)buffer.data(),
+                                      coarse_params.page_size);
+    ASSERT_NE(buf, nullptr);
+
+    coarse_params.cb.alloc = NULL;
+    coarse_params.cb.free = NULL;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+
+    umf_result = coarse_add_memory_fixed(ch, buf, alloc_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    const int niter = 10;
+    const size_t size = 1 * MB;
+    void *ptr[niter] = {0};
+
+    for (int i = 0; i < niter; i++) {
+        umf_result = coarse_alloc(ch, size, 0, &ptr[i]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ptr[i], nullptr);
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, niter * size);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)(niter + 1));
+
+    for (int i = 0; i < niter; i += 2) {
+        umf_result = coarse_free(ch, ptr[i], size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ptr[i] = nullptr;
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, niter * size / 2);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, alloc_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)(niter + 1));
+
+    for (int i = 0; i < niter; i += 2) {
+        ASSERT_EQ(ptr[i], nullptr);
+        umf_result = coarse_alloc(ch, size, 2 * MB, &ptr[i]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ptr[i], nullptr);
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, niter * size);
+
+    for (int i = 0; i < niter; i++) {
+        umf_result = coarse_free(ch, ptr[i], size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, (size_t)0);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    coarse_delete(ch);
+}
+
+TEST_P(CoarseWithMemoryStrategyTest,
+       coarseTest_basic_non_aligned_fixed_memory) {
+    // preallocate some memory and initialize the vector with zeros
+    const size_t buff_size = 20 * MB + coarse_params.page_size;
+    std::vector<char> buffer(buff_size, 0);
+
+    void *buf_aligned = (void *)ALIGN_UP_SAFE((uintptr_t)buffer.data(),
+                                              coarse_params.page_size);
+    ASSERT_NE(buf_aligned, nullptr);
+
+    void *buf_non_aligned = (void *)((uintptr_t)buf_aligned + 64);
+    size_t buf_non_aligned_size =
+        buff_size - ((uintptr_t)buf_non_aligned - (uintptr_t)buffer.data());
+    buf_non_aligned_size =
+        ALIGN_DOWN(buf_non_aligned_size, coarse_params.page_size);
+
+    coarse_params.cb.alloc = NULL;
+    coarse_params.cb.free = NULL;
+
+    umf_result = coarse_new(&coarse_params, &coarse_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(coarse_handle, nullptr);
+
+    coarse_t *ch = coarse_handle;
+    char *ptr = nullptr;
+
+    umf_result =
+        coarse_add_memory_fixed(ch, buf_non_aligned, buf_non_aligned_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buf_non_aligned_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    umf_result = coarse_alloc(ch, buf_non_aligned_size, 0, (void **)&ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY);
+    ASSERT_EQ(ptr, nullptr);
+
+    ASSERT_EQ(coarse_get_stats(ch).used_size, 0 * MB);
+    ASSERT_EQ(coarse_get_stats(ch).alloc_size, buf_non_aligned_size);
+    ASSERT_EQ(coarse_get_stats(ch).num_all_blocks, (size_t)1);
+
+    coarse_delete(ch);
+}
diff --git a/test/common/CMakeLists.txt b/test/common/CMakeLists.txt
index 4f88fd7d8..6cffe5cfe 100644
--- a/test/common/CMakeLists.txt
+++ b/test/common/CMakeLists.txt
@@ -9,6 +9,10 @@ set(COMMON_SOURCES
     provider_null.c
     provider_trace.c)
 
+if(LINUX)
+    set(COMMON_SOURCES ${COMMON_SOURCES} test_helpers_linux.c)
+endif(LINUX)
+
 add_umf_library(
     NAME umf_test_common
     TYPE STATIC
diff --git a/test/common/base.hpp b/test/common/base.hpp
index 8f2d5f6be..804eff48c 100644
--- a/test/common/base.hpp
+++ b/test/common/base.hpp
@@ -14,6 +14,8 @@
 
 namespace umf_test {
 
+#define IS_SKIPPED_OR_FAILED() (HasFatalFailure() || IsSkipped())
+
 #define NOEXCEPT_COND(cond, val, expected_val)                                                                   \
     try {                                                                                                        \
         cond(val, expected_val);                                                                                 \
@@ -48,6 +50,9 @@ std::function<Ret(void)> withGeneratedArgs(Ret (*f)(Args...)) {
     };
 }
 
+const size_t KB = 1024;
+const size_t MB = 1024 * KB;
+
 } // namespace umf_test
 
 #endif /* UMF_TEST_BASE_HPP */
diff --git a/test/common/ipc_common.c b/test/common/ipc_common.c
index 7e08e79f0..5e9b911be 100644
--- a/test/common/ipc_common.c
+++ b/test/common/ipc_common.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,14 +9,14 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/prctl.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
 #include "ipc_common.h"
 
 #define INET_ADDR "127.0.0.1"
-#define MSG_SIZE 1024
-#define RECV_BUFF_SIZE 1024
+#define MSG_SIZE 1024 * 8
 
 // consumer's response message
 #define CONSUMER_MSG                                                           \
@@ -34,6 +34,10 @@ Generally communication between the producer and the consumer looks like:
 - Producer creates a socket
 - Producer connects to the consumer
 - Consumer connects at IP 127.0.0.1 and a port to the producer
+- Producer sends the IPC handle size to the consumer
+- Consumer receives the IPC handle size from the producer
+- Consumer sends the confirmation (IPC handle size) to the producer
+- Producer receives the confirmation (IPC handle size) from the consumer
 - Producer sends the IPC handle to the consumer
 - Consumer receives the IPC handle from the producer
 - Consumer opens the IPC handle received from the producer
@@ -107,11 +111,12 @@ int consumer_connect(int port) {
     return ret;
 }
 
-int run_consumer(int port, umf_memory_provider_ops_t *provider_ops,
+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];
-    char recv_buffer[RECV_BUFF_SIZE];
     int producer_socket = -1;
     int ret = -1;
     umf_memory_provider_handle_t provider = NULL;
@@ -124,33 +129,62 @@ int run_consumer(int port, umf_memory_provider_ops_t *provider_ops,
     umf_result =
         umfMemoryProviderCreate(provider_ops, provider_params, &provider);
     if (umf_result != UMF_RESULT_SUCCESS) {
-        fprintf(stderr,
-                "[consumer] ERROR: creating OS memory provider failed\n");
+        fprintf(stderr, "[consumer] ERROR: creating memory provider failed\n");
         return -1;
     }
 
-    // get the size of the IPC handle
-    size_t IPC_handle_size;
-    umf_result = umfMemoryProviderGetIPCHandleSize(provider, &IPC_handle_size);
+    umf_memory_pool_handle_t pool;
+    umf_result = umfPoolCreate(pool_ops, provider, pool_params, 0, &pool);
     if (umf_result != UMF_RESULT_SUCCESS) {
-        fprintf(stderr,
-                "[consumer] ERROR: getting size of the IPC handle failed\n");
+        fprintf(stderr, "[consumer] ERROR: creating memory pool failed\n");
         goto err_umfMemoryProviderDestroy;
     }
 
+    umf_ipc_handler_handle_t ipc_handler;
+    umf_result = umfPoolGetIPCHandler(pool, &ipc_handler);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "[consumer] ERROR: get IPC handler failed\n");
+        goto err_umfMemoryPoolDestroy;
+    }
+
     producer_socket = consumer_connect(port);
     if (producer_socket < 0) {
-        goto err_umfMemoryProviderDestroy;
+        goto err_umfMemoryPoolDestroy;
     }
 
-    // zero the receive buffer
-    memset(recv_buffer, 0, RECV_BUFF_SIZE);
+    // allocate the zeroed receive buffer
+    char *recv_buffer = calloc(1, MSG_SIZE);
+    if (!recv_buffer) {
+        fprintf(stderr, "[consumer] ERROR: out of memory\n");
+        goto err_close_producer_socket;
+    }
 
-    // receive a producer's message
-    ssize_t recv_len = recv(producer_socket, recv_buffer, RECV_BUFF_SIZE, 0);
+    // get the size of the IPC handle from the producer
+    size_t IPC_handle_size;
+    ssize_t recv_len = recv(producer_socket, recv_buffer, MSG_SIZE, 0);
     if (recv_len < 0) {
         fprintf(stderr, "[consumer] ERROR: recv() failed\n");
-        goto err_close_producer_socket;
+        goto err_free_recv_buffer;
+    }
+    IPC_handle_size = *(size_t *)recv_buffer;
+    fprintf(stderr, "[consumer] Got the size of the IPC handle: %zu\n",
+            IPC_handle_size);
+
+    // send confirmation to the producer (IPC handle size)
+    recv_len =
+        send(producer_socket, &IPC_handle_size, sizeof(IPC_handle_size), 0);
+    if (recv_len < 0) {
+        fprintf(stderr, "[consumer] ERROR: sending confirmation failed\n");
+        goto err_free_recv_buffer;
+    }
+    fprintf(stderr,
+            "[consumer] Send the confirmation (IPC handle size) to producer\n");
+
+    // receive IPC handle from the producer
+    recv_len = recv(producer_socket, recv_buffer, MSG_SIZE, 0);
+    if (recv_len < 0) {
+        fprintf(stderr, "[consumer] ERROR: recv() failed\n");
+        goto err_free_recv_buffer;
     }
 
     size_t len = (size_t)recv_len;
@@ -159,7 +193,7 @@ int run_consumer(int port, umf_memory_provider_ops_t *provider_ops,
                 "[consumer] ERROR: recv() received a wrong number of bytes "
                 "(%zi != %zu expected)\n",
                 len, IPC_handle_size);
-        goto err_close_producer_socket;
+        goto err_free_recv_buffer;
     }
 
     void *IPC_handle = recv_buffer;
@@ -170,7 +204,7 @@ int run_consumer(int port, umf_memory_provider_ops_t *provider_ops,
         len);
 
     void *SHM_ptr;
-    umf_result = umfMemoryProviderOpenIPCHandle(provider, IPC_handle, &SHM_ptr);
+    umf_result = umfOpenIPCHandle(ipc_handler, IPC_handle, &SHM_ptr);
     if (umf_result == UMF_RESULT_ERROR_NOT_SUPPORTED) {
         fprintf(stderr,
                 "[consumer] SKIP: opening the IPC handle is not supported\n");
@@ -183,11 +217,11 @@ int run_consumer(int port, umf_memory_provider_ops_t *provider_ops,
         send(producer_socket, consumer_message, strlen(consumer_message) + 1,
              0);
 
-        goto err_close_producer_socket;
+        goto err_free_recv_buffer;
     }
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "[consumer] ERROR: opening the IPC handle failed\n");
-        goto err_close_producer_socket;
+        goto err_free_recv_buffer;
     }
 
     fprintf(stderr,
@@ -227,8 +261,7 @@ int run_consumer(int port, umf_memory_provider_ops_t *provider_ops,
 
 err_closeIPCHandle:
     // we do not know the exact size of the remote shared memory
-    umf_result = umfMemoryProviderCloseIPCHandle(provider, SHM_ptr,
-                                                 sizeof(unsigned long long));
+    umf_result = umfCloseIPCHandle(SHM_ptr);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "[consumer] ERROR: closing the IPC handle failed\n");
     }
@@ -236,9 +269,15 @@ int run_consumer(int port, umf_memory_provider_ops_t *provider_ops,
     fprintf(stderr,
             "[consumer] Closed the IPC handle received from the producer\n");
 
+err_free_recv_buffer:
+    free(recv_buffer);
+
 err_close_producer_socket:
     close(producer_socket);
 
+err_umfMemoryPoolDestroy:
+    umfPoolDestroy(pool);
+
 err_umfMemoryProviderDestroy:
     umfMemoryProviderDestroy(provider);
 
@@ -290,7 +329,9 @@ int producer_connect(int port) {
     return -1;
 }
 
-int run_producer(int port, umf_memory_provider_ops_t *provider_ops,
+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;
@@ -299,21 +340,33 @@ int run_producer(int port, umf_memory_provider_ops_t *provider_ops,
     int producer_socket = -1;
     char consumer_message[MSG_SIZE];
 
+    ret = prctl(PR_SET_PTRACER, getppid());
+    if (ret == -1) {
+        perror("PR_SET_PTRACER may be not supported. prctl() call failed");
+        goto err_end;
+    }
+
     // create OS memory provider
     umf_result =
         umfMemoryProviderCreate(provider_ops, provider_params, &provider);
     if (umf_result != UMF_RESULT_SUCCESS) {
-        fprintf(stderr,
-                "[producer] ERROR: creating OS memory provider failed\n");
+        fprintf(stderr, "[producer] ERROR: creating memory provider failed\n");
         return -1;
     }
 
+    umf_memory_pool_handle_t pool;
+    umf_result = umfPoolCreate(pool_ops, provider, pool_params, 0, &pool);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "[producer] ERROR: creating memory pool failed\n");
+        goto err_umfMemoryProviderDestroy;
+    }
+
     size_t page_size;
     umf_result = umfMemoryProviderGetMinPageSize(provider, NULL, &page_size);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr,
                 "[producer] ERROR: getting the minimum page size failed\n");
-        goto err_umfMemoryProviderDestroy;
+        goto err_umfMemoryPoolDestroy;
     }
 
     // Make 3 allocations of size: 1 page, 2 pages and 3 pages
@@ -322,45 +375,36 @@ int run_producer(int port, umf_memory_provider_ops_t *provider_ops,
     size_t ptr2_size = 2 * page_size;
     size_t size_IPC_shared_memory = 3 * page_size;
 
-    umf_result = umfMemoryProviderAlloc(provider, ptr1_size, 0, &ptr1);
-    if (umf_result != UMF_RESULT_SUCCESS) {
+    ptr1 = umfPoolMalloc(pool, ptr1_size);
+    if (ptr1 == NULL) {
         fprintf(stderr, "[producer] ERROR: allocating 1 page failed\n");
-        goto err_umfMemoryProviderDestroy;
+        goto err_umfMemoryPoolDestroy;
     }
 
-    umf_result = umfMemoryProviderAlloc(provider, ptr2_size, 0, &ptr2);
-    if (umf_result != UMF_RESULT_SUCCESS) {
+    ptr2 = umfPoolMalloc(pool, ptr2_size);
+    if (ptr2 == NULL) {
         fprintf(stderr, "[producer] ERROR: allocating 2 pages failed\n");
         goto err_free_ptr1;
     }
 
-    umf_result = umfMemoryProviderAlloc(provider, size_IPC_shared_memory, 0,
-                                        &IPC_shared_memory);
-    if (umf_result != UMF_RESULT_SUCCESS) {
+    IPC_shared_memory = umfPoolMalloc(pool, size_IPC_shared_memory);
+    if (IPC_shared_memory == NULL) {
         fprintf(stderr, "[producer] ERROR: allocating 3 pages failed\n");
         goto err_free_ptr2;
     }
 
     // get size of the IPC handle
     size_t IPC_handle_size;
-    umf_result = umfMemoryProviderGetIPCHandleSize(provider, &IPC_handle_size);
-    if (umf_result != UMF_RESULT_SUCCESS) {
-        fprintf(stderr,
-                "[producer] ERROR: getting size of the IPC handle failed\n");
-        goto err_free_IPC_shared_memory;
-    }
+    umf_ipc_handle_t IPC_handle = NULL;
 
-    // allocate data for IPC provider
-    void *IPC_handle = malloc(IPC_handle_size);
-    if (IPC_handle == NULL) {
-        fprintf(stderr,
-                "[producer] ERROR: allocating memory for IPC handle failed\n");
+    // get the IPC handle
+    umf_result =
+        umfGetIPCHandle(IPC_shared_memory, &IPC_handle, &IPC_handle_size);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "[producer] ERROR: getting the IPC handle failed\n");
         goto err_free_IPC_shared_memory;
     }
 
-    // zero the IPC handle and the shared memory
-    memset(IPC_handle, 0, IPC_handle_size);
-
     // save a random number (&provider) in the shared memory
     unsigned long long SHM_number_1 = (unsigned long long)&provider;
     memcopy_callback(IPC_shared_memory, &SHM_number_1, sizeof(SHM_number_1),
@@ -369,16 +413,6 @@ int run_producer(int port, umf_memory_provider_ops_t *provider_ops,
     fprintf(stderr, "[producer] My shared memory contains a number: %llu\n",
             SHM_number_1);
 
-    // get the IPC handle from the OS memory provider
-    umf_result = umfMemoryProviderGetIPCHandle(
-        provider, IPC_shared_memory, size_IPC_shared_memory, IPC_handle);
-    if (umf_result != UMF_RESULT_SUCCESS) {
-        fprintf(stderr,
-                "[producer] ERROR: getting the IPC handle from the OS memory "
-                "provider failed\n");
-        goto err_free_IPC_handle;
-    }
-
     fprintf(stderr, "[producer] Got the IPC handle\n");
 
     producer_socket = producer_connect(port);
@@ -386,6 +420,44 @@ int run_producer(int port, umf_memory_provider_ops_t *provider_ops,
         goto err_PutIPCHandle;
     }
 
+    // send the IPC_handle_size to the consumer
+    ssize_t len =
+        send(producer_socket, &IPC_handle_size, sizeof(IPC_handle_size), 0);
+    if (len < 0) {
+        fprintf(stderr, "[producer] ERROR: unable to send the message\n");
+        goto err_close_producer_socket;
+    }
+
+    fprintf(stderr,
+            "[producer] Sent the size of the IPC handle (%zu) to the consumer "
+            "(sent %zu bytes)\n",
+            IPC_handle_size, len);
+
+    // zero the consumer_message buffer
+    memset(consumer_message, 0, sizeof(consumer_message));
+
+    // receive the consumer's confirmation - IPC handle size
+    len = recv(producer_socket, consumer_message, sizeof(consumer_message), 0);
+    if (len < 0) {
+        fprintf(stderr, "[producer] ERROR: error while receiving the "
+                        "confirmation from the consumer\n");
+        goto err_close_producer_socket;
+    }
+
+    size_t conf_IPC_handle_size = *(size_t *)consumer_message;
+    if (conf_IPC_handle_size == IPC_handle_size) {
+        fprintf(stderr,
+                "[producer] Received the correct confirmation (%zu) from the "
+                "consumer (%zu bytes)\n",
+                conf_IPC_handle_size, len);
+    } else {
+        fprintf(stderr,
+                "[producer] Received an INCORRECT confirmation (%zu) from the "
+                "consumer (%zu bytes)\n",
+                conf_IPC_handle_size, len);
+        goto err_close_producer_socket;
+    }
+
     // send the IPC_handle of IPC_handle_size to the consumer
     if (send(producer_socket, IPC_handle, IPC_handle_size, 0) < 0) {
         fprintf(stderr, "[producer] ERROR: unable to send the message\n");
@@ -443,25 +515,29 @@ int run_producer(int port, umf_memory_provider_ops_t *provider_ops,
     close(producer_socket);
 
 err_PutIPCHandle:
-    umf_result = umfMemoryProviderPutIPCHandle(provider, IPC_handle);
+    umf_result = umfPutIPCHandle(IPC_handle);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "[producer] ERROR: putting the IPC handle failed\n");
     }
 
     fprintf(stderr, "[producer] Put the IPC handle\n");
 
-err_free_IPC_handle:
-    free(IPC_handle);
 err_free_IPC_shared_memory:
-    (void)umfMemoryProviderFree(provider, IPC_shared_memory,
-                                size_IPC_shared_memory);
+    (void)umfFree(IPC_shared_memory);
+
 err_free_ptr2:
-    (void)umfMemoryProviderFree(provider, ptr2, ptr2_size);
+    (void)umfFree(ptr2);
+
 err_free_ptr1:
-    (void)umfMemoryProviderFree(provider, ptr1, ptr1_size);
+    (void)umfFree(ptr1);
+
+err_umfMemoryPoolDestroy:
+    umfPoolDestroy(pool);
+
 err_umfMemoryProviderDestroy:
     umfMemoryProviderDestroy(provider);
 
+err_end:
     if (ret == 0) {
         fprintf(stderr, "[producer] Shutting down (status OK) ...\n");
     } else if (ret == 1) {
diff --git a/test/common/ipc_common.h b/test/common/ipc_common.h
index a73b01435..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
@@ -8,7 +8,10 @@
 #ifndef UMF_TEST_IPC_COMMON_H
 #define UMF_TEST_IPC_COMMON_H
 
+#include <umf/ipc.h>
+#include <umf/memory_pool.h>
 #include <umf/memory_provider.h>
+#include <umf/pools/pool_scalable.h>
 
 // pointer to the function that returns void and accept two int values
 typedef void (*memcopy_callback_t)(void *dst, const void *src, size_t size,
@@ -17,10 +20,15 @@ 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_provider_ops_t *provider_ops,
+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_provider_ops_t *provider_ops,
+
+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);
 
diff --git a/test/common/numa_helpers.h b/test/common/numa_helpers.h
deleted file mode 100644
index aa9888fea..000000000
--- a/test/common/numa_helpers.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright (C) 2024 Intel Corporation
-// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-#ifndef UMF_TEST_NUMA_HELPERS_H
-#define UMF_TEST_NUMA_HELPERS_H 1
-
-#include <numa.h>
-#include <numaif.h>
-#include <stdint.h>
-#include <stdio.h>
-
-#include "test_helpers.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// returns the node where page starting at 'ptr' resides
-int getNumaNodeByPtr(void *ptr) {
-    int nodeId;
-    int retm =
-        get_mempolicy(&nodeId, nullptr, 0, ptr, MPOL_F_ADDR | MPOL_F_NODE);
-    UT_ASSERTeq(retm, 0);
-    UT_ASSERT(nodeId >= 0);
-
-    return nodeId;
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* UMF_TEST_NUMA_HELPERS_H */
diff --git a/test/common/numa_helpers.hpp b/test/common/numa_helpers.hpp
new file mode 100644
index 000000000..adcce9102
--- /dev/null
+++ b/test/common/numa_helpers.hpp
@@ -0,0 +1,205 @@
+// Copyright (C) 2024 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef UMF_TEST_NUMA_HELPERS_HPP
+#define UMF_TEST_NUMA_HELPERS_HPP 1
+
+#include <gtest/gtest.h>
+#include <numa.h>
+#include <numaif.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "test_helpers.h"
+
+// returns the node where page starting at 'ptr' resides
+static inline void getNumaNodeByPtr(void *ptr, int *node) {
+    int ret = get_mempolicy(node, nullptr, 0, ptr, MPOL_F_ADDR | MPOL_F_NODE);
+
+    ASSERT_EQ(ret, 0) << "get_mempolicy failed";
+    ASSERT_GE(*node, 0)
+        << "get_mempolicy returned nodeId < 0 - should never happen";
+}
+
+// returns the mode in which page starting at 'ptr' is bound
+static inline void getBindModeByPtr(void *ptr, int *mode) {
+    int ret = get_mempolicy(mode, nullptr, 0, ptr, MPOL_F_ADDR);
+
+    ASSERT_EQ(ret, 0) << "get_mempolicy failed";
+}
+
+// returns the mask in which page starting at 'ptr' is bound
+static inline void getBindMaskByPtr(void *ptr, struct bitmask *mask) {
+    int ret = get_mempolicy(nullptr, mask->maskp, mask->size, ptr, MPOL_F_ADDR);
+
+    ASSERT_EQ(ret, 0) << "get_mempolicy failed";
+}
+
+// Internal do not use directly
+#define _CUSTOMIZABLE_ASSERT(expr, fatal, eq)                                  \
+    do {                                                                       \
+        if (fatal) {                                                           \
+            if (eq) {                                                          \
+                ASSERT_TRUE(expr);                                             \
+            } else {                                                           \
+                ASSERT_FALSE(expr);                                            \
+            }                                                                  \
+        } else {                                                               \
+            if (eq) {                                                          \
+                EXPECT_TRUE(expr);                                             \
+            } else {                                                           \
+                EXPECT_FALSE(expr);                                            \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+// Internal do not use directly
+static inline void _assertNode(void *ptr, int expected_node, bool fatal,
+                               bool eq) {
+    int node;
+
+    getNumaNodeByPtr(ptr, &node);
+    if (testing::Test::HasFatalFailure()) {
+        return;
+    }
+
+    _CUSTOMIZABLE_ASSERT(node == expected_node, fatal, eq);
+}
+
+// Internal do not use directly
+static inline void _assertNode(void *ptr, void *ptr2, bool fatal, bool eq) {
+    int node, node2;
+
+    getNumaNodeByPtr(ptr, &node);
+    getNumaNodeByPtr(ptr2, &node2);
+    if (testing::Test::HasFatalFailure()) {
+        return;
+    }
+
+    _CUSTOMIZABLE_ASSERT(node == node2, fatal, eq);
+}
+
+// Internal do not use directly
+static inline void _assertBindMode(void *ptr, int expected_mode, bool fatal,
+                                   bool eq) {
+    int mode;
+
+    getBindModeByPtr(ptr, &mode);
+    if (testing::Test::HasFatalFailure()) {
+        return;
+    }
+
+    _CUSTOMIZABLE_ASSERT(mode == expected_mode, fatal, eq);
+}
+
+static inline void _assertBindMode(void *ptr, void *ptr2, bool fatal, bool eq) {
+    int mode, mode2;
+
+    getBindModeByPtr(ptr, &mode);
+    getBindModeByPtr(ptr2, &mode2);
+    if (testing::Test::HasFatalFailure()) {
+        return;
+    }
+
+    _CUSTOMIZABLE_ASSERT(mode == mode2, fatal, eq);
+}
+
+// Internal do not use directly
+static inline void _assertBindMask(void *ptr, struct bitmask *expected_mask,
+                                   bool fatal, bool eq) {
+    struct bitmask *mask = numa_allocate_nodemask();
+    ASSERT_NE(mask, nullptr) << "numa_allocate_nodemask failed";
+
+    getBindMaskByPtr(ptr, mask);
+    if (testing::Test::HasFatalFailure()) {
+        return;
+    }
+
+    _CUSTOMIZABLE_ASSERT(numa_bitmask_equal(mask, expected_mask), fatal, eq);
+
+    numa_free_nodemask(mask);
+}
+
+// Internal do not use directly
+static inline void _assertBindMask(void *ptr, void *ptr2, bool fatal, bool eq) {
+    struct bitmask *mask = numa_allocate_nodemask();
+    ASSERT_NE(mask, nullptr) << "numa_allocate_nodemask failed";
+
+    getBindMaskByPtr(ptr, mask);
+
+    struct bitmask *mask2 = numa_allocate_nodemask();
+    ASSERT_NE(mask2, nullptr) << "numa_allocate_nodemask failed";
+
+    getBindMaskByPtr(ptr2, mask2);
+
+    if (testing::Test::HasFatalFailure()) {
+        return;
+    }
+
+    _CUSTOMIZABLE_ASSERT(numa_bitmask_equal(mask, mask2), fatal, eq);
+
+    numa_free_nodemask(mask);
+    numa_free_nodemask(mask2);
+}
+
+// Asserts that a memory page starting at 'ptr' is on the expected NUMA node,
+// The target can be either a specific node or another pointer, in which case we compare nodes of both ptr.
+#define ASSERT_NODE_EQ(ptr, target)                                            \
+    ASSERT_NO_FATAL_FAILURE(_assertNode(ptr, target, true, true))
+
+// Asserts that a memory page starting at 'ptr' is not on the expected NUMA node,
+// The target can be either a specific node or another pointer, in which case we compare nodes of both ptr.
+#define ASSERT_NODE_NE(ptr, target)                                            \
+    ASSERT_NO_FATAL_FAILURE(_assertNode(ptr, target, true, false))
+
+// Expects that a memory page starting at 'ptr' is on the expected NUMA node,
+// Target can be either a node id or another pointer, in which case we compare nodes of both ptr.
+#define EXPECT_NODE_EQ(ptr, target)                                            \
+    ASSERT_NO_FATAL_FAILURE(_assertNode(ptr, target, false, true))
+
+// Expects that a memory page starting at 'ptr' is not on the expected NUMA node,
+// Target can be either a node id or another pointer, in which case we compare nodes of both ptr.
+#define EXPECT_NODE_NE(ptr, target)                                            \
+    ASSERT_NO_FATAL_FAILURE(_assertNode(ptr, target, false, false))
+
+// Asserts that a memory page starting at 'ptr' is bound in the expected memory binding mode.
+// The target can be either a specific mode or another pointer, in which case we compare the modes of both ptr.
+#define ASSERT_BIND_MODE_EQ(ptr, target)                                       \
+    ASSERT_NO_FATAL_FAILURE(_assertBindMode(ptr, target, true, true))
+// Asserts that a memory page starting at 'ptr' is not bound in the expected memory binding mode.
+// The target can be either a specific mode or another pointer, in which case we compare the modes of both ptr.
+#define ASSERT_BIND_MODE_NE(ptr, target)                                       \
+    ASSERT_NO_FATAL_FAILURE(_assertBindMode(ptr, target, true, false))
+
+// Expects that a memory page starting at 'ptr' is bound in the expected memory binding mode.
+// The target can be either a specific mode or another pointer, in which case we compare the modes of both ptr.
+#define EXPECT_BIND_MODE_EQ(ptr, target)                                       \
+    ASSERT_NO_FATAL_FAILURE(_assertBindMode(ptr, target, false, true))
+
+// Expects that a memory page starting at 'ptr' is not bound in the expected memory binding mode.
+// The target can be either a specific mode or another pointer, in which case we compare the modes of both ptr.
+#define EXPECT_BIND_MODE_NE(ptr, target)                                       \
+    ASSERT_NO_FATAL_FAILURE(_assertBindMode(ptr, target, false, false))
+
+// Asserts that the memory binding mask for the page starting at 'ptr' matches the expected mask.
+// The target can be either a bitmask or another pointer, in which case we compare the masks of both ptr.
+#define ASSERT_BIND_MASK_EQ(ptr, target)                                       \
+    ASSERT_NO_FATAL_FAILURE(_assertBindMask(ptr, target, true, true))
+
+// Asserts that the memory binding mask for the page starting at 'ptr' does not match the expected mask.
+// The target can be either a bitmask or another pointer, in which case we compare the masks of both ptr.
+#define ASSERT_BIND_MASK_NE(ptr, target)                                       \
+    ASSERT_NO_FATAL_FAILURE(_assertBindMask(ptr, target, true, false))
+
+// Expects that the memory binding mask for the page starting at 'ptr' matches the expected mask.
+// The target can be either a bitmask or another pointer, in which case we compare the masks of both ptr.
+#define EXPECT_BIND_MASK_EQ(ptr, target)                                       \
+    ASSERT_NO_FATAL_FAILURE(_assertBindMask(ptr, target, false, true))
+
+// Expects that the memory binding mask for the page starting at 'ptr' does not match the expected mask.
+// The target can be either a bitmask or another pointer, in which case we compare the masks of both ptr.
+#define EXPECT_BIND_MASK_NE(ptr, target)                                       \
+    ASSERT_NO_FATAL_FAILURE(_assertBindMask(ptr, target, false, false))
+
+#endif /* UMF_TEST_NUMA_HELPERS_HPP */
diff --git a/test/common/pool.hpp b/test/common/pool.hpp
index 9a5739085..d9873810a 100644
--- a/test/common/pool.hpp
+++ b/test/common/pool.hpp
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -19,16 +19,17 @@
 
 #include <umf/base.h>
 #include <umf/memory_provider.h>
+#include <umf/pools/pool_disjoint.h>
 
 #include "base.hpp"
-#include "cpp_helpers.hpp"
 #include "provider.hpp"
+#include "utils/cpp_helpers.hpp"
 
 namespace umf_test {
 
 umf_memory_pool_handle_t
-createPoolChecked(umf_memory_pool_ops_t *ops,
-                  umf_memory_provider_handle_t hProvider, void *params,
+createPoolChecked(const umf_memory_pool_ops_t *ops,
+                  umf_memory_provider_handle_t hProvider, const void *params,
                   umf_pool_create_flags_t flags = 0) {
     umf_memory_pool_handle_t hPool;
     auto ret = umfPoolCreate(ops, hProvider, params, flags, &hPool);
@@ -37,7 +38,7 @@ createPoolChecked(umf_memory_pool_ops_t *ops,
 }
 
 auto wrapPoolUnique(umf_memory_pool_handle_t hPool) {
-    return umf::pool_unique_handle_t(hPool, &umfPoolDestroy);
+    return umf_test::pool_unique_handle_t(hPool, &umfPoolDestroy);
 }
 
 bool isReallocSupported(umf_memory_pool_handle_t hPool) {
@@ -82,7 +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);
@@ -96,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 {
@@ -106,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;
@@ -132,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 {
@@ -148,7 +154,50 @@ struct malloc_pool : public pool_base_t {
 };
 
 umf_memory_pool_ops_t MALLOC_POOL_OPS =
-    umf::poolMakeCOps<umf_test::malloc_pool, void>();
+    umf_test::poolMakeCOps<umf_test::malloc_pool, void>();
+
+static constexpr size_t DEFAULT_DISJOINT_SLAB_MIN_SIZE = 4096;
+static constexpr size_t DEFAULT_DISJOINT_MAX_POOLABLE_SIZE = 4096;
+static constexpr size_t DEFAULT_DISJOINT_CAPACITY = 4;
+static constexpr size_t DEFAULT_DISJOINT_MIN_BUCKET_SIZE = 64;
+
+inline void *defaultDisjointPoolConfig() {
+    umf_disjoint_pool_params_handle_t config = nullptr;
+    umf_result_t res = umfDisjointPoolParamsCreate(&config);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error("Failed to create pool params");
+    }
+    res = umfDisjointPoolParamsSetSlabMinSize(config,
+                                              DEFAULT_DISJOINT_SLAB_MIN_SIZE);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfDisjointPoolParamsDestroy(config);
+        throw std::runtime_error("Failed to set slab min size");
+    }
+    res = umfDisjointPoolParamsSetMaxPoolableSize(
+        config, DEFAULT_DISJOINT_MAX_POOLABLE_SIZE);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfDisjointPoolParamsDestroy(config);
+        throw std::runtime_error("Failed to set max poolable size");
+    }
+    res = umfDisjointPoolParamsSetCapacity(config, DEFAULT_DISJOINT_CAPACITY);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfDisjointPoolParamsDestroy(config);
+        throw std::runtime_error("Failed to set capacity");
+    }
+    res = umfDisjointPoolParamsSetMinBucketSize(
+        config, DEFAULT_DISJOINT_MIN_BUCKET_SIZE);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfDisjointPoolParamsDestroy(config);
+        throw std::runtime_error("Failed to set min bucket size");
+    }
+
+    return config;
+}
+
+inline umf_result_t defaultDisjointPoolConfigDestroy(void *config) {
+    return umfDisjointPoolParamsDestroy(
+        static_cast<umf_disjoint_pool_params_handle_t>(config));
+}
 
 } // namespace umf_test
 
diff --git a/test/common/pool_null.c b/test/common/pool_null.c
index c34bcfc16..a44f3c4ab 100644
--- a/test/common/pool_null.c
+++ b/test/common/pool_null.c
@@ -1,4 +1,4 @@
-// Copyright (C) 2023 Intel Corporation
+// Copyright (C) 2023-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -9,7 +9,7 @@
 #include <umf/memory_pool_ops.h>
 
 static umf_result_t nullInitialize(umf_memory_provider_handle_t provider,
-                                   void *params, void **pool) {
+                                   const void *params, void **pool) {
     (void)provider;
     (void)params;
     assert(provider);
@@ -17,7 +17,10 @@ static umf_result_t nullInitialize(umf_memory_provider_handle_t provider,
     return UMF_RESULT_SUCCESS;
 }
 
-static void nullFinalize(void *pool) { (void)pool; }
+static umf_result_t nullFinalize(void *pool) {
+    (void)pool;
+    return UMF_RESULT_SUCCESS;
+}
 
 static void *nullMalloc(void *pool, size_t size) {
     (void)pool;
@@ -46,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;
@@ -64,7 +67,7 @@ static umf_result_t nullGetLastStatus(void *pool) {
 }
 
 umf_memory_pool_ops_t UMF_NULL_POOL_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_POOL_OPS_VERSION_CURRENT,
     .initialize = nullInitialize,
     .finalize = nullFinalize,
     .malloc = nullMalloc,
diff --git a/test/common/pool_trace.c b/test/common/pool_trace.c
index 29329f31c..e4479548f 100644
--- a/test/common/pool_trace.c
+++ b/test/common/pool_trace.c
@@ -1,4 +1,4 @@
-// Copyright (C) 2023 Intel Corporation
+// Copyright (C) 2023-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -13,13 +13,13 @@ typedef struct trace_pool {
 } trace_pool_t;
 
 static umf_result_t traceInitialize(umf_memory_provider_handle_t provider,
-                                    void *params, void **pool) {
+                                    const void *params, void **pool) {
     trace_pool_t *trace_pool = (trace_pool_t *)malloc(sizeof(trace_pool_t));
     if (NULL == trace_pool) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
 
-    umf_pool_trace_params_t *pub_params = params;
+    const umf_pool_trace_params_t *pub_params = params;
     trace_pool->params.hUpstreamPool = pub_params->hUpstreamPool;
     trace_pool->params.trace_context = pub_params->trace_context;
     trace_pool->params.trace_handler = pub_params->trace_handler;
@@ -31,7 +31,10 @@ static umf_result_t traceInitialize(umf_memory_provider_handle_t provider,
     return UMF_RESULT_SUCCESS;
 }
 
-static void traceFinalize(void *pool) { free(pool); }
+static umf_result_t traceFinalize(void *pool) {
+    free(pool);
+    return UMF_RESULT_SUCCESS;
+}
 
 static void *traceMalloc(void *pool, size_t size) {
     trace_pool_t *trace_pool = (trace_pool_t *)pool;
@@ -66,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,
@@ -90,7 +93,7 @@ static umf_result_t traceGetLastStatus(void *pool) {
 }
 
 umf_memory_pool_ops_t UMF_TRACE_POOL_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_POOL_OPS_VERSION_CURRENT,
     .initialize = traceInitialize,
     .finalize = traceFinalize,
     .malloc = traceMalloc,
diff --git a/test/common/provider.hpp b/test/common/provider.hpp
index cb4835eb5..a393a77c6 100644
--- a/test/common/provider.hpp
+++ b/test/common/provider.hpp
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -14,8 +14,9 @@
 #include <umf/memory_provider.h>
 
 #include "base.hpp"
-#include "cpp_helpers.hpp"
+#include "base_alloc_global.h"
 #include "test_helpers.h"
+#include "utils/cpp_helpers.hpp"
 
 namespace umf_test {
 
@@ -28,7 +29,8 @@ createProviderChecked(umf_memory_provider_ops_t *ops, void *params) {
 }
 
 auto wrapProviderUnique(umf_memory_provider_handle_t hProvider) {
-    return umf::provider_unique_handle_t(hProvider, &umfMemoryProviderDestroy);
+    return umf_test::provider_unique_handle_t(hProvider,
+                                              &umfMemoryProviderDestroy);
 }
 
 typedef struct provider_base_t {
@@ -46,59 +48,60 @@ 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;
 } provider_base_t;
 
 umf_memory_provider_ops_t BASE_PROVIDER_OPS =
-    umf::providerMakeCOps<provider_base_t, void>();
+    umf_test::providerMakeCOps<provider_base_t, void>();
 
-struct provider_malloc : public provider_base_t {
+struct provider_ba_global : public provider_base_t {
     umf_result_t alloc(size_t size, size_t align, void **ptr) noexcept {
         if (!align) {
             align = 8;
@@ -108,35 +111,30 @@ struct provider_malloc : public provider_base_t {
         // requirement of 'size' being multiple of 'align' even though the
         // documentation says that it has to. AddressSanitizer returns an
         // error because of this issue.
-        size_t aligned_size = ALIGN_UP(size, align);
+        size_t aligned_size = ALIGN_UP_SAFE(size, align);
+        if (aligned_size == 0) {
+            return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        }
 
-#ifdef _WIN32
-        *ptr = _aligned_malloc(aligned_size, align);
-#else
-        *ptr = ::aligned_alloc(align, aligned_size);
-#endif
+        *ptr = umf_ba_global_aligned_alloc(aligned_size, align);
 
         return (*ptr) ? UMF_RESULT_SUCCESS
                       : UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
     umf_result_t free(void *ptr, size_t) noexcept {
-#ifdef _WIN32
-        _aligned_free(ptr);
-#else
-        ::free(ptr);
-#endif
+        umf_ba_global_free(ptr);
         return UMF_RESULT_SUCCESS;
     }
-    const char *get_name() noexcept { return "malloc"; }
+    const char *get_name() noexcept { return "umf_ba_global"; }
 };
 
-umf_memory_provider_ops_t MALLOC_PROVIDER_OPS =
-    umf::providerMakeCOps<provider_malloc, void>();
+umf_memory_provider_ops_t BA_GLOBAL_PROVIDER_OPS =
+    umf_test::providerMakeCOps<provider_ba_global, void>();
 
 struct provider_mock_out_of_mem : public provider_base_t {
-    provider_malloc helper_prov;
+    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;
     }
@@ -155,8 +153,8 @@ 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 =
-    umf::providerMakeCOps<provider_mock_out_of_mem, int>();
+const umf_memory_provider_ops_t MOCK_OUT_OF_MEM_PROVIDER_OPS =
+    umf_test::providerMakeCOps<provider_mock_out_of_mem, int>();
 
 } // namespace umf_test
 
diff --git a/test/common/provider_null.c b/test/common/provider_null.c
index e667bfce4..8c1602be7 100644
--- a/test/common/provider_null.c
+++ b/test/common/provider_null.c
@@ -1,4 +1,4 @@
-// Copyright (C) 2023-2024 Intel Corporation
+// Copyright (C) 2023-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -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;
@@ -130,7 +132,7 @@ static umf_result_t nullCloseIpcHandle(void *provider, void *ptr, size_t size) {
 }
 
 umf_memory_provider_ops_t UMF_NULL_PROVIDER_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = nullInitialize,
     .finalize = nullFinalize,
     .alloc = nullAlloc,
@@ -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 9d063b4f5..6be80c0de 100644
--- a/test/common/provider_trace.c
+++ b/test/common/provider_trace.c
@@ -1,4 +1,4 @@
-// Copyright (C) 2023-2024 Intel Corporation
+// Copyright (C) 2023-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -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;
@@ -191,7 +195,7 @@ static umf_result_t traceCloseIpcHandle(void *provider, void *ptr,
 }
 
 umf_memory_provider_ops_t UMF_TRACE_PROVIDER_OPS = {
-    .version = UMF_VERSION_CURRENT,
+    .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = traceInitialize,
     .finalize = traceFinalize,
     .alloc = traceAlloc,
@@ -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/common/test_helpers.c b/test/common/test_helpers.c
index 71f018d0f..d69ca3535 100644
--- a/test/common/test_helpers.c
+++ b/test/common/test_helpers.c
@@ -1,4 +1,4 @@
-// Copyright (C) 2023 Intel Corporation
+// Copyright (C) 2023-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 // This file contains tests for UMF pool API
diff --git a/test/common/test_helpers.h b/test/common/test_helpers.h
index e361feba4..494528b57 100644
--- a/test/common/test_helpers.h
+++ b/test/common/test_helpers.h
@@ -14,67 +14,14 @@
 #include <umf/memory_provider_ops.h>
 
 #include "provider_trace.h"
+#include "utils_common.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-static inline void UT_FATAL(const char *format, ...) {
-    va_list args_list;
-    va_start(args_list, format);
-    vfprintf(stderr, format, args_list);
-    va_end(args_list);
-
-    fprintf(stderr, "\n");
-
-    abort();
-}
-
-static inline void UT_OUT(const char *format, ...) {
-    va_list args_list;
-    va_start(args_list, format);
-    vfprintf(stdout, format, args_list);
-    va_end(args_list);
-
-    fprintf(stdout, "\n");
-}
-
-// Assert a condition is true at runtime
-#define UT_ASSERT(cnd)                                                         \
-    ((void)((cnd) || (UT_FATAL("%s:%d %s - assertion failure: %s", __FILE__,   \
-                               __LINE__, __func__, #cnd),                      \
-                      0)))
-
-// Assertion with extra info printed if assertion fails at runtime
-#define UT_ASSERTinfo(cnd, info)                                               \
-    ((void)((cnd) ||                                                           \
-            (UT_FATAL("%s:%d %s - assertion failure: %s (%s = %s)", __FILE__,  \
-                      __LINE__, __func__, #cnd, #info, info),                  \
-             0)))
-
-// Assert two integer values are equal at runtime
-#define UT_ASSERTeq(lhs, rhs)                                                  \
-    ((void)(((lhs) == (rhs)) ||                                                \
-            (UT_FATAL("%s:%d %s - assertion failure: %s (0x%llx) == %s "       \
-                      "(0x%llx)",                                              \
-                      __FILE__, __LINE__, __func__, #lhs,                      \
-                      (unsigned long long)(lhs), #rhs,                         \
-                      (unsigned long long)(rhs)),                              \
-             0)))
-
-// Assert two integer values are not equal at runtime
-#define UT_ASSERTne(lhs, rhs)                                                  \
-    ((void)(((lhs) != (rhs)) ||                                                \
-            (UT_FATAL("%s:%d %s - assertion failure: %s (0x%llx) != %s "       \
-                      "(0x%llx)",                                              \
-                      __FILE__, __LINE__, __func__, #lhs,                      \
-                      (unsigned long long)(lhs), #rhs,                         \
-                      (unsigned long long)(rhs)),                              \
-             0)))
-
-#ifndef ALIGN_UP
-#define ALIGN_UP(value, align) (((value) + (align)-1) & ~((align)-1))
-#endif
+// Needed for CI
+#define TEST_SKIP_ERROR_CODE 125
 
 int bufferIsFilledWithChar(void *ptr, size_t size, char c);
 
diff --git a/test/common/test_helpers_linux.c b/test/common/test_helpers_linux.c
new file mode 100644
index 000000000..431880bf7
--- /dev/null
+++ b/test/common/test_helpers_linux.c
@@ -0,0 +1,69 @@
+// Copyright (C) 2024 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// This file contains tests for UMF pool API
+
+#include <fcntl.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "test_helpers_linux.h"
+
+// Check if the file given by the 'path' argument was mapped with the MAP_SYNC flag:
+// 1) Open and read the /proc/self/smaps file.
+// 2) Look for the section of the 'path' file.
+// 3) Check if the VmFlags of the 'path' file contains the "sf" flag
+//    marking that the file was mapped with the MAP_SYNC flag.
+bool is_mapped_with_MAP_SYNC(char *path, char *buf, size_t size_buf) {
+    memset(buf, 0, size_buf);
+
+    int fd = open("/proc/self/smaps", O_RDONLY);
+    if (fd == -1) {
+        return false;
+    }
+
+    // number of bytes read from the file
+    ssize_t nbytes = 1;
+    // string starting from the path of the smaps
+    char *smaps = NULL;
+
+    // Read the "/proc/self/smaps" file
+    // until the path of the smaps is found
+    // or EOF is reached.
+    while (nbytes > 0 && smaps == NULL) {
+        memset(buf, 0, nbytes); // erase previous data
+        nbytes = read(fd, buf, size_buf);
+        // look for the path of the smaps
+        smaps = strstr(buf, path);
+    }
+
+    (void)close(fd);
+
+    // String starting from the "sf" flag
+    // marking that memory was mapped with the MAP_SYNC flag.
+    char *sf_flag = NULL;
+
+    if (smaps) {
+        // look for the "VmFlags:" string
+        char *VmFlags = strstr(smaps, "VmFlags:");
+        if (VmFlags) {
+            // look for the EOL
+            char *eol = strstr(VmFlags, "\n");
+            if (eol) {
+                // End the VmFlags string at EOL.
+                *eol = 0;
+                // Now the VmFlags string contains only one line with all VmFlags.
+
+                // Look for the "sf" flag in VmFlags
+                // marking that memory was mapped
+                // with the MAP_SYNC flag.
+                sf_flag = strstr(VmFlags, "sf");
+            }
+        }
+    }
+
+    return (sf_flag != NULL);
+}
diff --git a/test/common/test_helpers_linux.h b/test/common/test_helpers_linux.h
new file mode 100644
index 000000000..7755408b7
--- /dev/null
+++ b/test/common/test_helpers_linux.h
@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// This file contains helpers for tests for UMF pool API
+
+#ifndef UMF_TEST_HELPERS_LINUX_H
+#define UMF_TEST_HELPERS_LINUX_H 1
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bool is_mapped_with_MAP_SYNC(char *path, char *buf, size_t size_buf);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_TEST_HELPERS_LINUX_H */
diff --git a/test/ctl/config.txt b/test/ctl/config.txt
new file mode 100644
index 000000000..52c8febad
--- /dev/null
+++ b/test/ctl/config.txt
@@ -0,0 +1,3 @@
+debug.heap.alloc_pattern=321;
+debug.heap.enable_logging=1;
+debug.heap.log_level=5;
diff --git a/test/ctl/ctl_api.cpp b/test/ctl/ctl_api.cpp
new file mode 100644
index 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
new file mode 100644
index 000000000..965e4871c
--- /dev/null
+++ b/test/ctl/ctl_debug.c
@@ -0,0 +1,140 @@
+/*
+ *
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+/*
+ * ctl_debug.c -- implementation of the debug CTL namespace
+ */
+
+#include "ctl_debug.h"
+
+static struct ctl ctl_debug;
+
+static int alloc_pattern = 0;
+static int enable_logging = 0;
+static int log_level = 0;
+
+struct ctl *get_debug_ctl(void) { return &ctl_debug; }
+
+/*
+ * CTL_WRITE_HANDLER(alloc_pattern) -- sets the alloc_pattern field in heap
+ */
+static int CTL_WRITE_HANDLER(alloc_pattern)(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_in = *(int *)arg;
+    alloc_pattern = arg_in;
+    return 0;
+}
+
+/*
+ * CTL_READ_HANDLER(alloc_pattern) -- returns alloc_pattern heap field
+ */
+static int CTL_READ_HANDLER(alloc_pattern)(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;
+    *arg_out = alloc_pattern;
+    return 0;
+}
+
+static int CTL_WRITE_HANDLER(enable_logging)(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_in = *(int *)arg;
+    enable_logging = arg_in;
+    return 0;
+}
+
+static int CTL_READ_HANDLER(enable_logging)(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;
+    *arg_out = enable_logging;
+    return 0;
+}
+
+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)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, 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;
+    *arg_out = log_level;
+    return 0;
+}
+
+static const struct ctl_argument CTL_ARG(alloc_pattern) = CTL_ARG_LONG_LONG;
+
+static const struct ctl_argument CTL_ARG(enable_logging) = CTL_ARG_BOOLEAN;
+
+static const struct ctl_argument CTL_ARG(log_level) = CTL_ARG_INT;
+
+static const umf_ctl_node_t CTL_NODE(heap)[] = {CTL_LEAF_RW(alloc_pattern),
+                                                CTL_LEAF_RW(enable_logging),
+                                                CTL_LEAF_RW(log_level),
+
+                                                CTL_NODE_END};
+
+static const umf_ctl_node_t CTL_NODE(debug)[] = {CTL_CHILD(heap),
+
+                                                 CTL_NODE_END};
+
+/*
+ * debug_ctl_register -- registers ctl nodes for "debug" module
+ */
+void debug_ctl_register(struct ctl *ctl) { CTL_REGISTER_MODULE(ctl, debug); }
+
+void initialize_debug_ctl(void) { debug_ctl_register(&ctl_debug); }
diff --git a/test/ctl/ctl_debug.h b/test/ctl/ctl_debug.h
new file mode 100644
index 000000000..9dd8bade5
--- /dev/null
+++ b/test/ctl/ctl_debug.h
@@ -0,0 +1,32 @@
+/*
+ *
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+/*
+ * ctl_debug.h -- definitions for CTL test
+ */
+
+#ifndef UMF_CTL_DEBUG_H
+#define UMF_CTL_DEBUG_H 1
+
+#include "../src/ctl/ctl.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void debug_ctl_register(struct ctl *ctl);
+struct ctl *get_debug_ctl(void);
+void initialize_debug_ctl(void);
+void deinitialize_debug_ctl(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/test/ctl/ctl_unittest.cpp b/test/ctl/ctl_unittest.cpp
new file mode 100644
index 000000000..f98825bd4
--- /dev/null
+++ b/test/ctl/ctl_unittest.cpp
@@ -0,0 +1,96 @@
+/*
+ *
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+#include "../common/base.hpp"
+#include "ctl/ctl.h"
+#include "ctl/ctl_debug.h"
+
+using namespace umf_test;
+
+TEST_F(test, ctl_debug_read_from_string) {
+    initialize_debug_ctl();
+    auto ctl_handler = get_debug_ctl();
+    ctl_load_config_from_string(ctl_handler, NULL,
+                                "debug.heap.alloc_pattern=1");
+
+    int value = 0;
+    ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
+              "debug.heap.alloc_pattern", CTL_QUERY_READ, &value,
+              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,
+              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,
+              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,
+                        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,
+                        sizeof(value)),
+              0);
+
+    debug_ctl_register(ctl_handler);
+}
+
+int ctl_config_write_to_file(const char *filename, const char *data) {
+    FILE *file = fopen(filename == NULL ? "config.txt" : filename, "w+");
+    if (file == NULL) {
+        return -1;
+    }
+    fputs(data, file);
+    fclose(file);
+    return 0;
+}
+
+TEST_F(test, ctl_debug_read_from_file) {
+#ifndef _WIN32
+    ASSERT_EQ(ctl_config_write_to_file(
+                  "config.txt", "debug.heap.alloc_pattern=321;\ndebug.heap."
+                                "enable_logging=1;\ndebug.heap.log_level=5;\n"),
+              0);
+    initialize_debug_ctl();
+    auto ctl_handler = get_debug_ctl();
+    ASSERT_EQ(ctl_load_config_from_file(ctl_handler, NULL, "config.txt"), 0);
+
+    int value = 0;
+    ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC,
+              "debug.heap.alloc_pattern", CTL_QUERY_READ, &value, 0);
+    ASSERT_EQ(value, 321);
+
+    value = 0;
+    ctl_query(ctl_handler, NULL, CTL_QUERY_PROGRAMMATIC, "debug.heap.log_level",
+              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, 0);
+    ASSERT_EQ(value, 1);
+
+    debug_ctl_register(ctl_handler);
+#endif
+}
diff --git a/test/disjoint_pool_file_prov.cpp b/test/disjoint_pool_file_prov.cpp
new file mode 100644
index 000000000..08fad03e2
--- /dev/null
+++ b/test/disjoint_pool_file_prov.cpp
@@ -0,0 +1,371 @@
+/*
+ * Copyright (C) 2023-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#include <random>
+
+#include <umf/pools/pool_disjoint.h>
+#include <umf/providers/provider_file_memory.h>
+
+#include "coarse.h"
+#include "provider.hpp"
+
+using umf_test::KB;
+using umf_test::MB;
+using umf_test::test;
+
+#define FILE_PATH ((char *)"tmp_file")
+
+umf_memory_provider_ops_t UMF_MALLOC_MEMORY_PROVIDER_OPS =
+    umf_test::providerMakeCOps<umf_test::provider_ba_global, void>();
+
+struct FileWithMemoryStrategyTest
+    : umf_test::test,
+      ::testing::WithParamInterface<coarse_strategy_t> {
+    void SetUp() override {
+        test::SetUp();
+        allocation_strategy = this->GetParam();
+    }
+
+    coarse_strategy_t allocation_strategy;
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    FileWithMemoryStrategyTest, FileWithMemoryStrategyTest,
+    ::testing::Values(UMF_COARSE_MEMORY_STRATEGY_FASTEST,
+                      UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE,
+                      UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE));
+
+TEST_P(FileWithMemoryStrategyTest, disjointFileMallocPool_simple1) {
+    umf_memory_provider_handle_t malloc_memory_provider = nullptr;
+    umf_result_t umf_result;
+
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS,
+                                         nullptr, &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    umf_file_memory_provider_params_handle_t file_params = nullptr;
+    umf_result = umfFileMemoryProviderParamsCreate(&file_params, FILE_PATH);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(file_params, nullptr);
+
+    umf_memory_provider_handle_t file_memory_provider;
+    umf_result = umfMemoryProviderCreate(umfFileMemoryProviderOps(),
+                                         file_params, &file_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(file_memory_provider, nullptr);
+
+    umf_result = umfFileMemoryProviderParamsDestroy(file_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_disjoint_pool_params_handle_t disjoint_pool_params = nullptr;
+    umf_result = umfDisjointPoolParamsCreate(&disjoint_pool_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(disjoint_pool_params, nullptr);
+    umf_result =
+        umfDisjointPoolParamsSetSlabMinSize(disjoint_pool_params, 4096);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result =
+        umfDisjointPoolParamsSetMaxPoolableSize(disjoint_pool_params, 4096);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfDisjointPoolParamsSetCapacity(disjoint_pool_params, 4);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result =
+        umfDisjointPoolParamsSetMinBucketSize(disjoint_pool_params, 64);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfDisjointPoolParamsSetTrace(disjoint_pool_params, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_memory_pool_handle_t pool;
+    umf_result =
+        umfPoolCreate(umfDisjointPoolOps(), file_memory_provider,
+                      disjoint_pool_params, UMF_POOL_CREATE_FLAG_NONE, &pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(pool, nullptr);
+
+    umf_result = umfDisjointPoolParamsDestroy(disjoint_pool_params);
+
+    umf_memory_provider_handle_t prov = nullptr;
+    umfPoolGetMemoryProvider(pool, &prov);
+    ASSERT_NE(prov, nullptr);
+
+    // test 1
+
+    size_t s1 = 74659 * KB;
+    size_t s2 = 8206 * KB;
+
+    const int nreps = 2;
+    const int nptrs = 6;
+
+    // s1
+    for (int j = 0; j < nreps; j++) {
+        void *t[nptrs] = {0};
+        for (int i = 0; i < nptrs; i++) {
+            t[i] = umfPoolMalloc(pool, s1);
+            ASSERT_NE(t[i], nullptr);
+        }
+
+        for (int i = 0; i < nptrs; i++) {
+            umf_result = umfPoolFree(pool, t[i]);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+    }
+
+    // s2
+    for (int j = 0; j < nreps; j++) {
+        void *t[nptrs] = {0};
+        for (int i = 0; i < nptrs; i++) {
+            t[i] = umfPoolMalloc(pool, s2);
+            ASSERT_NE(t[i], nullptr);
+        }
+
+        for (int i = 0; i < nptrs; i++) {
+            umf_result = umfPoolFree(pool, t[i]);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+    }
+
+    umf_result = umfPoolDestroy(pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(file_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(FileWithMemoryStrategyTest, disjointFileMallocPool_simple2) {
+    umf_memory_provider_handle_t malloc_memory_provider = nullptr;
+    umf_result_t umf_result;
+
+    umf_result = umfMemoryProviderCreate(&UMF_MALLOC_MEMORY_PROVIDER_OPS,
+                                         nullptr, &malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(malloc_memory_provider, nullptr);
+
+    umf_file_memory_provider_params_handle_t file_params = nullptr;
+    umf_result = umfFileMemoryProviderParamsCreate(&file_params, FILE_PATH);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(file_params, nullptr);
+
+    umf_memory_provider_handle_t file_memory_provider;
+    umf_result = umfMemoryProviderCreate(umfFileMemoryProviderOps(),
+                                         file_params, &file_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(file_memory_provider, nullptr);
+
+    umf_result = umfFileMemoryProviderParamsDestroy(file_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_disjoint_pool_params_handle_t disjoint_pool_params = nullptr;
+    umf_result = umfDisjointPoolParamsCreate(&disjoint_pool_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(disjoint_pool_params, nullptr);
+    umf_result =
+        umfDisjointPoolParamsSetSlabMinSize(disjoint_pool_params, 4096);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result =
+        umfDisjointPoolParamsSetMaxPoolableSize(disjoint_pool_params, 4096);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfDisjointPoolParamsSetCapacity(disjoint_pool_params, 4);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result =
+        umfDisjointPoolParamsSetMinBucketSize(disjoint_pool_params, 64);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfDisjointPoolParamsSetTrace(disjoint_pool_params, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_memory_pool_handle_t pool;
+    umf_result =
+        umfPoolCreate(umfDisjointPoolOps(), file_memory_provider,
+                      disjoint_pool_params, UMF_POOL_CREATE_FLAG_NONE, &pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(pool, nullptr);
+
+    umf_result = umfDisjointPoolParamsDestroy(disjoint_pool_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // test
+    double sizes[] = {2, 4, 0.5, 1, 8, 0.25};
+    size_t alignment[] = {0, 4, 0, 16, 32, 128};
+    for (int i = 0; i < 6; i++) {
+        size_t s = (size_t)(sizes[i] * MB);
+        void *t[8] = {0};
+        for (int j = 0; j < 8; j++) {
+            t[j] = umfPoolAlignedMalloc(pool, s, alignment[i]);
+            ASSERT_NE(t[j], nullptr);
+        }
+
+        for (int j = 0; j < 8; j++) {
+            umf_result = umfPoolFree(pool, t[j]);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+    }
+
+    umf_result = umfPoolDestroy(pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(file_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(malloc_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+struct alloc_ptr_size {
+    void *ptr;
+    size_t size;
+
+    bool operator<(const alloc_ptr_size &other) const {
+        if (ptr == other.ptr) {
+            return size < other.size;
+        }
+        return ptr < other.ptr;
+    }
+};
+
+TEST_P(FileWithMemoryStrategyTest, disjointFileMMapPool_random) {
+    umf_result_t umf_result;
+
+    const size_t init_buffer_size = 200 * MB;
+
+    // preallocate some memory and initialize the vector with zeros
+    std::vector<char> buffer(init_buffer_size, 0);
+    void *buf = (void *)buffer.data();
+    ASSERT_NE(buf, nullptr);
+
+    const unsigned char alloc_check_val = 11;
+
+    umf_file_memory_provider_params_handle_t file_params = nullptr;
+    umf_result = umfFileMemoryProviderParamsCreate(&file_params, FILE_PATH);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(file_params, nullptr);
+
+    umf_memory_provider_handle_t file_memory_provider;
+    umf_result = umfMemoryProviderCreate(umfFileMemoryProviderOps(),
+                                         file_params, &file_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(file_memory_provider, nullptr);
+
+    umf_result = umfFileMemoryProviderParamsDestroy(file_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_disjoint_pool_params_handle_t disjoint_pool_params = nullptr;
+    umf_result = umfDisjointPoolParamsCreate(&disjoint_pool_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(disjoint_pool_params, nullptr);
+    umf_result =
+        umfDisjointPoolParamsSetSlabMinSize(disjoint_pool_params, 1024);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result =
+        umfDisjointPoolParamsSetMaxPoolableSize(disjoint_pool_params, 1024);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfDisjointPoolParamsSetCapacity(disjoint_pool_params, 2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result =
+        umfDisjointPoolParamsSetMinBucketSize(disjoint_pool_params, 16);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfDisjointPoolParamsSetTrace(disjoint_pool_params, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_memory_pool_handle_t pool;
+    umf_result =
+        umfPoolCreate(umfDisjointPoolOps(), file_memory_provider,
+                      disjoint_pool_params, UMF_POOL_CREATE_FLAG_NONE, &pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(pool, nullptr);
+
+    umf_result = umfDisjointPoolParamsDestroy(disjoint_pool_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // set constant seed so each test run will have the same scenario
+    uint32_t seed = 1234;
+    std::mt19937 mt(seed);
+
+    // different sizes to alloc
+    std::vector<size_t> sizes = {15,        49,     588,      1025,
+                                 2 * KB,    5 * KB, 160 * KB, 511 * KB,
+                                 1000 * KB, MB,     3 * MB,   7 * MB};
+    std::uniform_int_distribution<int> sizes_dist(0, (int)(sizes.size() - 1));
+
+    // each alloc would be done few times
+    std::vector<size_t> counts = {1, 3, 4, 8, 9, 11};
+    std::uniform_int_distribution<int> counts_dist(0, (int)(counts.size() - 1));
+
+    // action to take will be random
+    // alloc = <0, .5), free = <.5, 1)
+    std::uniform_real_distribution<float> actions_dist(0, 1);
+
+    std::set<alloc_ptr_size> allocs;
+    const int nreps = 100;
+
+    for (size_t i = 0; i < nreps; i++) {
+        size_t count = counts[counts_dist(mt)];
+        float action = actions_dist(mt);
+
+        if (action < 0.5) {
+            size_t size = sizes[sizes_dist(mt)];
+            std::cout << "size: " << size << " count: " << count
+                      << " action: alloc" << std::endl;
+
+            // alloc
+            for (size_t j = 0; j < count; j++) {
+                void *ptr = umfPoolCalloc(pool, 1, size);
+                if (ptr == nullptr) {
+                    break;
+                }
+
+                // check if first and last bytes are empty and fill them with control data
+                ASSERT_EQ(((unsigned char *)ptr)[0], 0);
+                ASSERT_EQ(((unsigned char *)ptr)[size - 1], 0);
+                ((unsigned char *)ptr)[0] = alloc_check_val;
+                ((unsigned char *)ptr)[size - 1] = alloc_check_val;
+
+                allocs.insert({ptr, size});
+            }
+        } else {
+            std::cout << "count: " << count << " action: free" << std::endl;
+
+            // free random allocs
+            for (size_t j = 0; j < count; j++) {
+                if (allocs.size() == 0) {
+                    continue;
+                }
+
+                std::uniform_int_distribution<int> free_dist(
+                    0, (int)(allocs.size() - 1));
+                size_t free_id = free_dist(mt);
+                auto it = allocs.begin();
+                std::advance(it, free_id);
+                auto [ptr, size] = (*it);
+                ASSERT_NE(ptr, nullptr);
+
+                // check if control bytes are set and clean them
+
+                ASSERT_EQ(((unsigned char *)ptr)[0], alloc_check_val);
+                ASSERT_EQ(((unsigned char *)ptr)[size - 1], alloc_check_val);
+                ((unsigned char *)ptr)[0] = 0;
+                ((unsigned char *)ptr)[size - 1] = 0;
+
+                umf_result_t ret = umfPoolFree(pool, ptr);
+                ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+                allocs.erase(it);
+            }
+        }
+    }
+
+    std::cout << "cleanup" << std::endl;
+
+    while (allocs.size()) {
+        umf_result_t ret = umfPoolFree(pool, (*allocs.begin()).ptr);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        allocs.erase(allocs.begin());
+    }
+
+    umf_result = umfPoolDestroy(pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(file_memory_provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
diff --git a/test/fuzz/umfFuzz.cpp b/test/fuzz/umfFuzz.cpp
index ac52c96b5..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,11 +12,16 @@ 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();
-    umf_os_memory_provider_params_t params = umfOsMemoryProviderParamsDefault();
-    umf_result_t res =
-        umfMemoryProviderCreate(provider_ops, &params, &test_state.provider);
+    const umf_memory_provider_ops_t *provider_ops = umfOsMemoryProviderOps();
+    umf_os_memory_provider_params_handle_t params = NULL;
+
+    umf_result_t res = umfOsMemoryProviderParamsCreate(&params);
+    if (res != UMF_RESULT_SUCCESS) {
+        return -1;
+    }
 
+    res = umfMemoryProviderCreate(provider_ops, params, &test_state.provider);
+    umfOsMemoryProviderParamsDestroy(params);
     if (res != UMF_RESULT_SUCCESS) {
         return -1;
     }
@@ -74,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 524c26d4b..15e995acd 100644
--- a/test/ipcAPI.cpp
+++ b/test/ipcAPI.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2023-2024 Intel Corporation
+// Copyright (C) 2023-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 // This file contains tests for UMF pool API
@@ -24,9 +24,9 @@ struct provider_mock_ipc : public umf_test::provider_base_t {
         size_t size;
     };
 
-    umf_test::provider_malloc helper_prov;
-    allocations_mutex_type alloc_mutex;
-    allocations_map_type allocations;
+    umf_test::provider_ba_global helper_prov;
+    static allocations_mutex_type alloc_mutex;
+    static allocations_map_type allocations;
 
     umf_result_t alloc(size_t size, size_t align, void **ptr) noexcept {
         auto ret = helper_prov.alloc(size, align, ptr);
@@ -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,19 +105,24 @@ 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;
     }
 };
 
+provider_mock_ipc::allocations_mutex_type provider_mock_ipc::alloc_mutex;
+provider_mock_ipc::allocations_map_type provider_mock_ipc::allocations;
+
 static umf_memory_provider_ops_t IPC_MOCK_PROVIDER_OPS =
-    umf::providerMakeCOps<provider_mock_ipc, void>();
+    umf_test::providerMakeCOps<provider_mock_ipc, void>();
 
 HostMemoryAccessor hostMemoryAccessor;
 
 INSTANTIATE_TEST_SUITE_P(umfIpcTestSuite, umfIpcTest,
                          ::testing::Values(ipcTestParams{
-                             umfProxyPoolOps(), nullptr, &IPC_MOCK_PROVIDER_OPS,
-                             nullptr, &hostMemoryAccessor}));
+                             umfProxyPoolOps(), nullptr, nullptr,
+                             &IPC_MOCK_PROVIDER_OPS, nullptr, nullptr,
+                             &hostMemoryAccessor}));
diff --git a/test/ipcFixtures.hpp b/test/ipcFixtures.hpp
index 1eb7865e3..4c1e5e714 100644
--- a/test/ipcFixtures.hpp
+++ b/test/ipcFixtures.hpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2024 Intel Corporation
+// Copyright (C) 2024-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -15,12 +15,15 @@
 #include <umf/memory_provider.h>
 #include <umf/pools/pool_proxy.h>
 
+#include <algorithm>
 #include <cstring>
 #include <numeric>
+#include <random>
 #include <tuple>
 
 class MemoryAccessor {
   public:
+    virtual ~MemoryAccessor() = default;
     virtual void fill(void *ptr, size_t size, const void *pattern,
                       size_t pattern_size) = 0;
     virtual void copy(void *dst_ptr, void *src_ptr, size_t size) = 0;
@@ -46,35 +49,78 @@ class HostMemoryAccessor : public MemoryAccessor {
     }
 };
 
+typedef void *(*pfnPoolParamsCreate)();
+typedef umf_result_t (*pfnPoolParamsDestroy)(void *);
+
+typedef void *(*pfnProviderParamsCreate)();
+typedef umf_result_t (*pfnProviderParamsDestroy)(void *);
+
+// ipcTestParams:
+// pool_ops, pfnPoolParamsCreate,pfnPoolParamsDestroy,
+// provider_ops, pfnProviderParamsCreate, pfnProviderParamsDestroy,
+// memoryAccessor
 using ipcTestParams =
-    std::tuple<umf_memory_pool_ops_t *, void *, umf_memory_provider_ops_t *,
-               void *, MemoryAccessor *>;
+    std::tuple<const umf_memory_pool_ops_t *, pfnPoolParamsCreate,
+               pfnPoolParamsDestroy, const umf_memory_provider_ops_t *,
+               pfnProviderParamsCreate, pfnProviderParamsDestroy,
+               MemoryAccessor *>;
 
 struct umfIpcTest : umf_test::test,
                     ::testing::WithParamInterface<ipcTestParams> {
-    umfIpcTest() : pool(nullptr, nullptr) {}
+    umfIpcTest() {}
+    size_t getOpenedIpcCacheSize() {
+        const char *max_size_str = getenv("UMF_MAX_OPENED_IPC_HANDLES");
+        if (max_size_str) {
+            char *endptr;
+            size_t max_size = strtoul(max_size_str, &endptr, 10);
+            EXPECT_EQ(*endptr, '\0');
+            if (*endptr == '\0') {
+                return max_size;
+            }
+        }
+        return 0;
+    }
     void SetUp() override {
         test::SetUp();
-        this->pool = makePool();
+        auto [pool_ops, pool_params_create, pool_params_destroy, provider_ops,
+              provider_params_create, provider_params_destroy, accessor] =
+            this->GetParam();
+        poolOps = pool_ops;
+        poolParamsCreate = pool_params_create;
+        poolParamsDestroy = pool_params_destroy;
+        providerOps = provider_ops;
+        providerParamsCreate = provider_params_create;
+        providerParamsDestroy = provider_params_destroy;
+        memAccessor = accessor;
+        openedIpcCacheSize = getOpenedIpcCacheSize();
     }
 
     void TearDown() override { test::TearDown(); }
 
-    umf::pool_unique_handle_t makePool() {
+    umf_test::pool_unique_handle_t makePool() {
         // TODO: The function is similar to poolCreateExt function
         //       from memoryPool.hpp
-        umf_memory_provider_handle_t hProvider;
-        umf_memory_pool_handle_t hPool;
-        auto [pool_ops, pool_params, provider_ops, provider_params, accessor] =
-            this->GetParam();
+        umf_memory_provider_handle_t hProvider = NULL;
+        umf_memory_pool_handle_t hPool = NULL;
+
+        void *providerParams = nullptr;
+        if (providerParamsCreate) {
+            providerParams = providerParamsCreate();
+        }
 
         auto ret =
-            umfMemoryProviderCreate(provider_ops, provider_params, &hProvider);
+            umfMemoryProviderCreate(providerOps, providerParams, &hProvider);
         EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
+        if (providerParamsDestroy) {
+            providerParamsDestroy(providerParams);
+        }
+
         auto trace = [](void *trace_context, const char *name) {
             stats_type *stat = static_cast<stats_type *>(trace_context);
-            if (std::strcmp(name, "get_ipc_handle") == 0) {
+            if (std::strcmp(name, "alloc") == 0) {
+                ++stat->allocCount;
+            } else if (std::strcmp(name, "get_ipc_handle") == 0) {
                 ++stat->getCount;
             } else if (std::strcmp(name, "put_ipc_handle") == 0) {
                 ++stat->putCount;
@@ -88,40 +134,363 @@ struct umfIpcTest : umf_test::test,
         umf_memory_provider_handle_t hTraceProvider =
             traceProviderCreate(hProvider, true, (void *)&stat, trace);
 
-        ret = umfPoolCreate(pool_ops, hTraceProvider, pool_params,
+        void *poolParams = nullptr;
+        if (poolParamsCreate) {
+            poolParams = poolParamsCreate();
+        }
+
+        ret = umfPoolCreate(poolOps, hTraceProvider, poolParams,
                             UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &hPool);
         EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
-        memAccessor = accessor;
+        if (poolParamsDestroy) {
+            poolParamsDestroy(poolParams);
+        }
 
-        return umf::pool_unique_handle_t(hPool, &umfPoolDestroy);
+        return umf_test::pool_unique_handle_t(hPool, &umfPoolDestroy);
     }
 
     struct stats_type {
+        std::atomic<size_t> allocCount;
         std::atomic<size_t> getCount;
         std::atomic<size_t> putCount;
         std::atomic<size_t> openCount;
         std::atomic<size_t> closeCount;
 
-        stats_type() : getCount(0), putCount(0), openCount(0), closeCount(0) {}
+        stats_type()
+            : allocCount(0), getCount(0), putCount(0), openCount(0),
+              closeCount(0) {}
     };
 
-    umf::pool_unique_handle_t pool;
     static constexpr int NTHREADS = 10;
     stats_type stat;
     MemoryAccessor *memAccessor = nullptr;
+
+    const umf_memory_pool_ops_t *poolOps = nullptr;
+    pfnPoolParamsCreate poolParamsCreate = nullptr;
+    pfnPoolParamsDestroy poolParamsDestroy = nullptr;
+
+    const umf_memory_provider_ops_t *providerOps = nullptr;
+    pfnProviderParamsCreate providerParamsCreate = nullptr;
+    pfnProviderParamsDestroy providerParamsDestroy = nullptr;
+    size_t openedIpcCacheSize = 0;
+
+    void concurrentGetConcurrentPutHandles(bool shuffle) {
+        std::vector<void *> ptrs;
+        constexpr size_t ALLOC_SIZE = 100;
+        constexpr size_t NUM_POINTERS = 100;
+        umf_test::pool_unique_handle_t pool = makePool();
+        ASSERT_NE(pool.get(), nullptr);
+
+        for (size_t i = 0; i < NUM_POINTERS; ++i) {
+            void *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);
+            EXPECT_NE(ptr, nullptr);
+            ptrs.push_back(ptr);
+        }
+
+        std::array<std::vector<umf_ipc_handle_t>, NTHREADS> ipcHandles;
+
+        umf_test::syncthreads_barrier syncthreads(NTHREADS);
+
+        auto getHandlesFn = [shuffle, &ipcHandles, &ptrs,
+                             &syncthreads](size_t tid) {
+            // Each thread gets a copy of the pointers to shuffle them
+            std::vector<void *> localPtrs = ptrs;
+            if (shuffle) {
+                std::random_device rd;
+                std::mt19937 g(rd());
+                std::shuffle(localPtrs.begin(), localPtrs.end(), g);
+            }
+            syncthreads();
+            for (void *ptr : localPtrs) {
+                umf_ipc_handle_t ipcHandle;
+                size_t handleSize;
+                umf_result_t ret =
+                    umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
+                ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+                ipcHandles[tid].push_back(ipcHandle);
+            }
+        };
+
+        umf_test::parallel_exec(NTHREADS, getHandlesFn);
+
+        auto putHandlesFn = [&ipcHandles, &syncthreads](size_t tid) {
+            syncthreads();
+            for (umf_ipc_handle_t ipcHandle : ipcHandles[tid]) {
+                umf_result_t ret = umfPutIPCHandle(ipcHandle);
+                EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+            }
+        };
+
+        umf_test::parallel_exec(NTHREADS, putHandlesFn);
+
+        for (void *ptr : ptrs) {
+            umf_result_t ret = umfPoolFree(pool.get(), ptr);
+            EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        }
+
+        pool.reset(nullptr);
+        EXPECT_EQ(stat.putCount, stat.getCount);
+    }
+
+    void concurrentGetPutHandles(bool shuffle) {
+        std::vector<void *> ptrs;
+        constexpr size_t ALLOC_SIZE = 100;
+        constexpr size_t NUM_POINTERS = 100;
+        umf_test::pool_unique_handle_t pool = makePool();
+        ASSERT_NE(pool.get(), nullptr);
+
+        for (size_t i = 0; i < NUM_POINTERS; ++i) {
+            void *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);
+            EXPECT_NE(ptr, nullptr);
+            ptrs.push_back(ptr);
+        }
+
+        umf_test::syncthreads_barrier syncthreads(NTHREADS);
+
+        auto getPutHandlesFn = [shuffle, &ptrs, &syncthreads](size_t) {
+            // Each thread gets a copy of the pointers to shuffle them
+            std::vector<void *> localPtrs = ptrs;
+            if (shuffle) {
+                std::random_device rd;
+                std::mt19937 g(rd());
+                std::shuffle(localPtrs.begin(), localPtrs.end(), g);
+            }
+            syncthreads();
+            for (void *ptr : localPtrs) {
+                umf_ipc_handle_t ipcHandle;
+                size_t handleSize;
+                umf_result_t ret =
+                    umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
+                ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+                ret = umfPutIPCHandle(ipcHandle);
+                EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+            }
+        };
+
+        umf_test::parallel_exec(NTHREADS, getPutHandlesFn);
+
+        for (void *ptr : ptrs) {
+            umf_result_t ret = umfPoolFree(pool.get(), ptr);
+            EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        }
+
+        pool.reset(nullptr);
+        EXPECT_EQ(stat.putCount, stat.getCount);
+    }
+
+    void concurrentOpenConcurrentCloseHandles(bool shuffle) {
+        umf_result_t ret;
+        std::vector<void *> ptrs;
+        constexpr size_t ALLOC_SIZE = 100;
+        constexpr size_t NUM_POINTERS = 100;
+        umf_test::pool_unique_handle_t pool = makePool();
+        ASSERT_NE(pool.get(), nullptr);
+
+        for (size_t i = 0; i < NUM_POINTERS; ++i) {
+            void *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);
+            EXPECT_NE(ptr, nullptr);
+            ptrs.push_back(ptr);
+        }
+
+        std::vector<umf_ipc_handle_t> ipcHandles;
+        for (size_t i = 0; i < NUM_POINTERS; ++i) {
+            umf_ipc_handle_t ipcHandle;
+            size_t handleSize;
+            ret = umfGetIPCHandle(ptrs[i], &ipcHandle, &handleSize);
+            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+            ipcHandles.push_back(ipcHandle);
+        }
+
+        std::array<std::vector<void *>, NTHREADS> openedIpcHandles;
+        umf_ipc_handler_handle_t ipcHandler = nullptr;
+        ret = umfPoolGetIPCHandler(pool.get(), &ipcHandler);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ipcHandler, nullptr);
+
+        umf_test::syncthreads_barrier syncthreads(NTHREADS);
+
+        auto openHandlesFn = [shuffle, &ipcHandles, &openedIpcHandles,
+                              &syncthreads, ipcHandler](size_t tid) {
+            // Each thread gets a copy of the pointers to shuffle them
+            std::vector<umf_ipc_handle_t> localIpcHandles = ipcHandles;
+            if (shuffle) {
+                std::random_device rd;
+                std::mt19937 g(rd());
+                std::shuffle(localIpcHandles.begin(), localIpcHandles.end(), g);
+            }
+            syncthreads();
+            for (auto ipcHandle : localIpcHandles) {
+                void *ptr;
+                umf_result_t ret =
+                    umfOpenIPCHandle(ipcHandler, ipcHandle, &ptr);
+                ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+                openedIpcHandles[tid].push_back(ptr);
+            }
+        };
+
+        umf_test::parallel_exec(NTHREADS, openHandlesFn);
+
+        auto closeHandlesFn = [&openedIpcHandles, &syncthreads](size_t tid) {
+            syncthreads();
+            for (void *ptr : openedIpcHandles[tid]) {
+                umf_result_t ret = umfCloseIPCHandle(ptr);
+                EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+            }
+        };
+
+        umf_test::parallel_exec(NTHREADS, closeHandlesFn);
+
+        for (auto ipcHandle : ipcHandles) {
+            ret = umfPutIPCHandle(ipcHandle);
+            EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        }
+
+        for (void *ptr : ptrs) {
+            ret = umfPoolFree(pool.get(), ptr);
+            EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        }
+
+        pool.reset(nullptr);
+        EXPECT_EQ(stat.getCount, stat.allocCount);
+        EXPECT_EQ(stat.putCount, stat.getCount);
+        EXPECT_EQ(stat.openCount, stat.allocCount);
+        EXPECT_EQ(stat.openCount, stat.closeCount);
+    }
+
+    void concurrentOpenCloseHandles(bool shuffle) {
+        umf_result_t ret;
+        std::vector<void *> ptrs;
+        constexpr size_t ALLOC_SIZE = 100;
+        constexpr size_t NUM_POINTERS = 100;
+        umf_test::pool_unique_handle_t pool = makePool();
+        ASSERT_NE(pool.get(), nullptr);
+
+        for (size_t i = 0; i < NUM_POINTERS; ++i) {
+            void *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);
+            EXPECT_NE(ptr, nullptr);
+            ptrs.push_back(ptr);
+        }
+
+        std::vector<umf_ipc_handle_t> ipcHandles;
+        for (size_t i = 0; i < NUM_POINTERS; ++i) {
+            umf_ipc_handle_t ipcHandle;
+            size_t handleSize;
+            ret = umfGetIPCHandle(ptrs[i], &ipcHandle, &handleSize);
+            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+            ipcHandles.push_back(ipcHandle);
+        }
+
+        umf_ipc_handler_handle_t ipcHandler = nullptr;
+        ret = umfPoolGetIPCHandler(pool.get(), &ipcHandler);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ipcHandler, nullptr);
+
+        umf_test::syncthreads_barrier syncthreads(NTHREADS);
+
+        auto openCloseHandlesFn = [shuffle, &ipcHandles, &syncthreads,
+                                   ipcHandler](size_t) {
+            // Each thread gets a copy of the pointers to shuffle them
+            std::vector<umf_ipc_handle_t> localIpcHandles = ipcHandles;
+            if (shuffle) {
+                std::random_device rd;
+                std::mt19937 g(rd());
+                std::shuffle(localIpcHandles.begin(), localIpcHandles.end(), g);
+            }
+            syncthreads();
+            for (auto ipcHandle : localIpcHandles) {
+                void *ptr;
+                umf_result_t ret =
+                    umfOpenIPCHandle(ipcHandler, ipcHandle, &ptr);
+                ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+                ret = umfCloseIPCHandle(ptr);
+                EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+            }
+        };
+
+        umf_test::parallel_exec(NTHREADS, openCloseHandlesFn);
+
+        for (auto ipcHandle : ipcHandles) {
+            ret = umfPutIPCHandle(ipcHandle);
+            EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        }
+
+        for (void *ptr : ptrs) {
+            ret = umfPoolFree(pool.get(), ptr);
+            EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        }
+
+        pool.reset(nullptr);
+        EXPECT_EQ(stat.getCount, stat.allocCount);
+        EXPECT_EQ(stat.putCount, stat.getCount);
+        if (openedIpcCacheSize == 0) {
+            EXPECT_EQ(stat.openCount, stat.allocCount);
+        }
+        EXPECT_EQ(stat.openCount, stat.closeCount);
+    }
 };
 
 TEST_P(umfIpcTest, GetIPCHandleSize) {
     size_t size = 0;
+    umf_test::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
+
     umf_result_t ret = umfPoolGetIPCHandleSize(pool.get(), &size);
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
-    EXPECT_GT(size, 0);
+    EXPECT_GT(size, (size_t)0);
+}
+
+TEST_P(umfIpcTest, GetIPCHandleSizeInvalidArgs) {
+    size_t size = 0;
+    umf_result_t ret = umfPoolGetIPCHandleSize(nullptr, &size);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_test::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
+
+    ret = umfPoolGetIPCHandleSize(pool.get(), nullptr);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(umfIpcTest, GetIPCHandleInvalidArgs) {
+    constexpr size_t SIZE = 100;
+    umf_ipc_handle_t ipcHandle = nullptr;
+    size_t handleSize = 0;
+    umf_result_t ret = umfGetIPCHandle(nullptr, &ipcHandle, &handleSize);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    void *ptr = (void *)0xBAD;
+    ret = umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_test::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
+
+    ptr = umfPoolMalloc(pool.get(), SIZE);
+    EXPECT_NE(ptr, nullptr);
+
+    ret = umfGetIPCHandle(ptr, nullptr, &handleSize);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfGetIPCHandle(ptr, &ipcHandle, nullptr);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfFree(ptr);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(umfIpcTest, CloseIPCHandleInvalidPtr) {
+    int local_var;
+    auto ret = umfCloseIPCHandle(&local_var);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
 
 TEST_P(umfIpcTest, BasicFlow) {
     constexpr size_t SIZE = 100;
     std::vector<int> expected_data(SIZE);
+    umf_test::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
+
     int *ptr = (int *)umfPoolMalloc(pool.get(), SIZE * sizeof(int));
     EXPECT_NE(ptr, nullptr);
 
@@ -138,12 +507,17 @@ TEST_P(umfIpcTest, BasicFlow) {
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_EQ(handleFullSize, handleHalfSize);
 
+    umf_ipc_handler_handle_t ipcHandler = nullptr;
+    ret = umfPoolGetIPCHandler(pool.get(), &ipcHandler);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ipcHandler, nullptr);
+
     void *fullArray = nullptr;
-    ret = umfOpenIPCHandle(pool.get(), ipcHandleFull, &fullArray);
+    ret = umfOpenIPCHandle(ipcHandler, ipcHandleFull, &fullArray);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
     void *halfArray = nullptr;
-    ret = umfOpenIPCHandle(pool.get(), ipcHandleHalf, &halfArray);
+    ret = umfOpenIPCHandle(ipcHandler, ipcHandleHalf, &halfArray);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
     std::vector<int> actual_data(SIZE);
@@ -172,116 +546,236 @@ TEST_P(umfIpcTest, BasicFlow) {
     ret = umfPoolFree(pool.get(), ptr);
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    EXPECT_EQ(stat.getCount, 1);
+    pool.reset(nullptr);
+    EXPECT_EQ(stat.getCount, (size_t)1);
     EXPECT_EQ(stat.putCount, stat.getCount);
-    // TODO: enale check below once cache for open IPC handles is implemented
-    // EXPECT_EQ(stat.openCount, 1);
+    EXPECT_EQ(stat.openCount, (size_t)1);
     EXPECT_EQ(stat.closeCount, stat.openCount);
 }
 
-TEST_P(umfIpcTest, ConcurrentGetPutHandles) {
-    std::vector<void *> ptrs;
-    constexpr size_t ALLOC_SIZE = 100;
-    constexpr size_t NUM_POINTERS = 100;
-    for (size_t i = 0; i < NUM_POINTERS; ++i) {
-        void *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);
-        EXPECT_NE(ptr, nullptr);
-        ptrs.push_back(ptr);
-    }
+TEST_P(umfIpcTest, AllocFreeAllocTest) {
+    constexpr size_t SIZE = 64 * 1024;
+    umf_test::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
 
-    std::array<std::vector<umf_ipc_handle_t>, NTHREADS> ipcHandles;
+    umf_ipc_handler_handle_t ipcHandler = nullptr;
 
-    umf_test::syncthreads_barrier syncthreads(NTHREADS);
+    umf_result_t ret = umfPoolGetIPCHandler(pool.get(), &ipcHandler);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ipcHandler, nullptr);
 
-    auto getHandlesFn = [&ipcHandles, &ptrs, &syncthreads](size_t tid) {
-        syncthreads();
-        for (void *ptr : ptrs) {
-            umf_ipc_handle_t ipcHandle;
-            size_t handleSize;
-            umf_result_t ret = umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
-            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-            ipcHandles[tid].push_back(ipcHandle);
-        }
-    };
+    void *ptr = umfPoolMalloc(pool.get(), SIZE);
+    EXPECT_NE(ptr, nullptr);
 
-    umf_test::parallel_exec(NTHREADS, getHandlesFn);
+    umf_ipc_handle_t ipcHandle = nullptr;
+    size_t handleSize = 0;
+    ret = umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    auto putHandlesFn = [&ipcHandles, &syncthreads](size_t tid) {
-        syncthreads();
-        for (umf_ipc_handle_t ipcHandle : ipcHandles[tid]) {
-            umf_result_t ret = umfPutIPCHandle(ipcHandle);
-            EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
-        }
-    };
+    void *opened_ptr = nullptr;
+    ret = umfOpenIPCHandle(ipcHandler, ipcHandle, &opened_ptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    umf_test::parallel_exec(NTHREADS, putHandlesFn);
+    ret = umfCloseIPCHandle(opened_ptr);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    for (void *ptr : ptrs) {
-        umf_result_t ret = umfPoolFree(pool.get(), ptr);
-        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
-    }
+    ret = umfPutIPCHandle(ipcHandle);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfPoolFree(pool.get(), ptr);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ptr = umfPoolMalloc(pool.get(), SIZE);
+    ASSERT_NE(ptr, nullptr);
+
+    // test if the allocated memory is usable - fill it with the 0xAB pattern.
+    const uint32_t pattern = 0xAB;
+    memAccessor->fill(ptr, SIZE, &pattern, sizeof(pattern));
+
+    ret = umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfOpenIPCHandle(ipcHandler, ipcHandle, &opened_ptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    EXPECT_GE(stat.getCount, NUM_POINTERS);
-    EXPECT_LE(stat.getCount, NUM_POINTERS * NTHREADS);
+    ret = umfCloseIPCHandle(opened_ptr);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfPutIPCHandle(ipcHandle);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfPoolFree(pool.get(), ptr);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    pool.reset(nullptr);
+    EXPECT_EQ(stat.getCount, stat.putCount);
+    EXPECT_EQ(stat.openCount, stat.getCount);
+    EXPECT_EQ(stat.openCount, stat.closeCount);
+}
+
+TEST_P(umfIpcTest, openInTwoIpcHandlers) {
+    constexpr size_t SIZE = 100;
+    std::vector<int> expected_data(SIZE);
+    umf_test::pool_unique_handle_t pool1 = makePool();
+    ASSERT_NE(pool1.get(), nullptr);
+    umf_test::pool_unique_handle_t pool2 = makePool();
+    ASSERT_NE(pool2.get(), nullptr);
+    umf_ipc_handler_handle_t ipcHandler1 = nullptr;
+    umf_ipc_handler_handle_t ipcHandler2 = nullptr;
+
+    umf_result_t ret = umfPoolGetIPCHandler(pool1.get(), &ipcHandler1);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ipcHandler1, nullptr);
+
+    ret = umfPoolGetIPCHandler(pool2.get(), &ipcHandler2);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ipcHandler2, nullptr);
+
+    void *ptr = umfPoolMalloc(pool1.get(), sizeof(expected_data[0]) * SIZE);
+    EXPECT_NE(ptr, nullptr);
+
+    std::iota(expected_data.begin(), expected_data.end(), 0);
+    memAccessor->copy(ptr, expected_data.data(), SIZE * sizeof(int));
+
+    umf_ipc_handle_t ipcHandle = nullptr;
+    size_t handleSize = 0;
+    ret = umfGetIPCHandle(ptr, &ipcHandle, &handleSize);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    void *openedPtr1 = nullptr;
+    ret = umfOpenIPCHandle(ipcHandler1, ipcHandle, &openedPtr1);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    void *openedPtr2 = nullptr;
+    ret = umfOpenIPCHandle(ipcHandler2, ipcHandle, &openedPtr2);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfPutIPCHandle(ipcHandle);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    std::vector<int> actual_data(SIZE);
+    memAccessor->copy(actual_data.data(), openedPtr1, SIZE * sizeof(int));
+    ASSERT_TRUE(std::equal(expected_data.begin(), expected_data.end(),
+                           actual_data.begin()));
+
+    ret = umfCloseIPCHandle(openedPtr1);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    memAccessor->copy(actual_data.data(), openedPtr2, SIZE * sizeof(int));
+    ASSERT_TRUE(std::equal(expected_data.begin(), expected_data.end(),
+                           actual_data.begin()));
+
+    ret = umfCloseIPCHandle(openedPtr2);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfPoolFree(pool1.get(), ptr);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    pool1.reset(nullptr);
+    pool2.reset(nullptr);
+    EXPECT_EQ(stat.getCount, (size_t)1);
     EXPECT_EQ(stat.putCount, stat.getCount);
+    EXPECT_EQ(stat.openCount, (size_t)2);
+    EXPECT_EQ(stat.closeCount, stat.openCount);
+}
+
+TEST_P(umfIpcTest, ConcurrentGetConcurrentPutHandles) {
+    concurrentGetConcurrentPutHandles(false);
+}
+
+TEST_P(umfIpcTest, ConcurrentGetConcurrentPutHandlesShuffled) {
+    concurrentGetConcurrentPutHandles(true);
+}
+
+TEST_P(umfIpcTest, ConcurrentGetPutHandles) { concurrentGetPutHandles(false); }
+
+TEST_P(umfIpcTest, ConcurrentGetPutHandlesShuffled) {
+    concurrentGetPutHandles(true);
+}
+
+TEST_P(umfIpcTest, ConcurrentOpenConcurrentCloseHandles) {
+    concurrentOpenConcurrentCloseHandles(false);
+}
+
+TEST_P(umfIpcTest, ConcurrentOpenConcurrentCloseHandlesShuffled) {
+    concurrentOpenConcurrentCloseHandles(true);
 }
 
 TEST_P(umfIpcTest, ConcurrentOpenCloseHandles) {
-    std::vector<void *> ptrs;
-    constexpr size_t ALLOC_SIZE = 100;
-    constexpr size_t NUM_POINTERS = 100;
-    for (size_t i = 0; i < NUM_POINTERS; ++i) {
-        void *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);
-        EXPECT_NE(ptr, nullptr);
-        ptrs.push_back(ptr);
+    concurrentOpenCloseHandles(false);
+}
+
+TEST_P(umfIpcTest, ConcurrentOpenCloseHandlesShuffled) {
+    concurrentOpenCloseHandles(true);
+}
+
+TEST_P(umfIpcTest, ConcurrentDestroyIpcHandlers) {
+    constexpr size_t SIZE = 100;
+    constexpr size_t NUM_ALLOCS = 100;
+    constexpr size_t NUM_POOLS = 10;
+    void *ptrs[NUM_ALLOCS];
+    void *openedPtrs[NUM_POOLS][NUM_ALLOCS];
+    std::vector<umf_test::pool_unique_handle_t> consumerPools;
+    umf_test::pool_unique_handle_t producerPool = makePool();
+    ASSERT_NE(producerPool.get(), nullptr);
+
+    for (size_t i = 0; i < NUM_POOLS; ++i) {
+        consumerPools.push_back(makePool());
+        ASSERT_NE(consumerPools[i].get(), nullptr);
     }
 
-    std::array<umf_ipc_handle_t, NUM_POINTERS> ipcHandles;
-    for (size_t i = 0; i < NUM_POINTERS; ++i) {
-        umf_ipc_handle_t ipcHandle;
-        size_t handleSize;
-        umf_result_t ret = umfGetIPCHandle(ptrs[i], &ipcHandle, &handleSize);
-        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-        ipcHandles[i] = ipcHandle;
+    for (size_t i = 0; i < NUM_ALLOCS; ++i) {
+        void *ptr = umfPoolMalloc(producerPool.get(), SIZE);
+        ASSERT_NE(ptr, nullptr);
+        ptrs[i] = ptr;
     }
 
-    std::array<std::vector<void *>, NTHREADS> openedIpcHandles;
+    for (size_t i = 0; i < NUM_ALLOCS; ++i) {
+        umf_ipc_handle_t ipcHandle = nullptr;
+        size_t handleSize = 0;
+        umf_result_t ret = umfGetIPCHandle(ptrs[i], &ipcHandle, &handleSize);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    umf_test::syncthreads_barrier syncthreads(NTHREADS);
+        for (size_t poolId = 0; poolId < NUM_POOLS; poolId++) {
+            void *ptr = nullptr;
+            umf_ipc_handler_handle_t ipcHandler = nullptr;
+            ret =
+                umfPoolGetIPCHandler(consumerPools[poolId].get(), &ipcHandler);
+            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+            ASSERT_NE(ipcHandler, nullptr);
 
-    auto openHandlesFn = [this, &ipcHandles, &openedIpcHandles,
-                          &syncthreads](size_t tid) {
-        syncthreads();
-        for (auto ipcHandle : ipcHandles) {
-            void *ptr;
-            umf_result_t ret = umfOpenIPCHandle(pool.get(), ipcHandle, &ptr);
+            ret = umfOpenIPCHandle(ipcHandler, ipcHandle, &ptr);
             ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-            openedIpcHandles[tid].push_back(ptr);
+            openedPtrs[poolId][i] = ptr;
         }
-    };
 
-    umf_test::parallel_exec(NTHREADS, openHandlesFn);
+        ret = umfPutIPCHandle(ipcHandle);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    }
 
-    auto closeHandlesFn = [&openedIpcHandles, &syncthreads](size_t tid) {
-        syncthreads();
-        for (void *ptr : openedIpcHandles[tid]) {
-            umf_result_t ret = umfCloseIPCHandle(ptr);
+    for (size_t poolId = 0; poolId < NUM_POOLS; poolId++) {
+        for (size_t i = 0; i < NUM_ALLOCS; ++i) {
+            umf_result_t ret = umfCloseIPCHandle(openedPtrs[poolId][i]);
             EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
         }
-    };
-
-    umf_test::parallel_exec(NTHREADS, closeHandlesFn);
-
-    for (auto ipcHandle : ipcHandles) {
-        umf_result_t ret = umfPutIPCHandle(ipcHandle);
-        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
     }
 
-    for (void *ptr : ptrs) {
-        umf_result_t ret = umfPoolFree(pool.get(), ptr);
+    for (size_t i = 0; i < NUM_ALLOCS; ++i) {
+        umf_result_t ret = umfFree(ptrs[i]);
         EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
     }
 
+    // Destroy pools in parallel to cause IPC cache cleanup in parallel.
+    umf_test::syncthreads_barrier syncthreads(NUM_POOLS);
+    auto poolDestroyFn = [&consumerPools, &syncthreads](size_t tid) {
+        syncthreads();
+        consumerPools[tid].reset(nullptr);
+    };
+    umf_test::parallel_exec(NUM_POOLS, poolDestroyFn);
+
+    producerPool.reset(nullptr);
+
+    EXPECT_EQ(stat.putCount, stat.getCount);
     EXPECT_EQ(stat.openCount, stat.closeCount);
 }
 
diff --git a/test/ipc_devdax_prov.sh b/test/ipc_devdax_prov.sh
new file mode 100755
index 000000000..43f177c71
--- /dev/null
+++ b/test/ipc_devdax_prov.sh
@@ -0,0 +1,34 @@
+#
+# 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
+#
+
+#!/bin/bash
+
+set -e
+
+if [ "$UMF_TESTS_DEVDAX_PATH" = "" ]; then
+	echo "Test skipped, UMF_TESTS_DEVDAX_PATH is not set"
+	exit 0
+fi
+
+if [ "$UMF_TESTS_DEVDAX_SIZE" = "" ]; then
+	echo "Test skipped, UMF_TESTS_DEVDAX_SIZE is not set"
+	exit 0
+fi
+
+# port should be a number from the range <1024, 65535>
+PORT=$(( 1024 + ( $$ % ( 65535 - 1024 ))))
+
+UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
+
+echo "Starting ipc_devdax_prov CONSUMER on port $PORT ..."
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_devdax_prov_consumer $PORT &
+
+echo "Waiting 1 sec ..."
+sleep 1
+
+echo "Starting ipc_devdax_prov PRODUCER on port $PORT ..."
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_devdax_prov_producer $PORT
diff --git a/test/ipc_devdax_prov_consumer.c b/test/ipc_devdax_prov_consumer.c
new file mode 100644
index 000000000..286b6de78
--- /dev/null
+++ b/test/ipc_devdax_prov_consumer.c
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <umf/providers/provider_devdax_memory.h>
+
+#include "ipc_common.h"
+#include "ipc_os_prov_common.h"
+
+int main(int argc, char *argv[]) {
+    if (argc < 2) {
+        fprintf(stderr, "usage: %s <port>\n", argv[0]);
+        return -1;
+    }
+
+    int ret = 0;
+    int port = atoi(argv[1]);
+
+    char *path = getenv("UMF_TESTS_DEVDAX_PATH");
+    if (path == NULL || path[0] == 0) {
+        fprintf(stderr, "Test skipped, UMF_TESTS_DEVDAX_PATH is not set\n");
+        return 0;
+    }
+
+    char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
+    if (size == NULL || size[0] == 0) {
+        fprintf(stderr, "Test skipped, UMF_TESTS_DEVDAX_SIZE is not set\n");
+        return 0;
+    }
+
+    umf_devdax_memory_provider_params_handle_t devdax_params = NULL;
+    umf_result_t umf_result =
+        umfDevDaxMemoryProviderParamsCreate(&devdax_params, path, atol(size));
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "[consumer] ERROR: creating DevDax Memory Provider "
+                        "params failed\n");
+        return -1;
+    }
+
+    void *pool_params = NULL;
+
+    ret = run_consumer(port, umfScalablePoolOps(), pool_params,
+                       umfDevDaxMemoryProviderOps(), devdax_params, memcopy,
+                       NULL);
+
+    umfDevDaxMemoryProviderParamsDestroy(devdax_params);
+
+    return ret;
+}
diff --git a/test/ipc_devdax_prov_producer.c b/test/ipc_devdax_prov_producer.c
new file mode 100644
index 000000000..479c1f945
--- /dev/null
+++ b/test/ipc_devdax_prov_producer.c
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <umf/providers/provider_devdax_memory.h>
+
+#include "ipc_common.h"
+#include "ipc_os_prov_common.h"
+
+int main(int argc, char *argv[]) {
+    if (argc < 2) {
+        fprintf(stderr, "usage: %s <port>\n", argv[0]);
+        return -1;
+    }
+
+    int ret = 0;
+    int port = atoi(argv[1]);
+
+    char *path = getenv("UMF_TESTS_DEVDAX_PATH");
+    if (path == NULL || path[0] == 0) {
+        fprintf(stderr, "Test skipped, UMF_TESTS_DEVDAX_PATH is not set\n");
+        return 0;
+    }
+
+    char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
+    if (size == NULL || size[0] == 0) {
+        fprintf(stderr, "Test skipped, UMF_TESTS_DEVDAX_SIZE is not set\n");
+        return 0;
+    }
+
+    umf_devdax_memory_provider_params_handle_t devdax_params = NULL;
+    umf_result_t umf_result =
+        umfDevDaxMemoryProviderParamsCreate(&devdax_params, path, atol(size));
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "[producer] ERROR: creating DevDax Memory Provider "
+                        "params failed\n");
+        return -1;
+    }
+
+    void *pool_params = NULL;
+
+    ret = run_producer(port, umfScalablePoolOps(), pool_params,
+                       umfDevDaxMemoryProviderOps(), devdax_params, memcopy,
+                       NULL);
+
+    umfDevDaxMemoryProviderParamsDestroy(devdax_params);
+
+    return ret;
+}
diff --git a/test/ipc_file_prov.sh b/test/ipc_file_prov.sh
new file mode 100755
index 000000000..ffb849f25
--- /dev/null
+++ b/test/ipc_file_prov.sh
@@ -0,0 +1,37 @@
+#
+# 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
+#
+
+#!/bin/bash
+
+set -e
+
+FILE_BASE="/tmp/umf_file_provider"
+
+# remove old SHM files (left from the previous runs, because of crashes)
+rm -f ${FILE_BASE}*
+
+FILE_NAME="${FILE_BASE}_$$"
+
+# port should be a number from the range <1024, 65535>
+PORT=$(( 1024 + ( $$ % ( 65535 - 1024 ))))
+
+UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
+
+# make sure the temp file does not exist
+rm -f ${FILE_NAME}
+
+echo "Starting ipc_file_prov CONSUMER on port $PORT ..."
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_file_prov_consumer $PORT ${FILE_NAME}_consumer &
+
+echo "Waiting 1 sec ..."
+sleep 1
+
+echo "Starting ipc_file_prov PRODUCER on port $PORT ..."
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_file_prov_producer $PORT ${FILE_NAME}_producer
+
+# remove the SHM file
+rm -f ${FILE_NAME}
diff --git a/test/ipc_file_prov_consumer.c b/test/ipc_file_prov_consumer.c
new file mode 100644
index 000000000..0c50991a9
--- /dev/null
+++ b/test/ipc_file_prov_consumer.c
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+
+#include <umf/providers/provider_file_memory.h>
+
+#include "ipc_common.h"
+#include "ipc_os_prov_common.h"
+
+int main(int argc, char *argv[]) {
+    if (argc < 3) {
+        fprintf(stderr, "usage: %s <port> <file_name>\n", argv[0]);
+        return -1;
+    }
+
+    int ret = 0;
+    int port = atoi(argv[1]);
+    char *file_name = argv[2];
+
+    umf_file_memory_provider_params_handle_t file_params = NULL;
+    umf_result_t umf_result =
+        umfFileMemoryProviderParamsCreate(&file_params, file_name);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(
+            stderr,
+            "[consumer] ERROR: creating File Memory Provider params failed\n");
+        return -1;
+    }
+
+    umf_result = umfFileMemoryProviderParamsSetVisibility(file_params,
+                                                          UMF_MEM_MAP_SHARED);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "[consumer] ERROR: setting File Memory Provider "
+                        "visibility failed\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    void *pool_params = NULL;
+
+    ret = run_consumer(port, umfScalablePoolOps(), pool_params,
+                       umfFileMemoryProviderOps(), file_params, memcopy, NULL);
+
+destroy_provider_params:
+    umfFileMemoryProviderParamsDestroy(file_params);
+
+    return ret;
+}
diff --git a/test/ipc_file_prov_fsdax.sh b/test/ipc_file_prov_fsdax.sh
new file mode 100755
index 000000000..314d0aa66
--- /dev/null
+++ b/test/ipc_file_prov_fsdax.sh
@@ -0,0 +1,43 @@
+#
+# 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
+#
+
+#!/bin/bash
+
+set -e
+
+if [ "$UMF_TESTS_FSDAX_PATH" = "" ]; then
+	echo "$0: Test skipped, UMF_TESTS_FSDAX_PATH is not set";
+	exit 0
+fi
+
+if [ "$UMF_TESTS_FSDAX_PATH_2" = "" ]; then
+	echo "$0: Test skipped, UMF_TESTS_FSDAX_PATH_2 is not set";
+	exit 0
+fi
+
+FILE_NAME="$UMF_TESTS_FSDAX_PATH"
+FILE_NAME_2="$UMF_TESTS_FSDAX_PATH_2"
+
+# port should be a number from the range <1024, 65535>
+PORT=$(( 1024 + ( $$ % ( 65535 - 1024 ))))
+
+UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
+
+# make sure the temp file does not exist
+rm -f ${FILE_NAME}
+
+echo "Starting ipc_file_prov_fsdax CONSUMER on port $PORT ..."
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_file_prov_consumer $PORT $FILE_NAME &
+
+echo "Waiting 1 sec ..."
+sleep 1
+
+echo "Starting ipc_file_prov_fsdax PRODUCER on port $PORT ..."
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_file_prov_producer $PORT $FILE_NAME_2
+
+# remove the SHM file
+rm -f ${FILE_NAME}
diff --git a/test/ipc_file_prov_producer.c b/test/ipc_file_prov_producer.c
new file mode 100644
index 000000000..c620437e0
--- /dev/null
+++ b/test/ipc_file_prov_producer.c
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+
+#include <umf/providers/provider_file_memory.h>
+
+#include "ipc_common.h"
+#include "ipc_os_prov_common.h"
+
+int main(int argc, char *argv[]) {
+    if (argc < 3) {
+        fprintf(stderr, "usage: %s <port> <file_name>\n", argv[0]);
+        return -1;
+    }
+
+    int ret = 0;
+    int port = atoi(argv[1]);
+    char *file_name = argv[2];
+
+    umf_file_memory_provider_params_handle_t file_params = NULL;
+    umf_result_t umf_result =
+        umfFileMemoryProviderParamsCreate(&file_params, file_name);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(
+            stderr,
+            "[producer] ERROR: creating File Memory Provider params failed\n");
+        return -1;
+    }
+
+    umf_result = umfFileMemoryProviderParamsSetVisibility(file_params,
+                                                          UMF_MEM_MAP_SHARED);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "[producer] ERROR: setting File Memory Provider "
+                        "visibility failed\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    void *pool_params = NULL;
+
+    ret = run_producer(port, umfScalablePoolOps(), pool_params,
+                       umfFileMemoryProviderOps(), file_params, memcopy, NULL);
+
+destroy_provider_params:
+    umfFileMemoryProviderParamsDestroy(file_params);
+
+    return ret;
+}
diff --git a/test/ipc_negative.cpp b/test/ipc_negative.cpp
new file mode 100644
index 000000000..7cbeb3668
--- /dev/null
+++ b/test/ipc_negative.cpp
@@ -0,0 +1,57 @@
+// Copyright (C) 2024-2025 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "base.hpp"
+#include "pool_null.h"
+#include "provider_null.h"
+
+#include <umf/ipc.h>
+#include <umf/memory_pool.h>
+#include <umf/memory_provider.h>
+
+#include <array>
+
+struct IpcNotSupported : umf_test::test {
+  protected:
+    void SetUp() override {
+        umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
+        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);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+        ret = umfPoolCreate(&UMF_NULL_POOL_OPS, provider, nullptr,
+                            UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &pool);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    }
+
+    void TearDown() override { umfPoolDestroy(pool); }
+
+    umf_memory_provider_handle_t provider;
+    umf_memory_pool_handle_t pool;
+};
+
+TEST_F(IpcNotSupported, GetIPCHandleSizeNotSupported) {
+    size_t size;
+    auto ret = umfPoolGetIPCHandleSize(pool, &size);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
+}
+
+TEST_F(IpcNotSupported, OpenIPCHandleNotSupported) {
+    // This data doesn't matter, as the ipc call is no-op
+    std::array<uint8_t, 128> ipc_data = {};
+    void *ptr;
+    umf_ipc_handler_handle_t ipc_handler;
+    auto ret = umfPoolGetIPCHandler(pool, &ipc_handler);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfOpenIPCHandle(ipc_handler,
+                           reinterpret_cast<umf_ipc_handle_t>(&ipc_data), &ptr);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
+}
diff --git a/test/ipc_os_prov_anon_fd.sh b/test/ipc_os_prov_anon_fd.sh
index c5738e989..4e9a0f832 100755
--- a/test/ipc_os_prov_anon_fd.sh
+++ b/test/ipc_os_prov_anon_fd.sh
@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024-2025 Intel Corporation
 #
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -12,28 +12,13 @@ set -e
 # port should be a number from the range <1024, 65535>
 PORT=$(( 1024 + ( $$ % ( 65535 - 1024 ))))
 
-# The ipc_os_prov_anon_fd example requires using pidfd_getfd(2)
-# to obtain a duplicate of another process's file descriptor.
-# Permission to duplicate another process's file descriptor
-# is governed by a ptrace access mode PTRACE_MODE_ATTACH_REALCREDS check (see ptrace(2))
-# that can be changed using the /proc/sys/kernel/yama/ptrace_scope interface.
-PTRACE_SCOPE_FILE="/proc/sys/kernel/yama/ptrace_scope"
-VAL=0
-if [ -f $PTRACE_SCOPE_FILE ]; then
-	PTRACE_SCOPE_VAL=$(cat $PTRACE_SCOPE_FILE)
-	if [ $PTRACE_SCOPE_VAL -ne $VAL ]; then
-		echo "SKIP: ptrace_scope is not set to 0 (classic ptrace permissions) - skipping the test"
-		exit 125 # skip code defined in CMakeLists.txt
-	fi
-fi
-
 UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
 
 echo "Starting ipc_os_prov_anon_fd CONSUMER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_os_prov_consumer $PORT &
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_os_prov_consumer $PORT &
 
 echo "Waiting 1 sec ..."
 sleep 1
 
 echo "Starting ipc_os_prov_anon_fd PRODUCER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_os_prov_producer $PORT
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_os_prov_producer $PORT
diff --git a/test/ipc_os_prov_consumer.c b/test/ipc_os_prov_consumer.c
index 7df1e7049..f3f8d0090 100644
--- a/test/ipc_os_prov_consumer.c
+++ b/test/ipc_os_prov_consumer.c
@@ -19,16 +19,44 @@ int main(int argc, char *argv[]) {
         return -1;
     }
 
+    int ret = 0;
     int port = atoi(argv[1]);
 
-    umf_os_memory_provider_params_t os_params;
+    umf_os_memory_provider_params_handle_t os_params = NULL;
+
+    umf_result_t umf_result = umfOsMemoryProviderParamsCreate(&os_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(
+            stderr,
+            "[consumer] ERROR: creating OS memory provider params failed\n");
+        return -1;
+    }
+
+    umf_result =
+        umfOsMemoryProviderParamsSetVisibility(os_params, UMF_MEM_MAP_SHARED);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "[consumer] ERROR: setting visibility mode failed\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
 
-    os_params = umfOsMemoryProviderParamsDefault();
-    os_params.visibility = UMF_MEM_MAP_SHARED;
     if (argc >= 3) {
-        os_params.shm_name = argv[2];
+        umf_result = umfOsMemoryProviderParamsSetShmName(os_params, argv[2]);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            fprintf(stderr,
+                    "[consumer] ERROR: setting shared memory name failed\n");
+            ret = -1;
+            goto destroy_provider_params;
+        }
     }
 
-    return run_consumer(port, umfOsMemoryProviderOps(), &os_params, memcopy,
-                        NULL);
+    void *pool_params = NULL;
+
+    ret = run_consumer(port, umfScalablePoolOps(), pool_params,
+                       umfOsMemoryProviderOps(), os_params, memcopy, NULL);
+
+destroy_provider_params:
+    umfOsMemoryProviderParamsDestroy(os_params);
+
+    return ret;
 }
diff --git a/test/ipc_os_prov_producer.c b/test/ipc_os_prov_producer.c
index a9a2ab56c..890f1eb3e 100644
--- a/test/ipc_os_prov_producer.c
+++ b/test/ipc_os_prov_producer.c
@@ -19,16 +19,44 @@ int main(int argc, char *argv[]) {
         return -1;
     }
 
+    int ret = 0;
     int port = atoi(argv[1]);
 
-    umf_os_memory_provider_params_t os_params;
+    umf_os_memory_provider_params_handle_t os_params = NULL;
+
+    umf_result_t umf_result = umfOsMemoryProviderParamsCreate(&os_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(
+            stderr,
+            "[producer] ERROR: creating OS memory provider params failed\n");
+        return -1;
+    }
+
+    umf_result =
+        umfOsMemoryProviderParamsSetVisibility(os_params, UMF_MEM_MAP_SHARED);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "[producer] ERROR: setting visibility mode failed\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
 
-    os_params = umfOsMemoryProviderParamsDefault();
-    os_params.visibility = UMF_MEM_MAP_SHARED;
     if (argc >= 3) {
-        os_params.shm_name = argv[2];
+        umf_result = umfOsMemoryProviderParamsSetShmName(os_params, argv[2]);
+        if (umf_result != UMF_RESULT_SUCCESS) {
+            fprintf(stderr,
+                    "[producer] ERROR: setting shared memory name failed\n");
+            ret = -1;
+            goto destroy_provider_params;
+        }
     }
 
-    return run_producer(port, umfOsMemoryProviderOps(), &os_params, memcopy,
-                        NULL);
+    void *pool_params = NULL;
+
+    ret = run_producer(port, umfScalablePoolOps(), pool_params,
+                       umfOsMemoryProviderOps(), os_params, memcopy, NULL);
+
+destroy_provider_params:
+    umfOsMemoryProviderParamsDestroy(os_params);
+
+    return ret;
 }
diff --git a/test/ipc_os_prov_proxy.c b/test/ipc_os_prov_proxy.c
new file mode 100644
index 000000000..0a4b64442
--- /dev/null
+++ b/test/ipc_os_prov_proxy.c
@@ -0,0 +1,256 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include <dlfcn.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <umf/ipc.h>
+
+#include "ipc_common.h"
+#include "utils_load_library.h"
+
+umf_result_t (*pfnGetIPCHandle)(const void *ptr, umf_ipc_handle_t *umfIPCHandle,
+                                size_t *size);
+umf_result_t (*pfnPutIPCHandle)(umf_ipc_handle_t umfIPCHandle);
+
+// This is a test for a scenario where a user process is started using the
+// LD_PRELOAD with the UMF Proxy Lib and this process uses UMF by loading
+// libumf.so at runtime.
+// In this test, we expect that all allocations made by the process will be
+// handled by UMF in the Proxy Lib and added to the UMF tracker so that they
+// can be used later in the UMF IPC API.
+int main(int argc, char *argv[]) {
+    int ret = 0;
+    umf_result_t umf_result = UMF_RESULT_ERROR_UNKNOWN;
+    int producer_socket = -1;
+    const size_t MSG_SIZE = 2048;
+    char consumer_message[MSG_SIZE];
+
+    if (argc < 2) {
+        fprintf(stderr, "usage: %s <port> [shm_name]\n", argv[0]);
+        return -1;
+    }
+
+    int port = atoi(argv[1]);
+
+    int fd = open("/proc/self/maps", O_RDONLY);
+    if (fd == -1) {
+        return -1;
+    }
+
+    // read the "/proc/self/maps" file until the "libumf_proxy.so" of the maps
+    // is found or EOF is reached.
+    const size_t SIZE_BUF = 8192;
+    char buf[SIZE_BUF];
+    ssize_t nbytes = 1;
+    char *found = NULL;
+    while (nbytes > 0 && found == NULL) {
+        memset(buf, 0, SIZE_BUF); // erase previous data
+        nbytes = read(fd, buf, SIZE_BUF);
+        if (nbytes <= 0) {
+            break;
+        }
+        found = strstr(buf, "libumf_proxy.so");
+    }
+    (void)close(fd);
+
+    if (found == NULL) {
+        fprintf(
+            stderr,
+            "test binary not run under LD_PRELOAD with \"libumf_proxy.so\"\n");
+        return -1;
+    }
+
+    // open the UMF library and get umfGetIPCHandle() function
+    const char *umf_lib_name = "libumf.so";
+    void *umf_lib_handle = utils_open_library(umf_lib_name, 0);
+    if (umf_lib_handle == NULL) {
+        fprintf(stderr, "utils_open_library: UMF library not found (%s)\n",
+                umf_lib_name);
+        return -1;
+    }
+
+    *(void **)&pfnGetIPCHandle =
+        utils_get_symbol_addr(umf_lib_handle, "umfGetIPCHandle", umf_lib_name);
+    if (pfnGetIPCHandle == NULL) {
+        ret = -1;
+        goto err_close_lib;
+    }
+
+    *(void **)&pfnPutIPCHandle =
+        utils_get_symbol_addr(umf_lib_handle, "umfPutIPCHandle", umf_lib_name);
+    if (pfnPutIPCHandle == NULL) {
+        ret = -1;
+        goto err_close_lib;
+    }
+
+    // create simple allocation - it should be added to the UMF tracker if the
+    // process was launched under UMF Proxy Lib
+    size_t size = 2137;
+    void *ptr = malloc(size);
+    if (ptr == NULL) {
+        fprintf(stderr, "malloc() failed!\n");
+        ret = -1;
+        goto err_close_lib;
+    }
+
+    fprintf(stderr, "Allocated memory - %zu\n", size);
+    size_t val = 144;
+    size_t expected_val = val / 2;
+    *(size_t *)ptr = val;
+
+    // get IPC handle of the allocation
+    umf_ipc_handle_t ipc_handle = NULL;
+    size_t ipc_handle_size = 0;
+    umf_result_t res = pfnGetIPCHandle(ptr, &ipc_handle, &ipc_handle_size);
+    if (res != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "pfnGetIPCHandle() failed!\n");
+        ret = -1;
+        goto err_free_mem;
+    }
+
+    // check if we got valid data
+    if (ipc_handle == NULL || ipc_handle_size == 0) {
+        fprintf(stderr, "pfnGetIPCHandle() couldn't find the handle data!\n");
+        ret = -1;
+        goto err_free_mem;
+    }
+
+    fprintf(stderr, "Got IPCHandle for memory - %p | size - %zu\n",
+            (void *)ipc_handle, ipc_handle_size);
+
+    producer_socket = producer_connect(port);
+    if (producer_socket < 0) {
+        goto err_PutIPCHandle;
+    }
+
+    // send the ipc_handle_size to the consumer
+    ssize_t len =
+        send(producer_socket, &ipc_handle_size, sizeof(ipc_handle_size), 0);
+    if (len < 0) {
+        fprintf(stderr, "[producer] ERROR: unable to send the ipc_handle_size "
+                        "to the consumer\n");
+        goto err_close_producer_socket;
+    }
+
+    fprintf(stderr,
+            "[producer] Sent the size of the IPC handle (%zu) to the consumer "
+            "(sent %zu bytes)\n",
+            ipc_handle_size, len);
+
+    // zero the consumer_message buffer
+    memset(consumer_message, 0, sizeof(consumer_message));
+
+    // receive the consumer's confirmation - IPC handle size
+    len = recv(producer_socket, consumer_message, sizeof(consumer_message), 0);
+    if (len < 0) {
+        fprintf(stderr, "[producer] ERROR: error while receiving the "
+                        "confirmation from the consumer\n");
+        goto err_close_producer_socket;
+    }
+
+    size_t conf_IPC_handle_size = *(size_t *)consumer_message;
+    if (conf_IPC_handle_size == ipc_handle_size) {
+        fprintf(stderr,
+                "[producer] Received the correct confirmation (%zu) from the "
+                "consumer (%zu bytes)\n",
+                conf_IPC_handle_size, len);
+    } else {
+        fprintf(stderr,
+                "[producer] Received an INCORRECT confirmation (%zu) from the "
+                "consumer (%zu bytes)\n",
+                conf_IPC_handle_size, len);
+        goto err_close_producer_socket;
+    }
+
+    // send the ipc_handle of ipc_handle_size to the consumer
+    if (send(producer_socket, ipc_handle, ipc_handle_size, 0) < 0) {
+        fprintf(stderr, "[producer] ERROR: unable to send the ipc_handle to "
+                        "the consumer\n");
+        goto err_close_producer_socket;
+    }
+
+    fprintf(stderr,
+            "[producer] Sent the IPC handle to the consumer (%zu bytes)\n",
+            ipc_handle_size);
+
+    // zero the consumer_message buffer
+    memset(consumer_message, 0, sizeof(consumer_message));
+
+    // receive the consumer's response
+    if (recv(producer_socket, consumer_message, sizeof(consumer_message) - 1,
+             0) < 0) {
+        fprintf(
+            stderr,
+            "[producer] ERROR: error while receiving the consumer's message\n");
+        goto err_close_producer_socket;
+    }
+
+    fprintf(stderr, "[producer] Received the consumer's response: \"%s\"\n",
+            consumer_message);
+
+    if (strncmp(consumer_message, "SKIP", 5 /* length of "SKIP" + 1 */) == 0) {
+        fprintf(stderr, "[producer] SKIP: received the 'SKIP' response from "
+                        "consumer, skipping ...\n");
+        ret = 1;
+        goto err_close_producer_socket;
+    }
+
+    // read a new value - the expected correct value val / 2
+    volatile unsigned long long new_val = *(unsigned long long *)ptr;
+    if (new_val == expected_val) {
+        ret = 0; // got the correct value - success!
+        fprintf(
+            stderr,
+            "[producer] The consumer wrote the correct value (the old one / 2) "
+            "to my shared memory: %llu\n",
+            new_val);
+    } else {
+        fprintf(
+            stderr,
+            "[producer] ERROR: The consumer did NOT write the correct value "
+            "(the old one / 2 = %zu) to my shared memory: %llu\n",
+            expected_val, new_val);
+    }
+
+err_close_producer_socket:
+    close(producer_socket);
+
+err_PutIPCHandle:
+    umf_result = pfnPutIPCHandle(ipc_handle);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "[producer] ERROR: putting the IPC handle failed\n");
+    }
+
+    fprintf(stderr, "[producer] Put the IPC handle\n");
+
+    if (ret == 0) {
+        fprintf(stderr, "[producer] Shutting down (status OK) ...\n");
+    } else if (ret == 1) {
+        fprintf(stderr, "[producer] Shutting down (status SKIP) ...\n");
+        ret = 0;
+    } else {
+        fprintf(stderr, "[producer] Shutting down (status ERROR) ...\n");
+    }
+
+    return ret;
+
+err_free_mem:
+    free(ptr);
+
+err_close_lib:
+    utils_close_library(umf_lib_handle);
+
+    return ret;
+}
diff --git a/test/ipc_os_prov_proxy.sh b/test/ipc_os_prov_proxy.sh
new file mode 100755
index 000000000..9bd02dad8
--- /dev/null
+++ b/test/ipc_os_prov_proxy.sh
@@ -0,0 +1,26 @@
+#
+# 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
+#
+
+#!/bin/bash
+
+set -e
+
+UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
+UMF_PROXY_VAL="page.disposition=shared-shm"
+LD_PRELOAD_VAL="../lib/libumf_proxy.so"
+
+# port should be a number from the range <1024, 65535>
+PORT=$(( 1024 + ( $$ % ( 65535 - 1024 ))))
+
+echo "Starting CONSUMER on port $PORT ..."
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_os_prov_consumer $PORT &
+
+echo "Waiting 1 sec ..."
+sleep 1
+
+echo "Starting ipc_os_prov_proxy PRODUCER on port $PORT ..."
+LD_PRELOAD=$LD_PRELOAD_VAL UMF_LOG=$UMF_LOG_VAL UMF_PROXY=$UMF_PROXY_VAL ./test_ipc_os_prov_proxy $PORT
diff --git a/test/ipc_os_prov_shm.sh b/test/ipc_os_prov_shm.sh
index 088d77169..7bde3c613 100755
--- a/test/ipc_os_prov_shm.sh
+++ b/test/ipc_os_prov_shm.sh
@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024-2025 Intel Corporation
 #
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -20,13 +20,13 @@ UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
 rm -f /dev/shm/${SHM_NAME}
 
 echo "Starting ipc_os_prov_shm CONSUMER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_os_prov_consumer $PORT $SHM_NAME &
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_os_prov_consumer $PORT &
 
 echo "Waiting 1 sec ..."
 sleep 1
 
 echo "Starting ipc_os_prov_shm PRODUCER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_os_prov_producer $PORT $SHM_NAME
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_os_prov_producer $PORT $SHM_NAME
 
 # remove the SHM file
 rm -f /dev/shm/${SHM_NAME}
diff --git a/test/malloc_compliance_tests.cpp b/test/malloc_compliance_tests.cpp
index c3c67ae21..e59dc4f4e 100644
--- a/test/malloc_compliance_tests.cpp
+++ b/test/malloc_compliance_tests.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2023 Intel Corporation
+// Copyright (C) 2023-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -85,12 +85,11 @@ void calloc_compliance_test(umf_memory_pool_handle_t hPool) {
     // Checking that the memory returned by calloc is zero filled
     for (int i = 0; i < ITERATIONS; i++) {
         alloc_size = rand_alloc_size(MAX_ALLOC_SIZE);
-        alloc_ptr[i] = umfPoolCalloc(hPool, i + 1, alloc_size);
+        alloc_ptr[i] = umfPoolCalloc(hPool, 2, alloc_size);
 
         ASSERT_NE(alloc_ptr[i], nullptr)
             << "calloc returned NULL, couldn't allocate much memory";
-        ASSERT_NE(bufferIsFilledWithChar(alloc_ptr[i], alloc_size * (i + 1), 0),
-                  0)
+        ASSERT_NE(bufferIsFilledWithChar(alloc_ptr[i], 2 * alloc_size, 0), 0)
             << "Memory returned by calloc was not zeroed";
     }
     free_memory(hPool, alloc_ptr);
@@ -120,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 0fb2a4422..8df9735a2 100644
--- a/test/memoryPoolAPI.cpp
+++ b/test/memoryPoolAPI.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2023-2024 Intel Corporation
+// Copyright (C) 2023-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 // This file contains tests for UMF pool API
@@ -12,6 +12,7 @@
 #include "test_helpers.h"
 
 #include <umf/memory_provider.h>
+#include <umf/pools/pool_disjoint.h>
 #include <umf/pools/pool_proxy.h>
 
 #ifdef UMF_PROXY_LIB_ENABLED
@@ -41,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) {
@@ -70,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) {
@@ -124,7 +125,7 @@ TEST_P(umfPoolWithCreateFlagsTest, memoryPoolWithCustomProvider) {
             return UMF_RESULT_SUCCESS;
         }
     };
-    umf_memory_pool_ops_t pool_ops = umf::poolMakeCOps<pool, void>();
+    umf_memory_pool_ops_t pool_ops = umf_test::poolMakeCOps<pool, void>();
 
     umf_memory_pool_handle_t hPool;
     auto ret = umfPoolCreate(&pool_ops, hProvider, nullptr, flags, &hPool);
@@ -139,7 +140,8 @@ TEST_P(umfPoolWithCreateFlagsTest, memoryPoolWithCustomProvider) {
 }
 
 TEST_F(test, retrieveMemoryProvider) {
-    umf_memory_provider_handle_t provider = (umf_memory_provider_handle_t)0x1;
+    auto nullProvider = umf_test::wrapProviderUnique(nullProviderCreate());
+    umf_memory_provider_handle_t provider = nullProvider.get();
 
     auto pool =
         wrapPoolUnique(createPoolChecked(umfProxyPoolOps(), provider, nullptr));
@@ -155,7 +157,7 @@ TEST_F(test, BasicPoolByPtrTest) {
 
     umf_memory_provider_handle_t provider;
     umf_result_t ret =
-        umfMemoryProviderCreate(&MALLOC_PROVIDER_OPS, NULL, &provider);
+        umfMemoryProviderCreate(&BA_GLOBAL_PROVIDER_OPS, NULL, &provider);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     auto pool =
         wrapPoolUnique(createPoolChecked(umfProxyPoolOps(), provider, nullptr,
@@ -177,17 +179,136 @@ TEST_F(test, BasicPoolByPtrTest) {
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
+struct tagTest : umf_test::test {
+    void SetUp() override {
+        test::SetUp();
+        provider = umf_test::wrapProviderUnique(nullProviderCreate());
+        pool = umf_test::wrapPoolUnique(
+            createPoolChecked(umfProxyPoolOps(), provider.get(), nullptr));
+    }
+
+    umf_test::provider_unique_handle_t provider;
+    umf_test::pool_unique_handle_t pool;
+};
+
+TEST_F(tagTest, SetAndGet) {
+    umf_result_t ret = umfPoolSetTag(pool.get(), (void *)0x99, nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    void *tag;
+    ret = umfPoolGetTag(pool.get(), &tag);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(tag, (void *)0x99);
+
+    void *oldTag;
+    ret = umfPoolSetTag(pool.get(), (void *)0x100, &oldTag);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(oldTag, (void *)0x99);
+
+    ret = umfPoolGetTag(pool.get(), &tag);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(tag, (void *)0x100);
+}
+
+TEST_F(tagTest, SetAndGetNull) {
+    umf_result_t ret = umfPoolSetTag(pool.get(), nullptr, nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    void *tag;
+    ret = umfPoolGetTag(pool.get(), &tag);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(tag, nullptr);
+}
+
+TEST_F(tagTest, NoSetAndGet) {
+    void *tag;
+    umf_result_t ret = umfPoolGetTag(pool.get(), &tag);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(tag, nullptr);
+}
+
+TEST_F(tagTest, SetAndGetMt) {
+    static constexpr size_t NUM_THREADS = 8;
+    static constexpr size_t NUM_OPS_PER_THREAD = 16;
+
+    std::vector<std::thread> threads;
+
+    auto encodeTag = [](size_t thread, size_t op) -> void * {
+        return reinterpret_cast<void *>(thread * NUM_OPS_PER_THREAD + op);
+    };
+
+    auto decodeTag = [](void *tag) -> std::pair<size_t, size_t> {
+        auto op = reinterpret_cast<size_t>(tag) & (NUM_OPS_PER_THREAD - 1);
+        auto thread = reinterpret_cast<size_t>(tag) / NUM_OPS_PER_THREAD;
+        return {thread, op};
+    };
+
+    for (size_t i = 0; i < NUM_THREADS; i++) {
+        threads.emplace_back([this, i, encodeTag, decodeTag] {
+            for (size_t j = 0; j < NUM_OPS_PER_THREAD; j++) {
+                void *oldTag;
+                umf_result_t ret =
+                    umfPoolSetTag(pool.get(), encodeTag(i, j), &oldTag);
+                ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+                void *queriedTag;
+                ret = umfPoolGetTag(pool.get(), &queriedTag);
+                ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+                auto [t1, op1] = decodeTag(oldTag);
+                auto [t2, op2] = decodeTag(queriedTag);
+                // if the tag was set by the same thread, the op part should be the same or higher
+                ASSERT_TRUE(t1 != t2 || op2 >= op1);
+            }
+        });
+    }
+
+    for (auto &thread : threads) {
+        thread.join();
+    }
+
+    void *tag;
+    auto ret = umfPoolGetTag(pool.get(), &tag);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    auto [t, op] = decodeTag(tag);
+    ASSERT_TRUE(t < NUM_THREADS);
+    ASSERT_TRUE(op == NUM_OPS_PER_THREAD - 1);
+}
+
+TEST_F(tagTest, SetAndGetInvalidPtr) {
+    umf_result_t ret = umfPoolSetTag(pool.get(), nullptr, nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfPoolGetTag(pool.get(), nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(tagTest, SetAndGetInvalidPool) {
+    umf_result_t ret =
+        umfPoolSetTag(nullptr, reinterpret_cast<void *>(0x1), nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    void *tag;
+    ret = umfPoolGetTag(nullptr, &tag);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
 INSTANTIATE_TEST_SUITE_P(
     mallocPoolTest, umfPoolTest,
-    ::testing::Values(poolCreateExtParams{&MALLOC_POOL_OPS, nullptr,
-                                          &UMF_NULL_PROVIDER_OPS, nullptr},
-                      poolCreateExtParams{umfProxyPoolOps(), nullptr,
-                                          &MALLOC_PROVIDER_OPS, nullptr}));
+    ::testing::Values(
+        poolCreateExtParams{&MALLOC_POOL_OPS, nullptr, nullptr,
+                            &UMF_NULL_PROVIDER_OPS, nullptr, nullptr},
+        poolCreateExtParams{umfProxyPoolOps(), nullptr, nullptr,
+                            &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr},
+        poolCreateExtParams{umfDisjointPoolOps(), defaultDisjointPoolConfig,
+                            defaultDisjointPoolConfigDestroy,
+                            &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}));
 
 INSTANTIATE_TEST_SUITE_P(mallocMultiPoolTest, umfMultiPoolTest,
                          ::testing::Values(poolCreateExtParams{
-                             umfProxyPoolOps(), nullptr, &MALLOC_PROVIDER_OPS,
-                             nullptr}));
+                             umfProxyPoolOps(), nullptr, nullptr,
+                             &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}));
 
 INSTANTIATE_TEST_SUITE_P(umfPoolWithCreateFlagsTest, umfPoolWithCreateFlagsTest,
                          ::testing::Values(0,
@@ -228,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> {};
 
@@ -245,11 +385,12 @@ TEST_P(poolInitializeTest, errorPropagation) {
     struct pool : public umf_test::pool_base_t {
         umf_result_t
         initialize([[maybe_unused]] umf_memory_provider_handle_t provider,
-                   umf_result_t *errorToReturn) noexcept {
+                   const umf_result_t *errorToReturn) noexcept {
             return *errorToReturn;
         }
     };
-    umf_memory_pool_ops_t pool_ops = umf::poolMakeCOps<pool, umf_result_t>();
+    umf_memory_pool_ops_t pool_ops =
+        umf_test::poolMakeCOps<pool, umf_result_t>();
 
     umf_memory_pool_handle_t hPool;
     auto ret = umfPoolCreate(&pool_ops, hProvider, (void *)&this->GetParam(), 0,
@@ -258,7 +399,8 @@ TEST_P(poolInitializeTest, errorPropagation) {
 }
 
 TEST_F(test, retrieveMemoryProvidersError) {
-    umf_memory_provider_handle_t provider = (umf_memory_provider_handle_t)0x1;
+    auto nullProvider = umf_test::wrapProviderUnique(nullProviderCreate());
+    umf_memory_provider_handle_t provider = nullProvider.get();
 
     auto pool =
         wrapPoolUnique(createPoolChecked(umfProxyPoolOps(), provider, nullptr));
@@ -298,7 +440,7 @@ TEST_F(test, getLastFailedMemoryProvider) {
         const char *name;
     };
     umf_memory_provider_ops_t provider_ops =
-        umf::providerMakeCOps<memory_provider, char>();
+        umf_test::providerMakeCOps<memory_provider, char>();
 
     auto providerUnique1 = wrapProviderUnique(
         createProviderChecked(&provider_ops, (void *)"provider1"));
diff --git a/test/memoryProviderAPI.cpp b/test/memoryProviderAPI.cpp
index 144aa4d55..e35fc5282 100644
--- a/test/memoryProviderAPI.cpp
+++ b/test/memoryProviderAPI.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2023-2024 Intel Corporation
+// Copyright (C) 2023-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 // This file contains tests for UMF provider API
@@ -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,44 +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,
-                                                  nullptr);
+                                                  &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,
-                                          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(), nullptr, 0);
+    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(), nullptr, 0);
+    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;
@@ -75,47 +78,47 @@ 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);
 
     ret = umfMemoryProviderPurgeLazy(hProvider, nullptr, 0);
-    ASSERT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     umfMemoryProviderDestroy(hProvider);
 }
 
 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);
 
     ret = umfMemoryProviderPurgeForce(hProvider, nullptr, 0);
-    ASSERT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     umfMemoryProviderDestroy(hProvider);
 }
 
 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);
@@ -133,6 +136,44 @@ TEST_F(test, memoryProviderOpsNullAllocationSplitAllocationMergeFields) {
     umfMemoryProviderDestroy(hProvider);
 }
 
+TEST_F(test, memoryProviderOpsNullAllIPCFields) {
+    umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
+    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);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    size_t size;
+    ret = umfMemoryProviderGetIPCHandleSize(hProvider, &size);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    void *ptr = nullptr;
+    void *providerIpcData = nullptr;
+    ret = umfMemoryProviderGetIPCHandle(hProvider, ptr, size, providerIpcData);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfMemoryProviderPutIPCHandle(hProvider, providerIpcData);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfMemoryProviderOpenIPCHandle(hProvider, providerIpcData, &ptr);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfMemoryProviderCloseIPCHandle(hProvider, ptr, size);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umfMemoryProviderDestroy(hProvider);
+}
+
+TEST_F(test, memoryProviderNullDelete) {
+    auto ret = umfMemoryProviderDestroy(nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+}
+
 ////////////////// Negative test cases /////////////////
 
 TEST_F(test, memoryProviderCreateNullOps) {
@@ -197,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);
@@ -205,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);
@@ -213,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);
@@ -221,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);
@@ -229,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);
@@ -237,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);
@@ -245,10 +286,41 @@ 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);
+}
+
+TEST_F(test, memoryProviderOpsNullAllocationSplitAllocationMergeNegative) {
+    umf_memory_provider_ops_t provider_ops = UMF_NULL_PROVIDER_OPS;
     umf_memory_provider_handle_t hProvider;
+
     auto ret = umfMemoryProviderCreate(&provider_ops, nullptr, &hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfMemoryProviderAllocationSplit(hProvider, nullptr, 2 * 4096, 4096);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret =
+        umfMemoryProviderAllocationMerge(hProvider, nullptr, nullptr, 2 * 4096);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    void *lowPtr = (void *)0xBAD;
+    void *highPtr = (void *)((uintptr_t)lowPtr + 4096);
+    size_t totalSize = 0;
+    ret =
+        umfMemoryProviderAllocationMerge(hProvider, lowPtr, highPtr, totalSize);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    totalSize = 4096;
+    lowPtr = (void *)0xBAD;
+    highPtr = (void *)((uintptr_t)lowPtr + 2 * totalSize);
+    ret =
+        umfMemoryProviderAllocationMerge(hProvider, lowPtr, highPtr, totalSize);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umfMemoryProviderDestroy(hProvider);
 }
 
 struct providerInitializeTest : umf_test::test,
@@ -263,12 +335,12 @@ 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;
         }
     };
     umf_memory_provider_ops_t provider_ops =
-        umf::providerMakeCOps<provider, umf_result_t>();
+        umf_test::providerMakeCOps<provider, umf_result_t>();
 
     umf_memory_provider_handle_t hProvider;
     auto ret = umfMemoryProviderCreate(&provider_ops, (void *)&this->GetParam(),
diff --git a/test/memspaces/mempolicy.cpp b/test/memspaces/mempolicy.cpp
index 97948bfbb..2cde749be 100644
--- a/test/memspaces/mempolicy.cpp
+++ b/test/memspaces/mempolicy.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2024 Intel Corporation
+// Copyright (C) 2024-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -7,11 +7,7 @@
 #include "provider_os_memory_internal.h"
 
 os_memory_provider_t *providerGetPriv(umf_memory_provider_handle_t hProvider) {
-    // hack to have access to fields in structure defined in memory_provider.c
-    struct umf_memory_provider_t {
-        umf_memory_provider_ops_t ops;
-        void *provider_priv;
-    } *provider = (struct umf_memory_provider_t *)hProvider;
+    umf_memory_provider_t *provider = (umf_memory_provider_t *)hProvider;
     return (os_memory_provider_t *)provider->provider_priv;
 }
 
@@ -85,7 +81,8 @@ TEST_F(test, mempolicyDefaultInterleave) {
     EXPECT_EQ(ProviderInternal->numa_flags, HWLOC_MEMBIND_BYNODESET);
     EXPECT_EQ(ProviderInternal->part_size, 0);
     EXPECT_EQ(ProviderInternal->mode, UMF_NUMA_MODE_INTERLEAVE);
-    umfMemoryProviderDestroy(hProvider);
+    ret = umfMemoryProviderDestroy(hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 TEST_F(test, mempolicyInterleavePartSize) {
@@ -113,7 +110,8 @@ TEST_F(test, mempolicyInterleavePartSize) {
               HWLOC_MEMBIND_BYNODESET | HWLOC_MEMBIND_STRICT);
     EXPECT_EQ(ProviderInternal->part_size, part_size);
     EXPECT_EQ(ProviderInternal->mode, UMF_NUMA_MODE_INTERLEAVE);
-    umfMemoryProviderDestroy(hProvider);
+    ret = umfMemoryProviderDestroy(hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 TEST_F(test, mempolicyDefaultSplit) {
@@ -138,7 +136,8 @@ TEST_F(test, mempolicyDefaultSplit) {
               HWLOC_MEMBIND_BYNODESET | HWLOC_MEMBIND_STRICT);
     EXPECT_EQ(ProviderInternal->partitions_len, ProviderInternal->nodeset_len);
     EXPECT_EQ(ProviderInternal->mode, UMF_NUMA_MODE_SPLIT);
-    umfMemoryProviderDestroy(hProvider);
+    ret = umfMemoryProviderDestroy(hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 TEST_F(test, mempolicyCustomSplit) {
@@ -170,7 +169,8 @@ TEST_F(test, mempolicyCustomSplit) {
     EXPECT_EQ(ProviderInternal->partitions_weight_sum, 2);
     EXPECT_EQ(ProviderInternal->partitions[0].target,
               ProviderInternal->partitions[1].target);
-    umfMemoryProviderDestroy(hProvider);
+    ret = umfMemoryProviderDestroy(hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 TEST_F(test, mempolicySplitNegative) {
diff --git a/test/memspaces/memspace.cpp b/test/memspaces/memspace.cpp
new file mode 100644
index 000000000..412c5beb7
--- /dev/null
+++ b/test/memspaces/memspace.cpp
@@ -0,0 +1,43 @@
+// Copyright (C) 2024 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "memspace_helpers.hpp"
+
+using umf_test::test;
+
+TEST_F(test, memspaceNewInvalid) {
+    auto ret = umfMemspaceNew(NULL);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+class emptyMemspace : public testing::Test {
+  public:
+    umf_memspace_handle_t memspace;
+
+    void SetUp() override {
+        auto ret = umfMemspaceNew(&memspace);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_NE(memspace, nullptr);
+    }
+    void TearDown() override { umfMemspaceDestroy(memspace); }
+};
+
+TEST_F(emptyMemspace, basic) {
+    size_t len = umfMemspaceMemtargetNum(memspace);
+    ASSERT_EQ(len, 0);
+}
+
+TEST_F(emptyMemspace, create_pool) {
+    umf_memory_pool_handle_t pool = nullptr;
+    auto ret = umfPoolCreateFromMemspace(memspace, NULL, &pool);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(pool, nullptr);
+}
+
+TEST_F(emptyMemspace, create_provider) {
+    umf_memory_provider_handle_t provider = nullptr;
+    auto ret = umfMemoryProviderCreateFromMemspace(memspace, NULL, &provider);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(provider, nullptr);
+}
diff --git a/test/memspaces/memspace_fixtures.hpp b/test/memspaces/memspace_fixtures.hpp
index fac50b031..da174c4f1 100644
--- a/test/memspaces/memspace_fixtures.hpp
+++ b/test/memspaces/memspace_fixtures.hpp
@@ -5,6 +5,7 @@
 #ifndef UMF_TEST_MEMSPACE_FIXTURES_HPP
 #define UMF_TEST_MEMSPACE_FIXTURES_HPP
 
+#include <algorithm>
 #include <numa.h>
 #include <numaif.h>
 #include <thread>
@@ -30,7 +31,7 @@ struct numaNodesTest : ::umf_test::test {
         ::umf_test::test::SetUp();
 
         if (numa_available() == -1 || numa_all_nodes_ptr == nullptr) {
-            GTEST_FAIL() << "Failed to initialize libnuma";
+            GTEST_SKIP() << "No available NUMA support; skipped";
         }
 
         int maxNode = numa_max_node();
@@ -50,7 +51,7 @@ struct numaNodesTest : ::umf_test::test {
     unsigned long maxNodeId = 0;
 };
 
-using isQuerySupportedFunc = bool (*)(size_t);
+using isQuerySupportedFunc = void (*)(size_t);
 using memspaceGetFunc = umf_const_memspace_handle_t (*)();
 using memspaceGetParams = std::tuple<isQuerySupportedFunc, memspaceGetFunc>;
 
@@ -59,10 +60,15 @@ struct memspaceGetTest : ::numaNodesTest,
     void SetUp() override {
         ::numaNodesTest::SetUp();
 
+        if (numa_available() == -1 || numa_all_nodes_ptr == nullptr) {
+            GTEST_SKIP() << "No available NUMA support; skipped";
+        }
+
         auto [isQuerySupported, memspaceGet] = this->GetParam();
+        isQuerySupported(nodeIds.front());
 
-        if (!isQuerySupported(nodeIds.front())) {
-            GTEST_SKIP();
+        if (IS_SKIPPED_OR_FAILED()) {
+            return;
         }
 
         hMemspace = memspaceGet();
@@ -76,8 +82,20 @@ struct memspaceProviderTest : ::memspaceGetTest {
     void SetUp() override {
         ::memspaceGetTest::SetUp();
 
-        if (::memspaceGetTest::IsSkipped()) {
-            GTEST_SKIP();
+        if (numa_available() == -1 || numa_all_nodes_ptr == nullptr) {
+            GTEST_SKIP() << "No available NUMA support; skipped";
+        }
+
+        auto [isQuerySupported, memspaceGet] = ::memspaceGetTest::GetParam();
+        (void)memspaceGet;
+
+        isQuerySupported(nodeIds.front());
+
+        // The test has been marked as skipped in isQuerySupported,
+        // repeating GTEST_SKIP in fixture would only duplicate
+        // the output message
+        if (IS_SKIPPED_OR_FAILED()) {
+            return;
         }
 
         umf_result_t ret =
@@ -97,6 +115,18 @@ struct memspaceProviderTest : ::memspaceGetTest {
     umf_memory_provider_handle_t hProvider = nullptr;
 };
 
+struct numaNodesCapacityTest : numaNodesTest {
+    void SetUp() override {
+        numaNodesTest::SetUp();
+
+        for (auto nodeId : nodeIds) {
+            capacities.push_back(numa_node_size64(nodeId, nullptr));
+        }
+    }
+
+    std::vector<size_t> capacities;
+};
+
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(memspaceGetTest);
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(memspaceProviderTest);
 
@@ -104,8 +134,8 @@ TEST_P(memspaceGetTest, providerFromMemspace) {
     umf_memory_provider_handle_t hProvider = nullptr;
     umf_result_t ret =
         umfMemoryProviderCreateFromMemspace(hMemspace, nullptr, &hProvider);
-    UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
-    UT_ASSERTne(hProvider, nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hProvider, nullptr);
 
     umfMemoryProviderDestroy(hProvider);
 }
@@ -116,15 +146,15 @@ TEST_P(memspaceProviderTest, allocFree) {
     size_t alignment = 0;
 
     umf_result_t ret = umfMemoryProviderAlloc(hProvider, size, alignment, &ptr);
-    UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
-    UT_ASSERTne(ptr, nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
 
     // Access the allocation, so that all the pages associated with it are
     // allocated on some NUMA node.
     memset(ptr, 0xFF, size);
 
     ret = umfMemoryProviderFree(hProvider, ptr, size);
-    UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 static std::vector<int> getAllCpus() {
@@ -144,20 +174,20 @@ TEST_P(memspaceProviderTest, allocLocalMt) {
     auto pinAllocValidate = [&](umf_memory_provider_handle_t hProvider,
                                 int cpu) {
         hwloc_topology_t topology = NULL;
-        UT_ASSERTeq(hwloc_topology_init(&topology), 0);
-        UT_ASSERTeq(hwloc_topology_load(topology), 0);
+        ASSERT_EQ(hwloc_topology_init(&topology), 0);
+        ASSERT_EQ(hwloc_topology_load(topology), 0);
 
         // Pin current thread to the provided CPU.
         hwloc_cpuset_t pinCpuset = hwloc_bitmap_alloc();
-        UT_ASSERTeq(hwloc_bitmap_set(pinCpuset, cpu), 0);
-        UT_ASSERTeq(
-            hwloc_set_cpubind(topology, pinCpuset, HWLOC_CPUBIND_THREAD), 0);
+        ASSERT_EQ(hwloc_bitmap_set(pinCpuset, cpu), 0);
+        ASSERT_EQ(hwloc_set_cpubind(topology, pinCpuset, HWLOC_CPUBIND_THREAD),
+                  0);
 
         // Confirm that the thread is pinned to the provided CPU.
         hwloc_cpuset_t curCpuset = hwloc_bitmap_alloc();
-        UT_ASSERTeq(
-            hwloc_get_cpubind(topology, curCpuset, HWLOC_CPUBIND_THREAD), 0);
-        UT_ASSERT(hwloc_bitmap_isequal(curCpuset, pinCpuset));
+        ASSERT_EQ(hwloc_get_cpubind(topology, curCpuset, HWLOC_CPUBIND_THREAD),
+                  0);
+        ASSERT_TRUE(hwloc_bitmap_isequal(curCpuset, pinCpuset));
         hwloc_bitmap_free(curCpuset);
         hwloc_bitmap_free(pinCpuset);
 
@@ -168,8 +198,8 @@ TEST_P(memspaceProviderTest, allocLocalMt) {
 
         umf_result_t ret =
             umfMemoryProviderAlloc(hProvider, size, alignment, &ptr);
-        UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
-        UT_ASSERTne(ptr, nullptr);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ptr, nullptr);
 
         // Access the allocation, so that all the pages associated with it are
         // allocated on some NUMA node.
@@ -179,7 +209,8 @@ TEST_P(memspaceProviderTest, allocLocalMt) {
         int mode = -1;
         std::vector<size_t> boundNodeIds;
         size_t allocNodeId = SIZE_MAX;
-        getAllocationPolicy(ptr, maxNodeId, mode, boundNodeIds, allocNodeId);
+        ASSERT_NO_FATAL_FAILURE(getAllocationPolicy(ptr, maxNodeId, mode,
+                                                    boundNodeIds, allocNodeId));
 
         // Get the CPUs associated with the specified NUMA node.
         hwloc_obj_t allocNodeObj =
@@ -190,20 +221,20 @@ TEST_P(memspaceProviderTest, allocLocalMt) {
         hwloc_location loc;
         loc.location.object = allocNodeObj,
         loc.type = hwloc_location_type_alias::HWLOC_LOCATION_TYPE_OBJECT;
-        UT_ASSERTeq(hwloc_get_local_numanode_objs(topology, &loc, &nNodes,
-                                                  localNodes.data(), 0),
-                    0);
-        UT_ASSERT(nNodes <= MAX_NODES);
+        ASSERT_EQ(hwloc_get_local_numanode_objs(topology, &loc, &nNodes,
+                                                localNodes.data(), 0),
+                  0);
+        ASSERT_LE(nNodes, MAX_NODES);
 
         // Confirm that the allocation from this thread was made to a local
         // NUMA node.
-        UT_ASSERT(std::any_of(localNodes.begin(), localNodes.end(),
-                              [&allocNodeObj](hwloc_obj_t node) {
-                                  return node == allocNodeObj;
-                              }));
+        ASSERT_TRUE(std::any_of(localNodes.begin(), localNodes.end(),
+                                [&allocNodeObj](hwloc_obj_t node) {
+                                    return node == allocNodeObj;
+                                }));
 
         ret = umfMemoryProviderFree(hProvider, ptr, size);
-        UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
         hwloc_topology_destroy(topology);
     };
diff --git a/test/memspaces/memspace_helpers.hpp b/test/memspaces/memspace_helpers.hpp
index 1adee2607..5385e5344 100644
--- a/test/memspaces/memspace_helpers.hpp
+++ b/test/memspaces/memspace_helpers.hpp
@@ -36,10 +36,10 @@ void getAllocationPolicy(void *ptr, unsigned long maxNodeId, int &mode,
     // Get policy and the nodes associated with this policy.
     int ret = get_mempolicy(&memMode, memNodeMasks.data(),
                             nrUlongs * bitsPerUlong, ptr, MPOL_F_ADDR);
-    UT_ASSERTeq(ret, 0);
+    ASSERT_EQ(ret, 0);
     mode = memMode;
 
-    UT_ASSERTeq(boundNodeIds.size(), 0);
+    ASSERT_EQ(boundNodeIds.size(), 0);
     for (size_t i = 0; i <= maxNodeId; i++) {
         const size_t memNodeMaskIdx = ((i + bitsPerUlong) / bitsPerUlong) - 1;
         const auto &memNodeMask = memNodeMasks.at(memNodeMaskIdx);
@@ -52,7 +52,7 @@ void getAllocationPolicy(void *ptr, unsigned long maxNodeId, int &mode,
     // Get the node that allocated the memory at 'ptr'.
     int nodeId = -1;
     ret = get_mempolicy(&nodeId, nullptr, 0, ptr, MPOL_F_ADDR | MPOL_F_NODE);
-    UT_ASSERTeq(ret, 0);
+    ASSERT_EQ(ret, 0);
     allocNodeId = static_cast<size_t>(nodeId);
 }
 
diff --git a/test/memspaces/memspace_highest_bandwidth.cpp b/test/memspaces/memspace_highest_bandwidth.cpp
index a5bffb41d..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,18 +7,20 @@
 #include "memspace_fixtures.hpp"
 #include "memspace_helpers.hpp"
 #include "memspace_internal.h"
+#include "numa_helpers.hpp"
 #include "test_helpers.h"
 
-static bool canQueryBandwidth(size_t nodeId) {
+static void canQueryBandwidth(size_t nodeId) {
     hwloc_topology_t topology = nullptr;
     int ret = hwloc_topology_init(&topology);
-    UT_ASSERTeq(ret, 0);
+    ASSERT_EQ(ret, 0);
+
     ret = hwloc_topology_load(topology);
-    UT_ASSERTeq(ret, 0);
+    ASSERT_EQ(ret, 0);
 
     hwloc_obj_t numaNode =
         hwloc_get_obj_by_type(topology, HWLOC_OBJ_NUMANODE, nodeId);
-    UT_ASSERTne(numaNode, nullptr);
+    ASSERT_NE(numaNode, nullptr);
 
     // Setup initiator structure.
     struct hwloc_location initiator;
@@ -30,7 +32,12 @@ static bool canQueryBandwidth(size_t nodeId) {
                                   numaNode, &initiator, 0, &value);
 
     hwloc_topology_destroy(topology);
-    return (ret == 0);
+
+    if (ret != 0) {
+        GTEST_SKIP()
+            << "Error: hwloc_memattr_get_value return value is equal to " << ret
+            << ", should be " << 0;
+    }
 }
 
 INSTANTIATE_TEST_SUITE_P(memspaceLowestLatencyTest, memspaceGetTest,
@@ -43,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_highest_capacity.cpp b/test/memspaces/memspace_highest_capacity.cpp
index 3f3e99c76..8452e74a7 100644
--- a/test/memspaces/memspace_highest_capacity.cpp
+++ b/test/memspaces/memspace_highest_capacity.cpp
@@ -2,11 +2,11 @@
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-#include "memory_target_numa.h"
 #include "memspace_fixtures.hpp"
 #include "memspace_helpers.hpp"
 #include "memspace_internal.h"
-#include "numa_helpers.h"
+#include "memtarget_numa.h"
+#include "numa_helpers.hpp"
 #include "test_helpers.h"
 
 #include <numa.h>
@@ -21,7 +21,7 @@ struct memspaceHighestCapacityProviderTest : ::numaNodesTest {
         ::numaNodesTest::SetUp();
 
         umf_const_memspace_handle_t hMemspace = umfMemspaceHighestCapacityGet();
-        UT_ASSERTne(hMemspace, nullptr);
+        ASSERT_NE(hMemspace, nullptr);
 
         umf_result_t ret =
             umfMemoryProviderCreateFromMemspace(hMemspace, nullptr, &hProvider);
@@ -60,7 +60,9 @@ TEST_F(memspaceHighestCapacityProviderTest, highestCapacityVerify) {
     memset(ptr, 0, alloc_size);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    auto nodeId = getNumaNodeByPtr(ptr);
+    int nodeId = -1;
+    ASSERT_NO_FATAL_FAILURE(getNumaNodeByPtr(ptr, &nodeId));
+
     ASSERT_TRUE(std::any_of(maxCapacityNodes.begin(), maxCapacityNodes.end(),
                             [nodeId](int node) { return nodeId == node; }));
 
diff --git a/test/memspaces/memspace_host_all.cpp b/test/memspaces/memspace_host_all.cpp
index 3b0825eb5..3462b87dc 100644
--- a/test/memspaces/memspace_host_all.cpp
+++ b/test/memspaces/memspace_host_all.cpp
@@ -9,11 +9,11 @@
 
 #include <umf/memspace.h>
 
-#include "memory_target_numa.h"
 #include "memspace_fixtures.hpp"
 #include "memspace_helpers.hpp"
 #include "memspace_internal.h"
-#include "numa_helpers.h"
+#include "memtarget_numa.h"
+#include "numa_helpers.hpp"
 #include "test_helpers.h"
 #include "utils_sanitizers.h"
 
@@ -51,17 +51,18 @@ struct memspaceHostAllProviderTest : ::memspaceHostAllTest {
 
 TEST_F(numaNodesTest, memspaceGet) {
     umf_const_memspace_handle_t hMemspace = umfMemspaceHostAllGet();
-    UT_ASSERTne(hMemspace, nullptr);
+    ASSERT_NE(hMemspace, nullptr);
 
     // Confirm that the HOST ALL memspace is composed of all available NUMA nodes.
-    UT_ASSERTeq(hMemspace->size, nodeIds.size());
+    ASSERT_EQ(hMemspace->size, nodeIds.size());
     for (size_t i = 0; i < hMemspace->size; i++) {
         // NUMA memory target internally casts the config directly into priv.
         // TODO: Use the memory target API when it becomes available.
-        struct umf_numa_memory_target_config_t *numaTargetCfg =
-            (struct umf_numa_memory_target_config_t *)hMemspace->nodes[i]->priv;
-        UT_ASSERT(std::find(nodeIds.begin(), nodeIds.end(),
-                            numaTargetCfg->physical_id) != nodeIds.end());
+        struct umf_numa_memtarget_config_t *numaTargetCfg =
+            (struct umf_numa_memtarget_config_t *)hMemspace->nodes[i]->priv;
+        ASSERT_NE(std::find(nodeIds.begin(), nodeIds.end(),
+                            numaTargetCfg->physical_id),
+                  nodeIds.end());
     }
 }
 
@@ -69,8 +70,8 @@ TEST_F(memspaceHostAllTest, providerFromHostAllMemspace) {
     umf_memory_provider_handle_t hProvider = nullptr;
     umf_result_t ret =
         umfMemoryProviderCreateFromMemspace(hMemspace, nullptr, &hProvider);
-    UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
-    UT_ASSERTne(hProvider, nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hProvider, nullptr);
 
     umfMemoryProviderDestroy(hProvider);
 }
@@ -81,13 +82,13 @@ TEST_F(memspaceHostAllProviderTest, allocFree) {
     size_t alignment = 0;
 
     umf_result_t ret = umfMemoryProviderAlloc(hProvider, size, alignment, &ptr);
-    UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
-    UT_ASSERTne(ptr, nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
 
     memset(ptr, 0xFF, size);
 
     ret = umfMemoryProviderFree(hProvider, ptr, size);
-    UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 TEST_F(memspaceHostAllProviderTest, hostAllDefaults) {
@@ -96,7 +97,7 @@ TEST_F(memspaceHostAllProviderTest, hostAllDefaults) {
     // default kernel path (no mbind).
 
     umf_const_memspace_handle_t hMemspace = umfMemspaceHostAllGet();
-    UT_ASSERTne(hMemspace, nullptr);
+    ASSERT_NE(hMemspace, nullptr);
 
     umf_memory_provider_handle_t hProvider = nullptr;
     umf_result_t ret = umfMemoryProviderCreateFromMemspace(
@@ -110,45 +111,82 @@ TEST_F(memspaceHostAllProviderTest, hostAllDefaults) {
     size_t alignment = 0;
 
     ret = umfMemoryProviderAlloc(hProvider, size, alignment, &ptr1);
-    UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
-    UT_ASSERTne(ptr1, nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr1, nullptr);
     memset(ptr1, 0xFF, size);
 
     // Create single allocation using mmap
     void *ptr2 = mmap(nullptr, size, PROT_READ | PROT_WRITE,
                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-    UT_ASSERTne(ptr2, nullptr);
+    ASSERT_NE(ptr2, nullptr);
     memset(ptr2, 0xFF, size);
 
-    // Compare UMF and kernel default allocation policy
-    struct bitmask *nodemask1 = numa_allocate_nodemask();
-    struct bitmask *nodemask2 = numa_allocate_nodemask();
-    int memMode1 = -1, memMode2 = -1;
-
-    int ret2 = get_mempolicy(&memMode1, nodemask1->maskp, nodemask1->size, ptr1,
-                             MPOL_F_ADDR);
-    UT_ASSERTeq(ret2, 0);
-    ret2 = get_mempolicy(&memMode2, nodemask2->maskp, nodemask2->size, ptr2,
-                         MPOL_F_ADDR);
-    UT_ASSERTeq(ret2, 0);
-    UT_ASSERTeq(memMode1, memMode2);
-    UT_ASSERTeq(nodemask1->size, nodemask2->size);
-    UT_ASSERTeq(numa_bitmask_equal(nodemask1, nodemask2), 1);
-
-    int nodeId1 = -1, nodeId2 = -1;
-    ret2 = get_mempolicy(&nodeId1, nullptr, 0, ptr1, MPOL_F_ADDR | MPOL_F_NODE);
-    UT_ASSERTeq(ret2, 0);
-    ret2 = get_mempolicy(&nodeId2, nullptr, 0, ptr2, MPOL_F_ADDR | MPOL_F_NODE);
-    UT_ASSERTeq(ret2, 0);
-    UT_ASSERTeq(nodeId1, nodeId2);
-
-    numa_free_nodemask(nodemask2);
-    numa_free_nodemask(nodemask1);
-
-    ret2 = munmap(ptr2, size);
-    UT_ASSERTeq(ret2, 0);
+    EXPECT_NODE_EQ(ptr1, ptr2);
+    EXPECT_BIND_MODE_EQ(ptr1, ptr2);
+    EXPECT_BIND_MASK_EQ(ptr1, ptr2);
+
+    auto ret2 = munmap(ptr2, size);
+    ASSERT_EQ(ret2, 0);
 
     ret = umfMemoryProviderFree(hProvider, ptr1, size);
-    UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     umfMemoryProviderDestroy(hProvider);
 }
+
+TEST_F(memspaceHostAllProviderTest, HostAllVsCopy) {
+    umf_memspace_handle_t hMemspaceCopy = nullptr;
+    auto ret = umfMemspaceNew(&hMemspaceCopy);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hMemspaceCopy, nullptr);
+
+    for (size_t i = 0; i < umfMemspaceMemtargetNum(hMemspace); ++i) {
+        auto target = umfMemspaceMemtargetGet(hMemspace, i);
+        ASSERT_NE(target, nullptr);
+
+        ret = umfMemspaceMemtargetAdd(hMemspaceCopy, target);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    }
+
+    ASSERT_EQ(umfMemspaceMemtargetNum(hMemspace),
+              umfMemspaceMemtargetNum(hMemspaceCopy));
+
+    umf_memory_provider_handle_t hProvider1, hProvider2;
+    ret = umfMemoryProviderCreateFromMemspace(hMemspace, nullptr, &hProvider1);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hProvider1, nullptr);
+
+    ret = umfMemoryProviderCreateFromMemspace(hMemspaceCopy, nullptr,
+                                              &hProvider2);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hProvider2, nullptr);
+
+    void *ptr1, *ptr2;
+    ret = umfMemoryProviderAlloc(hProvider1, SIZE_4K, 0, &ptr1);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr1, nullptr);
+
+    ret = umfMemoryProviderAlloc(hProvider2, SIZE_4K, 0, &ptr2);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    memset(ptr1, 0xFF, SIZE_4K);
+    memset(ptr2, 0xFF, SIZE_4K);
+
+    ASSERT_NODE_EQ(ptr1, ptr2);
+    // HostAll memspace bind memory in the unique way (MPOL_DEFAULT),
+    // but this works only for this specific memspaces, but not for it's copies.
+    ASSERT_BIND_MASK_NE(ptr1, ptr2);
+    ASSERT_BIND_MODE_NE(ptr1, ptr2);
+
+    ASSERT_BIND_MODE_EQ(ptr1, MPOL_DEFAULT);
+    ASSERT_BIND_MODE_EQ(ptr2, MPOL_BIND);
+
+    ret = umfMemoryProviderFree(hProvider1, ptr1, SIZE_4K);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfMemoryProviderFree(hProvider2, ptr2, SIZE_4K);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    umfMemoryProviderDestroy(hProvider1);
+    umfMemoryProviderDestroy(hProvider2);
+    umfMemspaceDestroy(hMemspaceCopy);
+}
diff --git a/test/memspaces/memspace_lowest_latency.cpp b/test/memspaces/memspace_lowest_latency.cpp
index cf921612c..fc35f465a 100644
--- a/test/memspaces/memspace_lowest_latency.cpp
+++ b/test/memspaces/memspace_lowest_latency.cpp
@@ -9,16 +9,17 @@
 #include "memspace_internal.h"
 #include "test_helpers.h"
 
-static bool canQueryLatency(size_t nodeId) {
+static void canQueryLatency(size_t nodeId) {
     hwloc_topology_t topology = nullptr;
     int ret = hwloc_topology_init(&topology);
-    UT_ASSERTeq(ret, 0);
+    ASSERT_EQ(ret, 0);
+
     ret = hwloc_topology_load(topology);
-    UT_ASSERTeq(ret, 0);
+    ASSERT_EQ(ret, 0);
 
     hwloc_obj_t numaNode =
         hwloc_get_obj_by_type(topology, HWLOC_OBJ_NUMANODE, nodeId);
-    UT_ASSERTne(numaNode, nullptr);
+    ASSERT_NE(numaNode, nullptr);
 
     // Setup initiator structure.
     struct hwloc_location initiator;
@@ -30,7 +31,12 @@ static bool canQueryLatency(size_t nodeId) {
                                   &initiator, 0, &value);
 
     hwloc_topology_destroy(topology);
-    return (ret == 0);
+
+    if (ret != 0) {
+        GTEST_SKIP()
+            << "Error: hwloc_memattr_get_value return value is equal to " << ret
+            << ", should be " << 0;
+    }
 }
 
 INSTANTIATE_TEST_SUITE_P(memspaceLowestLatencyTest, memspaceGetTest,
diff --git a/test/memspaces/memspace_numa.cpp b/test/memspaces/memspace_numa.cpp
index b50eceac9..be961fb89 100644
--- a/test/memspaces/memspace_numa.cpp
+++ b/test/memspaces/memspace_numa.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2023 Intel Corporation
+// Copyright (C) 2023-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -6,13 +6,19 @@
 #include "memspace_fixtures.hpp"
 #include "memspace_helpers.hpp"
 #include "memspace_internal.h"
+#include "numa_helpers.hpp"
 
+#include <umf/memspace.h>
 #include <umf/providers/provider_os_memory.h>
 
 struct memspaceNumaTest : ::numaNodesTest {
     void SetUp() override {
         ::numaNodesTest::SetUp();
 
+        if (numa_available() == -1) {
+            GTEST_SKIP() << "NUMA not supported on this system; test skipped";
+        }
+
         umf_result_t ret = umfMemspaceCreateFromNumaArray(
             nodeIds.data(), nodeIds.size(), &hMemspace);
         ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
@@ -33,6 +39,10 @@ struct memspaceNumaProviderTest : ::memspaceNumaTest {
     void SetUp() override {
         ::memspaceNumaTest::SetUp();
 
+        if (numa_available() == -1) {
+            GTEST_SKIP() << "NUMA not supported on this system; test skipped";
+        }
+
         umf_result_t ret =
             umfMemoryProviderCreateFromMemspace(hMemspace, nullptr, &hProvider);
         ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
@@ -56,8 +66,13 @@ TEST_F(numaNodesTest, createDestroy) {
         nodeIds.data(), nodeIds.size(), &hMemspace);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_NE(hMemspace, nullptr);
+    EXPECT_EQ(umfMemspaceMemtargetNum(hMemspace), nodeIds.size());
+    for (size_t i = 0; i < umfMemspaceMemtargetNum(hMemspace); ++i) {
+        EXPECT_NE(umfMemspaceMemtargetGet(hMemspace, i), nullptr);
+    }
 
-    umfMemspaceDestroy(hMemspace);
+    ret = umfMemspaceDestroy(hMemspace);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
 
 TEST_F(numaNodesTest, createInvalidNullArray) {
@@ -88,7 +103,130 @@ 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) {
+    EXPECT_EQ(umfMemspaceMemtargetNum(nullptr), 0);
+    EXPECT_EQ(umfMemspaceMemtargetGet(nullptr, 0), nullptr);
+
+    ASSERT_EQ(umfMemspaceMemtargetNum(hMemspace), nodeIds.size());
+    EXPECT_EQ(umfMemspaceMemtargetGet(hMemspace, nodeIds.size()), nullptr);
+}
+
+TEST_F(memspaceNumaTest, memspaceCopyTarget) {
+    umf_memspace_handle_t hMemspaceCopy = nullptr;
+    auto ret = umfMemspaceNew(&hMemspaceCopy);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hMemspaceCopy, nullptr);
+
+    for (size_t i = 0; i < umfMemspaceMemtargetNum(hMemspace); ++i) {
+        auto target = umfMemspaceMemtargetGet(hMemspace, i);
+        ASSERT_NE(target, nullptr);
+
+        ret = umfMemspaceMemtargetAdd(hMemspaceCopy, target);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    }
+
+    ASSERT_EQ(umfMemspaceMemtargetNum(hMemspace),
+              umfMemspaceMemtargetNum(hMemspaceCopy));
+
+    umf_memory_provider_handle_t hProvider1, hProvider2;
+    ret = umfMemoryProviderCreateFromMemspace(hMemspace, nullptr, &hProvider1);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hProvider1, nullptr);
+
+    ret = umfMemoryProviderCreateFromMemspace(hMemspaceCopy, nullptr,
+                                              &hProvider2);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hProvider2, nullptr);
+
+    void *ptr1, *ptr2;
+    ret = umfMemoryProviderAlloc(hProvider1, SIZE_4K, 0, &ptr1);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr1, nullptr);
+
+    ret = umfMemoryProviderAlloc(hProvider2, SIZE_4K, 0, &ptr2);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ASSERT_BIND_MASK_EQ(ptr1, ptr2);
+    ASSERT_BIND_MODE_EQ(ptr1, ptr2);
+
+    ret = umfMemoryProviderFree(hProvider1, ptr1, SIZE_4K);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfMemoryProviderFree(hProvider2, ptr2, SIZE_4K);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    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) {
+    if (numa_max_node() < 2) {
+        GTEST_SKIP() << "Not enough NUMA nodes to run test";
+    }
+
+    umf_memspace_handle_t hMemspaceCopy = nullptr;
+    auto ret = umfMemspaceNew(&hMemspaceCopy);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hMemspaceCopy, nullptr);
+
+    auto target = umfMemspaceMemtargetGet(hMemspace, 0);
+    ASSERT_NE(target, nullptr);
+
+    ret = umfMemspaceMemtargetAdd(hMemspaceCopy, target);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    while (umfMemspaceMemtargetNum(hMemspace) > 1) {
+        auto target = umfMemspaceMemtargetGet(hMemspace, 1);
+        ASSERT_NE(target, nullptr);
+
+        ret = umfMemspaceMemtargetRemove(hMemspace, target);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    }
+
+    ASSERT_EQ(umfMemspaceMemtargetNum(hMemspace),
+              umfMemspaceMemtargetNum(hMemspaceCopy));
+
+    umf_memory_provider_handle_t hProvider1, hProvider2;
+    ret = umfMemoryProviderCreateFromMemspace(hMemspace, nullptr, &hProvider1);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hProvider1, nullptr);
+
+    ret = umfMemoryProviderCreateFromMemspace(hMemspaceCopy, nullptr,
+                                              &hProvider2);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hProvider2, nullptr);
+
+    void *ptr1, *ptr2;
+    ret = umfMemoryProviderAlloc(hProvider1, SIZE_4K, 0, &ptr1);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr1, nullptr);
+
+    ret = umfMemoryProviderAlloc(hProvider2, SIZE_4K, 0, &ptr2);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ASSERT_BIND_MASK_EQ(ptr1, ptr2);
+    ASSERT_BIND_MODE_EQ(ptr1, ptr2);
+
+    ret = umfMemoryProviderFree(hProvider1, ptr1, SIZE_4K);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret = umfMemoryProviderFree(hProvider2, ptr2, SIZE_4K);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    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) {
@@ -105,3 +243,167 @@ TEST_F(memspaceNumaProviderTest, allocFree) {
     ret = umfMemoryProviderFree(hProvider, ptr, size);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
+
+TEST_F(numaNodesCapacityTest, CapacityFilter) {
+    if (capacities.size() <= 1) {
+        GTEST_SKIP() << "Not enough numa nodes - skipping the test";
+    }
+
+    umf_memspace_handle_t hMemspace;
+    auto ret = umfMemspaceClone(umfMemspaceHostAllGet(), &hMemspace);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hMemspace, nullptr);
+
+    std::sort(capacities.begin(), capacities.end());
+
+    size_t filter_size = capacities[capacities.size() / 2];
+    ret = umfMemspaceFilterByCapacity(hMemspace, filter_size);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    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;
+        auto ret = umfMemtargetGetCapacity(hTarget, &capacity);
+        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        auto it = std::find(capacities.begin(), capacities.end(), capacity);
+        EXPECT_NE(it, capacities.end());
+        EXPECT_GE(capacity, filter_size);
+        if (it != capacities.end()) {
+            capacities.erase(it);
+        }
+    }
+
+    // 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) {
+    if (nodeIds.size() <= 1) {
+        GTEST_SKIP() << "Not enough numa nodes - skipping the test";
+    }
+
+    umf_memspace_handle_t hMemspace;
+    auto ret = umfMemspaceClone(umfMemspaceHostAllGet(), &hMemspace);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hMemspace, nullptr);
+
+    std::vector<unsigned> ids = {nodeIds[0], nodeIds[1]};
+    ret = umfMemspaceFilterById(hMemspace, ids.data(), 2);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(umfMemspaceMemtargetNum(hMemspace), 2);
+
+    for (size_t i = 0; i < umfMemspaceMemtargetNum(hMemspace); i++) {
+        auto hTarget = umfMemspaceMemtargetGet(hMemspace, i);
+        ASSERT_NE(hTarget, nullptr);
+        unsigned id;
+        auto ret = umfMemtargetGetId(hTarget, &id);
+        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        auto it = std::find(ids.begin(), ids.end(), id);
+        EXPECT_NE(it, ids.end());
+        if (it != ids.end()) {
+            ids.erase(it);
+        }
+    }
+    ret = umfMemspaceDestroy(hMemspace);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+}
+
+int customfilter(umf_const_memspace_handle_t memspace,
+                 umf_const_memtarget_handle_t memtarget, void *args) {
+    static unsigned customFilterCounter = 0;
+
+    EXPECT_NE(args, nullptr);
+    EXPECT_NE(memspace, nullptr);
+    EXPECT_NE(memtarget, nullptr);
+
+    auto ids = (std::vector<umf_const_memtarget_handle_t> *)args;
+    if (customFilterCounter++ % 2) {
+        ids->push_back(memtarget);
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+TEST_F(numaNodesTest, customfilter) {
+    if (nodeIds.size() <= 1) {
+        GTEST_SKIP() << "Not enough numa nodes - skipping the test";
+    }
+
+    umf_memspace_handle_t hMemspace;
+    auto ret = umfMemspaceClone(umfMemspaceHostAllGet(), &hMemspace);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hMemspace, nullptr);
+
+    std::vector<umf_const_memtarget_handle_t> vec;
+    ret = umfMemspaceUserFilter(hMemspace, &customfilter, &vec);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ASSERT_EQ(umfMemspaceMemtargetNum(hMemspace), nodeIds.size() / 2);
+
+    for (size_t i = 0; i < umfMemspaceMemtargetNum(hMemspace); i++) {
+        auto hTarget = umfMemspaceMemtargetGet(hMemspace, i);
+        ASSERT_NE(hTarget, nullptr);
+
+        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        auto it = std::find(vec.begin(), vec.end(), hTarget);
+        EXPECT_NE(it, vec.end());
+        if (it != vec.end()) {
+            vec.erase(it);
+        }
+    }
+    ASSERT_EQ(vec.size(), 0);
+    ret = umfMemspaceDestroy(hMemspace);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+}
+
+int invalidFilter(umf_const_memspace_handle_t memspace,
+                  umf_const_memtarget_handle_t memtarget, void *args) {
+    EXPECT_EQ(args, nullptr);
+    EXPECT_NE(memspace, nullptr);
+    EXPECT_NE(memtarget, nullptr);
+
+    return -1;
+}
+
+TEST_F(numaNodesTest, invalidFilters) {
+    umf_memspace_handle_t hMemspace;
+    auto ret = umfMemspaceClone(umfMemspaceHostAllGet(), &hMemspace);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hMemspace, nullptr);
+
+    ret = umfMemspaceFilterByCapacity(nullptr, 0);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfMemspaceFilterByCapacity(hMemspace, -1);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfMemspaceFilterById(hMemspace, nullptr, 0);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    unsigned id = 0;
+    ret = umfMemspaceFilterById(nullptr, &id, 1);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfMemspaceUserFilter(hMemspace, nullptr, nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ret = umfMemspaceUserFilter(nullptr, invalidFilter, nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfMemspaceUserFilter(hMemspace, invalidFilter, nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_USER_SPECIFIC);
+    ret = umfMemspaceDestroy(hMemspace);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+}
diff --git a/test/memspaces/memtarget.cpp b/test/memspaces/memtarget.cpp
new file mode 100644
index 000000000..325fa9d1d
--- /dev/null
+++ b/test/memspaces/memtarget.cpp
@@ -0,0 +1,105 @@
+// Copyright (C) 2024 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "memspace_fixtures.hpp"
+#include "memspace_helpers.hpp"
+
+#include <umf/base.h>
+#include <umf/memspace.h>
+#include <umf/memtarget.h>
+
+using umf_test::test;
+
+TEST_F(test, memTargetNuma) {
+    auto memspace = umfMemspaceHostAllGet();
+    ASSERT_NE(memspace, nullptr);
+    umf_memtarget_type_t type;
+    for (size_t i = 0; i < umfMemspaceMemtargetNum(memspace); i++) {
+        auto hTarget = umfMemspaceMemtargetGet(memspace, i);
+        ASSERT_NE(hTarget, nullptr);
+        auto ret = umfMemtargetGetType(hTarget, &type);
+        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        EXPECT_EQ(type, UMF_MEMTARGET_TYPE_NUMA);
+    }
+}
+
+TEST_F(numaNodesCapacityTest, getCapacity) {
+    auto memspace = umfMemspaceHostAllGet();
+    ASSERT_NE(memspace, nullptr);
+
+    for (size_t i = 0; i < umfMemspaceMemtargetNum(memspace); i++) {
+        auto hTarget = umfMemspaceMemtargetGet(memspace, i);
+        ASSERT_NE(hTarget, nullptr);
+        size_t capacity;
+        auto ret = umfMemtargetGetCapacity(hTarget, &capacity);
+        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        auto it = std::find(capacities.begin(), capacities.end(), capacity);
+        EXPECT_NE(it, capacities.end());
+        if (it != capacities.end()) {
+            capacities.erase(it);
+        }
+    }
+    ASSERT_EQ(capacities.size(), 0);
+}
+
+TEST_F(numaNodesTest, getId) {
+    auto memspace = umfMemspaceHostAllGet();
+    ASSERT_NE(memspace, nullptr);
+
+    for (size_t i = 0; i < umfMemspaceMemtargetNum(memspace); i++) {
+        auto hTarget = umfMemspaceMemtargetGet(memspace, i);
+        ASSERT_NE(hTarget, nullptr);
+        unsigned id;
+        auto ret = umfMemtargetGetId(hTarget, &id);
+        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        auto it = std::find(nodeIds.begin(), nodeIds.end(), id);
+        EXPECT_NE(it, nodeIds.end());
+        if (it != nodeIds.end()) {
+            nodeIds.erase(it);
+        }
+    }
+    ASSERT_EQ(nodeIds.size(), 0);
+}
+
+TEST_F(numaNodesTest, getCapacityInvalid) {
+    auto memspace = umfMemspaceHostAllGet();
+    ASSERT_NE(memspace, nullptr);
+    size_t capacity;
+    auto ret = umfMemtargetGetCapacity(NULL, &capacity);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ret = umfMemtargetGetCapacity(NULL, NULL);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    auto hTarget = umfMemspaceMemtargetGet(memspace, 0);
+    ASSERT_NE(hTarget, nullptr);
+    ret = umfMemtargetGetCapacity(hTarget, NULL);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(test, memTargetInvalid) {
+    auto memspace = umfMemspaceHostAllGet();
+    ASSERT_NE(memspace, nullptr);
+    umf_memtarget_type_t type;
+    auto ret = umfMemtargetGetType(NULL, &type);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ret = umfMemtargetGetType(NULL, NULL);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    auto hTarget = umfMemspaceMemtargetGet(memspace, 0);
+    ASSERT_NE(hTarget, nullptr);
+    ret = umfMemtargetGetType(hTarget, NULL);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(numaNodesTest, getIdInvalid) {
+    auto memspace = umfMemspaceHostAllGet();
+    ASSERT_NE(memspace, nullptr);
+    unsigned id;
+    auto ret = umfMemtargetGetId(NULL, &id);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ret = umfMemtargetGetId(NULL, NULL);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    auto hTarget = umfMemspaceMemtargetGet(memspace, 0);
+    ASSERT_NE(hTarget, nullptr);
+    ret = umfMemtargetGetId(hTarget, NULL);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
diff --git a/test/poolFixtures.hpp b/test/poolFixtures.hpp
index 1285c57bf..23f519ecc 100644
--- a/test/poolFixtures.hpp
+++ b/test/poolFixtures.hpp
@@ -1,51 +1,93 @@
-// Copyright (C) 2023 Intel Corporation
+// Copyright (C) 2023-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-#ifndef UMF_TEST_MEMORY_POOL_OPS_HPP
-#define UMF_TEST_MEMORY_POOL_OPS_HPP
-
-#include "pool.hpp"
-#include "provider.hpp"
+#ifndef UMF_TEST_POOL_FIXTURES_HPP
+#define UMF_TEST_POOL_FIXTURES_HPP 1
 
 #include <array>
 #include <cstring>
 #include <functional>
+#include <list>
 #include <random>
 #include <string>
 #include <thread>
 
+#include <umf/pools/pool_proxy.h>
+#include <umf/providers/provider_devdax_memory.h>
+#include <umf/providers/provider_fixed_memory.h>
+
 #include "../malloc_compliance_tests.hpp"
+#include "pool.hpp"
+#include "provider.hpp"
+#include "utils/utils_sanitizers.h"
+
+typedef void *(*pfnPoolParamsCreate)();
+typedef umf_result_t (*pfnPoolParamsDestroy)(void *);
 
-using poolCreateExtParams = std::tuple<umf_memory_pool_ops_t *, void *,
-                                       umf_memory_provider_ops_t *, void *>;
+typedef void *(*pfnProviderParamsCreate)();
+typedef umf_result_t (*pfnProviderParamsDestroy)(void *);
 
-umf::pool_unique_handle_t poolCreateExtUnique(poolCreateExtParams params) {
-    umf_memory_pool_handle_t hPool;
-    auto [pool_ops, pool_params, provider_ops, provider_params] = params;
+using poolCreateExtParams =
+    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) {
+    auto [pool_ops, poolParamsCreate, poolParamsDestroy, provider_ops,
+          providerParamsCreate, providerParamsDestroy] = params;
+
+    umf_memory_provider_handle_t upstream_provider = nullptr;
     umf_memory_provider_handle_t provider = nullptr;
-    auto ret =
-        umfMemoryProviderCreate(provider_ops, provider_params, &provider);
+    umf_memory_pool_handle_t hPool = nullptr;
+    umf_result_t ret;
+
+    void *provider_params = NULL;
+    if (providerParamsCreate) {
+        provider_params = providerParamsCreate();
+    }
+    ret = umfMemoryProviderCreate(provider_ops, provider_params,
+                                  &upstream_provider);
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    EXPECT_NE(upstream_provider, nullptr);
+
+    provider = upstream_provider;
+
+    void *pool_params = NULL;
+    if (poolParamsCreate) {
+        pool_params = poolParamsCreate();
+    }
 
+    // NOTE: we set the UMF_POOL_CREATE_FLAG_OWN_PROVIDER flag here so the pool
+    // will destroy the provider when it is destroyed
     ret = umfPoolCreate(pool_ops, provider, pool_params,
                         UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &hPool);
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    EXPECT_NE(hPool, nullptr);
+
+    // we do not need params anymore
+    if (poolParamsDestroy) {
+        poolParamsDestroy(pool_params);
+    }
+
+    if (providerParamsDestroy) {
+        providerParamsDestroy(provider_params);
+    }
 
-    return umf::pool_unique_handle_t(hPool, &umfPoolDestroy);
+    return umf_test::pool_unique_handle_t(hPool, &umfPoolDestroy);
 }
 
 struct umfPoolTest : umf_test::test,
                      ::testing::WithParamInterface<poolCreateExtParams> {
     void SetUp() override {
         test::SetUp();
+
         pool = poolCreateExtUnique(this->GetParam());
     }
 
     void TearDown() override { test::TearDown(); }
 
-    umf::pool_unique_handle_t pool;
+    umf_test::pool_unique_handle_t pool;
 
     static constexpr int NTHREADS = 5;
     static constexpr std::array<int, 7> nonAlignedAllocSizes = {5,  7,   23, 55,
@@ -65,7 +107,7 @@ struct umfMultiPoolTest : umf_test::test,
 
     void TearDown() override { test::TearDown(); }
 
-    std::vector<umf::pool_unique_handle_t> pools;
+    std::vector<umf_test::pool_unique_handle_t> pools;
 };
 
 struct umfMemTest
@@ -82,7 +124,7 @@ struct umfMemTest
 
     void TearDown() override { test::TearDown(); }
 
-    umf::pool_unique_handle_t pool;
+    umf_test::pool_unique_handle_t pool;
     int expectedRecycledPoolAllocs;
 };
 
@@ -95,7 +137,8 @@ TEST_P(umfPoolTest, allocFree) {
     auto *ptr = umfPoolMalloc(pool.get(), allocSize);
     ASSERT_NE(ptr, nullptr);
     std::memset(ptr, 0, allocSize);
-    umfPoolFree(pool.get(), ptr);
+    umf_result_t umf_result = umfPoolFree(pool.get(), ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 }
 
 TEST_P(umfPoolTest, allocFreeNonAlignedSizes) {
@@ -103,8 +146,31 @@ TEST_P(umfPoolTest, allocFreeNonAlignedSizes) {
         auto *ptr = umfPoolMalloc(pool.get(), allocSize);
         ASSERT_NE(ptr, nullptr);
         std::memset(ptr, 0, allocSize);
-        umfPoolFree(pool.get(), ptr);
+        umf_result_t umf_result = umfPoolFree(pool.get(), ptr);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+}
+
+TEST_P(umfPoolTest, allocFreeAligned) {
+// ::aligned_alloc(alignment=4096, size=1) does not work under sanitizers for unknown reason
+#if defined(_WIN32) || defined(__SANITIZE_ADDRESS__) ||                        \
+    defined(__SANITIZE_THREAD__)
+    // TODO: implement support for windows
+    GTEST_SKIP();
+#else
+    if (!umf_test::isAlignedAllocSupported(pool.get())) {
+        GTEST_SKIP();
     }
+
+    size_t alignment = 4 * 1024; // 4kB
+    void *ptr = umfPoolAlignedMalloc(pool.get(), 1, alignment);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_TRUE(reinterpret_cast<uintptr_t>(ptr) % alignment == 0);
+    *(reinterpret_cast<unsigned char *>(ptr)) = (unsigned char)0xFF;
+
+    umf_result_t umf_result = umfPoolFree(pool.get(), ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+#endif
 }
 
 TEST_P(umfPoolTest, reallocFree) {
@@ -119,7 +185,8 @@ TEST_P(umfPoolTest, reallocFree) {
     auto *new_ptr = umfPoolRealloc(pool.get(), ptr, allocSize * multiplier);
     ASSERT_NE(new_ptr, nullptr);
     std::memset(new_ptr, 0, allocSize * multiplier);
-    umfPoolFree(pool.get(), new_ptr);
+    umf_result_t umf_result = umfPoolFree(pool.get(), new_ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 }
 
 TEST_P(umfPoolTest, callocFree) {
@@ -133,7 +200,8 @@ TEST_P(umfPoolTest, callocFree) {
     for (size_t i = 0; i < num; ++i) {
         ASSERT_EQ(((int *)ptr)[i], 0);
     }
-    umfPoolFree(pool.get(), ptr);
+    umf_result_t umf_result = umfPoolFree(pool.get(), ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 }
 
 void pow2AlignedAllocHelper(umf_memory_pool_handle_t pool) {
@@ -154,9 +222,31 @@ void pow2AlignedAllocHelper(umf_memory_pool_handle_t pool) {
         }
 
         for (auto &ptr : allocs) {
-            umfPoolFree(pool, ptr);
+            umf_result_t umf_result = umfPoolFree(pool, ptr);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+    }
+
+// ::aligned_alloc(alignment=4096, size=1) does not work under sanitizers for unknown reason
+#if !defined(__SANITIZE_ADDRESS__) && !defined(__SANITIZE_THREAD__)
+    // the same for size = 1
+    for (size_t alignment = 1; alignment <= maxAlignment; alignment <<= 1) {
+        std::vector<void *> allocs;
+
+        for (size_t alloc = 0; alloc < numAllocs; alloc++) {
+            auto *ptr = umfPoolAlignedMalloc(pool, 1, alignment);
+            ASSERT_NE(ptr, nullptr);
+            ASSERT_TRUE(reinterpret_cast<uintptr_t>(ptr) % alignment == 0);
+            *(reinterpret_cast<unsigned char *>(ptr)) = (unsigned char)0xFF;
+            allocs.push_back(ptr);
+        }
+
+        for (auto &ptr : allocs) {
+            umf_result_t umf_result = umfPoolFree(pool, ptr);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
         }
     }
+#endif
 }
 
 TEST_P(umfPoolTest, pow2AlignedAlloc) {
@@ -186,7 +276,8 @@ TEST_P(umfPoolTest, multiThreadedMallocFree) {
         }
 
         for (auto allocation : allocations) {
-            umfPoolFree(inPool, allocation);
+            umf_result_t umf_result = umfPoolFree(inPool, allocation);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
         }
     };
 
@@ -239,7 +330,8 @@ TEST_P(umfPoolTest, multiThreadedReallocFree) {
         for (auto allocation : allocations) {
             auto *ptr =
                 umfPoolRealloc(inPool, allocation, allocSize * multiplier);
-            umfPoolFree(inPool, ptr);
+            umf_result_t umf_result = umfPoolFree(inPool, ptr);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
         }
     };
 
@@ -269,7 +361,8 @@ TEST_P(umfPoolTest, multiThreadedCallocFree) {
         }
 
         for (auto allocation : allocations) {
-            umfPoolFree(inPool, allocation);
+            umf_result_t umf_result = umfPoolFree(inPool, allocation);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
         }
     };
 
@@ -294,7 +387,8 @@ TEST_P(umfPoolTest, multiThreadedMallocFreeRandomSizes) {
         }
 
         for (auto allocation : allocations) {
-            umfPoolFree(inPool, allocation);
+            umf_result_t umf_result = umfPoolFree(inPool, allocation);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
         }
     };
 
@@ -334,7 +428,8 @@ TEST_P(umfMemTest, outOfMem) {
     ASSERT_NE(allocations.back(), nullptr);
 
     for (int i = 0; i < expectedRecycledPoolAllocs; i++) {
-        umfPoolFree(hPool, allocations.back());
+        umf_result_t umf_result = umfPoolFree(hPool, allocations.back());
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
         allocations.pop_back();
     }
 
@@ -344,7 +439,8 @@ TEST_P(umfMemTest, outOfMem) {
     }
 
     for (auto allocation : allocations) {
-        umfPoolFree(hPool, allocation);
+        umf_result_t umf_result = umfPoolFree(hPool, allocation);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     }
 }
 
@@ -407,4 +503,305 @@ TEST_P(umfPoolTest, realloc_compliance) {
 
 TEST_P(umfPoolTest, free_compliance) { free_compliance_test(pool.get()); }
 
-#endif /* UMF_TEST_MEMORY_POOL_OPS_HPP */
+TEST_P(umfPoolTest, allocMaxSize) {
+    auto *ptr = umfPoolMalloc(pool.get(), SIZE_MAX);
+    ASSERT_EQ(ptr, nullptr);
+}
+
+TEST_P(umfPoolTest, mallocUsableSize) {
+    [[maybe_unused]] auto pool_ops = std::get<0>(this->GetParam());
+#ifdef _WIN32
+    if (pool_ops == &umf_test::MALLOC_POOL_OPS) {
+        GTEST_SKIP()
+            << "Windows Malloc Pool does not support umfPoolAlignedMalloc";
+    }
+#endif
+    if (!umf_test::isAlignedAllocSupported(pool.get())) {
+        GTEST_SKIP();
+    }
+#ifdef __SANITIZE_ADDRESS__
+    if (pool_ops == &umf_test::MALLOC_POOL_OPS) {
+        // Sanitizer replaces malloc_usable_size implementation with its own
+        GTEST_SKIP()
+            << "This test is invalid with AddressSanitizer instrumentation";
+    }
+#endif
+    for (size_t allocSize :
+         {32, 64, 1 << 6, 1 << 10, 1 << 13, 1 << 16, 1 << 19}) {
+        for (size_t alignment : {0, 1 << 6, 1 << 8, 1 << 12}) {
+            if (alignment >= allocSize) {
+                continue;
+            }
+            void *ptr = nullptr;
+            if (alignment == 0) {
+                ptr = umfPoolMalloc(pool.get(), allocSize);
+            } else {
+                ptr = umfPoolAlignedMalloc(pool.get(), allocSize, alignment);
+            }
+            ASSERT_NE(ptr, nullptr);
+            size_t result = umfPoolMallocUsableSize(pool.get(), ptr);
+            ASSERT_TRUE(result == 0 || result >= allocSize);
+
+            // Make sure we can write to this memory
+            memset(ptr, 123, result);
+
+            umf_result_t umf_result = umfPoolFree(pool.get(), ptr);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+    }
+}
+
+TEST_P(umfPoolTest, umfPoolAlignedMalloc) {
+#ifdef _WIN32
+    // TODO: implement support for windows
+    GTEST_SKIP() << "umfPoolAlignedMalloc() is not supported on Windows";
+#else  /* !_WIN32 */
+    umf_result_t umf_result;
+    void *ptr = nullptr;
+    const size_t size = 2 * 1024 * 1024; // 2MB
+
+    umf_memory_pool_handle_t pool_get = pool.get();
+
+    if (!umf_test::isAlignedAllocSupported(pool_get)) {
+        GTEST_SKIP();
+    }
+
+    ptr = umfPoolAlignedMalloc(pool_get, size, utils_get_page_size());
+    ASSERT_NE(ptr, nullptr);
+
+    umf_result = umfPoolFree(pool_get, ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+#endif /* !_WIN32 */
+}
+
+TEST_P(umfPoolTest, pool_from_ptr_whole_size_success) {
+#ifdef _WIN32
+    // TODO: implement support for windows
+    GTEST_SKIP() << "umfPoolAlignedMalloc() is not supported on Windows";
+#else  /* !_WIN32 */
+    umf_result_t umf_result;
+    size_t size_of_pool_from_ptr;
+    void *ptr_for_pool = nullptr;
+    void *ptr = nullptr;
+
+    umf_memory_pool_handle_t pool_get = pool.get();
+    const size_t size_of_first_alloc = 2 * 1024 * 1024; // 2MB
+
+    if (!umf_test::isAlignedAllocSupported(pool_get)) {
+        GTEST_SKIP();
+    }
+
+    ptr_for_pool = umfPoolAlignedMalloc(pool_get, size_of_first_alloc,
+                                        utils_get_page_size());
+    ASSERT_NE(ptr_for_pool, nullptr);
+
+    // Create provider parameters
+    size_of_pool_from_ptr = size_of_first_alloc; // whole size
+    umf_fixed_memory_provider_params_handle_t params = nullptr;
+    umf_result = umfFixedMemoryProviderParamsCreate(&params, ptr_for_pool,
+                                                    size_of_pool_from_ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(params, nullptr);
+
+    umf_memory_provider_handle_t providerFromPtr = nullptr;
+    umf_result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
+                                         &providerFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(providerFromPtr, nullptr);
+
+    umf_memory_pool_handle_t poolFromPtr = nullptr;
+    umf_result = umfPoolCreate(umfProxyPoolOps(), providerFromPtr, nullptr, 0,
+                               &poolFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ptr = umfPoolMalloc(poolFromPtr, size_of_pool_from_ptr);
+    ASSERT_NE(ptr, nullptr);
+
+    memset(ptr, 0xFF, size_of_pool_from_ptr);
+
+    umf_result = umfPoolFree(poolFromPtr, ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfPoolDestroy(poolFromPtr);
+    umfMemoryProviderDestroy(providerFromPtr);
+    umfFixedMemoryProviderParamsDestroy(params);
+
+    umf_result = umfPoolFree(pool_get, ptr_for_pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+#endif /* !_WIN32 */
+}
+
+TEST_P(umfPoolTest, pool_from_ptr_half_size_success) {
+#ifdef _WIN32
+    // TODO: implement support for windows
+    GTEST_SKIP() << "umfPoolAlignedMalloc() is not supported on Windows";
+#else  /* !_WIN32 */
+    umf_result_t umf_result;
+    size_t size_of_pool_from_ptr;
+    void *ptr_for_pool = nullptr;
+    void *ptr = nullptr;
+
+    umf_memory_pool_handle_t pool_get = pool.get();
+    const size_t size_of_first_alloc = 2 * 1024 * 1024; // 2MB
+
+    if (!umf_test::isAlignedAllocSupported(pool_get)) {
+        GTEST_SKIP();
+    }
+
+    ptr_for_pool = umfPoolAlignedMalloc(pool_get, size_of_first_alloc,
+                                        utils_get_page_size());
+    ASSERT_NE(ptr_for_pool, nullptr);
+
+    // Create provider parameters
+    size_of_pool_from_ptr = size_of_first_alloc / 2; // half size
+    umf_fixed_memory_provider_params_handle_t params = nullptr;
+    umf_result = umfFixedMemoryProviderParamsCreate(&params, ptr_for_pool,
+                                                    size_of_pool_from_ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(params, nullptr);
+
+    umf_memory_provider_handle_t providerFromPtr = nullptr;
+    umf_result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
+                                         &providerFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(providerFromPtr, nullptr);
+
+    umf_memory_pool_handle_t poolFromPtr = nullptr;
+    umf_result = umfPoolCreate(umfProxyPoolOps(), providerFromPtr, nullptr, 0,
+                               &poolFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ptr = umfPoolMalloc(poolFromPtr, size_of_pool_from_ptr);
+    ASSERT_NE(ptr, nullptr);
+
+    memset(ptr, 0xFF, size_of_pool_from_ptr);
+
+    umf_result = umfPoolFree(poolFromPtr, ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfPoolDestroy(poolFromPtr);
+    umfMemoryProviderDestroy(providerFromPtr);
+    umfFixedMemoryProviderParamsDestroy(params);
+
+    umf_result = umfPoolFree(pool_get, ptr_for_pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+#endif /* !_WIN32 */
+}
+
+TEST_P(umfPoolTest, ctl_stat_alloc_count) {
+    umf_memory_pool_handle_t pool_get = pool.get();
+    const size_t size = 4096;
+    const size_t max_allocs = 10;
+    std::list<void *> ptrs;
+    size_t alloc_count = 0;
+    auto ret = umfCtlGet("umf.pool.by_handle.stats.alloc_count", 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 d7612f4d5..7780846ce 100644
--- a/test/pools/disjoint_pool.cpp
+++ b/test/pools/disjoint_pool.cpp
@@ -1,44 +1,159 @@
-// Copyright (C) 2023-2024 Intel Corporation
+// Copyright (C) 2023-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+#include <memory>
+
+#include <umf/base.h>
+#include <umf/memory_pool.h>
+#include <umf/pools/pool_disjoint.h>
+
 #include "pool.hpp"
+#include "pool/pool_disjoint_internal.h"
 #include "poolFixtures.hpp"
-#include "pool_disjoint.h"
 #include "provider.hpp"
 #include "provider_null.h"
 #include "provider_trace.h"
 
-umf_disjoint_pool_params_t poolConfig() {
-    umf_disjoint_pool_params_t config{};
-    config.SlabMinSize = 4096;
-    config.MaxPoolableSize = 4096;
-    config.Capacity = 4;
-    config.MinBucketSize = 64;
-    return config;
-}
-
 using umf_test::test;
 using namespace umf_test;
 
+TEST_F(test, internals) {
+    static umf_result_t expectedResult = UMF_RESULT_SUCCESS;
+    struct memory_provider : public umf_test::provider_base_t {
+        umf_result_t alloc(size_t size, size_t alignment, void **ptr) noexcept {
+            *ptr = umf_ba_global_aligned_alloc(size, alignment);
+            return UMF_RESULT_SUCCESS;
+        }
+
+        umf_result_t free(void *ptr, [[maybe_unused]] size_t size) noexcept {
+            // do the actual free only when we expect the success
+            if (expectedResult == UMF_RESULT_SUCCESS) {
+                umf_ba_global_free(ptr);
+            }
+            return expectedResult;
+        }
+
+        umf_result_t
+        get_min_page_size([[maybe_unused]] const void *ptr,
+                          [[maybe_unused]] size_t *pageSize) noexcept {
+            *pageSize = 1024;
+            return UMF_RESULT_SUCCESS;
+        }
+    };
+    umf_memory_provider_ops_t provider_ops =
+        umf_test::providerMakeCOps<memory_provider, void>();
+
+    auto providerUnique =
+        wrapProviderUnique(createProviderChecked(&provider_ops, nullptr));
+
+    umf_memory_provider_handle_t provider_handle;
+    provider_handle = providerUnique.get();
+
+    umf_disjoint_pool_params_handle_t params =
+        (umf_disjoint_pool_params_handle_t)defaultDisjointPoolConfig();
+    // set to maximum tracing
+    params->pool_trace = 3;
+    params->max_poolable_size = 1024 * 1024;
+
+    // in "internals" test we use ops interface to directly manipulate the pool
+    // structure
+    const umf_memory_pool_ops_t *ops = umfDisjointPoolOps();
+    EXPECT_NE(ops, nullptr);
+
+    disjoint_pool_t *pool;
+    umf_result_t res = ops->initialize(provider_handle, params, (void **)&pool);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+    EXPECT_NE(pool, nullptr);
+    EXPECT_EQ(pool->provider_min_page_size, (size_t)1024);
+
+    // check buckets sizes
+    size_t expected_size = DEFAULT_DISJOINT_MIN_BUCKET_SIZE;
+    EXPECT_EQ(pool->buckets[0]->size, expected_size);
+    EXPECT_EQ(pool->buckets[pool->buckets_num - 1]->size,
+              (size_t)1 << 31); // 2GB
+    for (size_t i = 0; i < pool->buckets_num; i++) {
+        bucket_t *bucket = pool->buckets[i];
+        EXPECT_NE(bucket, nullptr);
+        EXPECT_EQ(bucket->size, expected_size);
+
+        // assuming DEFAULT_DISJOINT_MIN_BUCKET_SIZE = 64, expected bucket
+        // sizes are: 64, 96, 128, 192, 256, ..., 2GB
+        if (i % 2 == 0) {
+            expected_size += expected_size / 2;
+        } else {
+            expected_size = DEFAULT_DISJOINT_MIN_BUCKET_SIZE << ((i + 1) / 2);
+        }
+    }
+
+    // test small allocations
+    size_t size = 8;
+    void *ptr = ops->malloc(pool, size);
+    EXPECT_NE(ptr, nullptr);
+
+    // get bucket - because of small size this should be the first bucket in
+    // the pool
+    bucket_t *bucket = pool->buckets[0];
+    EXPECT_NE(bucket, nullptr);
+
+    // check bucket stats
+    EXPECT_EQ(bucket->alloc_count, (size_t)1);
+
+    // first allocation will always use external memory (newly added to the
+    // pool) and this is counted as allocation from the outside of the pool
+    EXPECT_EQ(bucket->alloc_pool_count, (size_t)0);
+    EXPECT_EQ(bucket->curr_slabs_in_use, (size_t)1);
+
+    // check slab - there should be only single slab allocated
+    EXPECT_NE(bucket->available_slabs, nullptr);
+    EXPECT_EQ(bucket->available_slabs_num, (size_t)1);
+    EXPECT_EQ(bucket->available_slabs->next, nullptr);
+    slab_t *slab = bucket->available_slabs->val;
+
+    // check slab stats
+    EXPECT_GE(slab->slab_size, params->slab_min_size);
+    EXPECT_GE(slab->num_chunks_total, slab->slab_size / bucket->size);
+
+    // check allocation in slab
+    EXPECT_EQ(slab_read_chunk_bit(slab, 0), false);
+    EXPECT_EQ(slab_read_chunk_bit(slab, 1), true);
+
+    // TODO:
+    // * multiple alloc + free from single bucket
+    // * alignments
+    // * full slab alloc
+    // * slab overflow
+    // * chunked slabs
+    // * multiple alloc + free from different buckets
+    // * alloc something outside pool (> MaxPoolableSize)
+    // * test capacity
+    // * check minBucketSize
+    // * test large objects
+    // * check available_slabs_num
+
+    // cleanup
+    ops->finalize(pool);
+    umfDisjointPoolParamsDestroy(params);
+}
+
 TEST_F(test, freeErrorPropagation) {
     static umf_result_t expectedResult = UMF_RESULT_SUCCESS;
     struct memory_provider : public umf_test::provider_base_t {
-        umf_result_t alloc(size_t size, size_t, void **ptr) noexcept {
-            *ptr = malloc(size);
+        umf_result_t alloc(size_t size, size_t alignment, void **ptr) noexcept {
+            *ptr = umf_ba_global_aligned_alloc(size, alignment);
             return UMF_RESULT_SUCCESS;
         }
 
         umf_result_t free(void *ptr, [[maybe_unused]] size_t size) noexcept {
             // do the actual free only when we expect the success
             if (expectedResult == UMF_RESULT_SUCCESS) {
-                ::free(ptr);
+                umf_ba_global_free(ptr);
             }
             return expectedResult;
         }
     };
     umf_memory_provider_ops_t provider_ops =
-        umf::providerMakeCOps<memory_provider, void>();
+        umf_test::providerMakeCOps<memory_provider, void>();
 
     auto providerUnique =
         wrapProviderUnique(createProviderChecked(&provider_ops, nullptr));
@@ -47,15 +162,21 @@ TEST_F(test, freeErrorPropagation) {
     provider_handle = providerUnique.get();
 
     // force all allocations to go to memory provider
-    umf_disjoint_pool_params_t params = poolConfig();
-    params.MaxPoolableSize = 0;
+    umf_disjoint_pool_params_handle_t params;
+    umf_result_t retp = umfDisjointPoolParamsCreate(&params);
+    EXPECT_EQ(retp, UMF_RESULT_SUCCESS);
+    retp = umfDisjointPoolParamsSetMaxPoolableSize(params, 0);
+    EXPECT_EQ(retp, UMF_RESULT_SUCCESS);
 
     umf_memory_pool_handle_t pool = NULL;
-    umf_result_t retp =
-        umfPoolCreate(umfDisjointPoolOps(), provider_handle, &params, 0, &pool);
+    retp =
+        umfPoolCreate(umfDisjointPoolOps(), provider_handle, params, 0, &pool);
     EXPECT_EQ(retp, UMF_RESULT_SUCCESS);
     auto poolHandle = umf_test::wrapPoolUnique(pool);
 
+    retp = umfDisjointPoolParamsDestroy(params);
+    EXPECT_EQ(retp, UMF_RESULT_SUCCESS);
+
     static constexpr size_t size = 1024;
     void *ptr = umfPoolMalloc(pool, size);
 
@@ -75,25 +196,27 @@ TEST_F(test, sharedLimits) {
     static size_t numFrees = 0;
 
     struct memory_provider : public umf_test::provider_base_t {
-        umf_result_t alloc(size_t size, size_t, void **ptr) noexcept {
-            *ptr = malloc(size);
+        umf_result_t alloc(size_t size, size_t alignment, void **ptr) noexcept {
+            *ptr = umf_ba_global_aligned_alloc(size, alignment);
             numAllocs++;
             return UMF_RESULT_SUCCESS;
         }
         umf_result_t free(void *ptr, [[maybe_unused]] size_t size) noexcept {
-            ::free(ptr);
+            umf_ba_global_free(ptr);
             numFrees++;
             return UMF_RESULT_SUCCESS;
         }
     };
     umf_memory_provider_ops_t provider_ops =
-        umf::providerMakeCOps<memory_provider, void>();
+        umf_test::providerMakeCOps<memory_provider, void>();
 
     static constexpr size_t SlabMinSize = 1024;
     static constexpr size_t MaxSize = 4 * SlabMinSize;
 
-    auto config = poolConfig();
-    config.SlabMinSize = SlabMinSize;
+    umf_disjoint_pool_params_handle_t params =
+        (umf_disjoint_pool_params_handle_t)defaultDisjointPoolConfig();
+    umf_result_t ret = umfDisjointPoolParamsSetSlabMinSize(params, SlabMinSize);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
     auto limits =
         std::unique_ptr<umf_disjoint_pool_shared_limits_t,
@@ -101,25 +224,29 @@ TEST_F(test, sharedLimits) {
             umfDisjointPoolSharedLimitsCreate(MaxSize),
             &umfDisjointPoolSharedLimitsDestroy);
 
-    config.SharedLimits = limits.get();
+    ret = umfDisjointPoolParamsSetSharedLimits(params, limits.get());
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
 
     auto provider =
         wrapProviderUnique(createProviderChecked(&provider_ops, nullptr));
 
     umf_memory_pool_handle_t pool1 = NULL;
     umf_memory_pool_handle_t pool2 = NULL;
-    auto ret = umfPoolCreate(umfDisjointPoolOps(), provider.get(),
-                             (void *)&config, 0, &pool1);
+    ret =
+        umfPoolCreate(umfDisjointPoolOps(), provider.get(), params, 0, &pool1);
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
     auto poolHandle1 = umf_test::wrapPoolUnique(pool1);
 
-    ret = umfPoolCreate(umfDisjointPoolOps(), provider.get(), (void *)&config,
-                        0, &pool2);
+    ret =
+        umfPoolCreate(umfDisjointPoolOps(), provider.get(), params, 0, &pool2);
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
     auto poolHandle2 = umf_test::wrapPoolUnique(pool2);
 
-    EXPECT_EQ(0, numAllocs);
-    EXPECT_EQ(0, numFrees);
+    ret = umfDisjointPoolParamsDestroy(params);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    EXPECT_EQ((size_t)0, numAllocs);
+    EXPECT_EQ((size_t)0, numFrees);
 
     std::vector<std::unique_ptr<void, decltype(&umfFree)>> ptrs;
     for (size_t i = 0; i < MaxSize / SlabMinSize; i++) {
@@ -128,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();
 
@@ -144,21 +271,110 @@ TEST_F(test, sharedLimits) {
     EXPECT_EQ(MaxSize / SlabMinSize * 2, numFrees);
 }
 
-auto defaultPoolConfig = poolConfig();
+TEST_F(test, disjointPoolNullParams) {
+    umf_result_t res = umfDisjointPoolParamsCreate(nullptr);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    res = umfDisjointPoolParamsSetSlabMinSize(params, 4096);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfDisjointPoolParamsSetMaxPoolableSize(params, 4096);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfDisjointPoolParamsSetCapacity(params, 4);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfDisjointPoolParamsSetMinBucketSize(params, 64);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfDisjointPoolParamsSetTrace(params, 0);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfDisjointPoolParamsSetSharedLimits(params, nullptr);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfDisjointPoolParamsSetName(params, "test_disjoint_pool");
+}
+
+TEST_F(test, disjointPoolInvalidBucketSize) {
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    umf_result_t res = umfDisjointPoolParamsCreate(&params);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfDisjointPoolParamsSetMinBucketSize(params, 0);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfDisjointPoolParamsSetMinBucketSize(params, 1);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfDisjointPoolParamsSetMinBucketSize(params, 2);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfDisjointPoolParamsSetMinBucketSize(params, 3);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfDisjointPoolParamsSetMinBucketSize(params, 4);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfDisjointPoolParamsSetMinBucketSize(params, 6);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfDisjointPoolParamsSetMinBucketSize(params, 8);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfDisjointPoolParamsSetMinBucketSize(params, 24);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    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(), (void *)&defaultPoolConfig,
-                             &MALLOC_PROVIDER_OPS, nullptr}));
+                             umfDisjointPoolOps(), defaultDisjointPoolConfig,
+                             defaultDisjointPoolConfigDestroy,
+                             &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}));
+
+void *memProviderParams() { return (void *)&DEFAULT_DISJOINT_CAPACITY; }
 
 INSTANTIATE_TEST_SUITE_P(
     disjointPoolTests, umfMemTest,
     ::testing::Values(std::make_tuple(
-        poolCreateExtParams{umfDisjointPoolOps(), (void *)&defaultPoolConfig,
-                            &MOCK_OUT_OF_MEM_PROVIDER_OPS,
-                            (void *)&defaultPoolConfig.Capacity},
-        static_cast<int>(defaultPoolConfig.Capacity) / 2)));
+        poolCreateExtParams{umfDisjointPoolOps(), defaultDisjointPoolConfig,
+                            defaultDisjointPoolConfigDestroy,
+                            &MOCK_OUT_OF_MEM_PROVIDER_OPS, memProviderParams,
+                            nullptr},
+        static_cast<int>(DEFAULT_DISJOINT_CAPACITY) / 2)));
 
 INSTANTIATE_TEST_SUITE_P(disjointMultiPoolTests, umfMultiPoolTest,
                          ::testing::Values(poolCreateExtParams{
-                             umfDisjointPoolOps(), (void *)&defaultPoolConfig,
-                             &MALLOC_PROVIDER_OPS, nullptr}));
+                             umfDisjointPoolOps(), defaultDisjointPoolConfig,
+                             defaultDisjointPoolConfigDestroy,
+                             &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}));
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_coarse_devdax.cpp b/test/pools/jemalloc_coarse_devdax.cpp
new file mode 100644
index 000000000..53d2a41b3
--- /dev/null
+++ b/test/pools/jemalloc_coarse_devdax.cpp
@@ -0,0 +1,44 @@
+// Copyright (C) 2024-2025 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "umf/pools/pool_jemalloc.h"
+#include "umf/providers/provider_devdax_memory.h"
+
+#include "pool_coarse.hpp"
+
+bool devDaxEnvSet() {
+    char *path = getenv("UMF_TESTS_DEVDAX_PATH");
+    char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
+    if (path == nullptr || path[0] == 0 || size == nullptr || size[0] == 0) {
+        return false;
+    }
+
+    return true;
+}
+
+void *createDevDaxParams() {
+    char *path = getenv("UMF_TESTS_DEVDAX_PATH");
+    char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
+
+    umf_devdax_memory_provider_params_handle_t params = NULL;
+    umf_result_t res =
+        umfDevDaxMemoryProviderParamsCreate(&params, path, atol(size));
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error(
+            "Failed to create DevDax Memory Provider params");
+    }
+
+    return params;
+}
+
+static std::vector<poolCreateExtParams> poolParamsList =
+    devDaxEnvSet()
+        ? std::vector<poolCreateExtParams>{poolCreateExtParams{
+              umfJemallocPoolOps(), nullptr, nullptr,
+              umfDevDaxMemoryProviderOps(), createDevDaxParams,
+              (pfnProviderParamsDestroy)umfDevDaxMemoryProviderParamsDestroy}}
+        : std::vector<poolCreateExtParams>{};
+
+INSTANTIATE_TEST_SUITE_P(jemallocCoarseDevDaxTest, umfPoolTest,
+                         ::testing::ValuesIn(poolParamsList));
diff --git a/test/pools/jemalloc_coarse_file.cpp b/test/pools/jemalloc_coarse_file.cpp
new file mode 100644
index 000000000..dcd03898e
--- /dev/null
+++ b/test/pools/jemalloc_coarse_file.cpp
@@ -0,0 +1,31 @@
+// Copyright (C) 2024-2025 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "umf/pools/pool_jemalloc.h"
+#include "umf/providers/provider_file_memory.h"
+
+#include "pool_coarse.hpp"
+
+void *getFileParamsDefault() {
+    umf_file_memory_provider_params_handle_t file_params = NULL;
+    umf_result_t res =
+        umfFileMemoryProviderParamsCreate(&file_params, FILE_PATH);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error(
+            "Failed to create File Memory Provider params");
+    }
+
+    return file_params;
+}
+
+umf_result_t destroyFileParams(void *params) {
+    return umfFileMemoryProviderParamsDestroy(
+        (umf_file_memory_provider_params_handle_t)params);
+}
+
+INSTANTIATE_TEST_SUITE_P(jemallocCoarseFileTest, umfPoolTest,
+                         ::testing::Values(poolCreateExtParams{
+                             umfJemallocPoolOps(), nullptr, nullptr,
+                             umfFileMemoryProviderOps(), getFileParamsDefault,
+                             destroyFileParams}));
diff --git a/test/pools/jemalloc_pool.cpp b/test/pools/jemalloc_pool.cpp
index 331c96f04..69c4cf1a8 100644
--- a/test/pools/jemalloc_pool.cpp
+++ b/test/pools/jemalloc_pool.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2023 Intel Corporation
+// Copyright (C) 2023-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -11,11 +11,83 @@
 using umf_test::test;
 using namespace umf_test;
 
-auto defaultParams = umfOsMemoryProviderParamsDefault();
-INSTANTIATE_TEST_SUITE_P(jemallocPoolTest, umfPoolTest,
-                         ::testing::Values(poolCreateExtParams{
-                             umfJemallocPoolOps(), nullptr,
-                             umfOsMemoryProviderOps(), &defaultParams}));
+using void_unique_ptr = std::unique_ptr<void, decltype(&free)>;
+
+void *createOsMemoryProviderParams() {
+    umf_os_memory_provider_params_handle_t params = nullptr;
+    umf_result_t res = umfOsMemoryProviderParamsCreate(&params);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error("Failed to create os memory provider params");
+    }
+
+    return params;
+}
+
+umf_result_t destroyOsMemoryProviderParams(void *params) {
+    return umfOsMemoryProviderParamsDestroy(
+        (umf_os_memory_provider_params_handle_t)params);
+}
+
+void *createFixedMemoryProviderParams() {
+    // Allocate a memory buffer to use with the fixed memory provider.
+    // The umfPoolTest.malloc_compliance test requires a lot of memory.
+    size_t memory_size = (1UL << 31);
+    static void_unique_ptr memory_buffer =
+        void_unique_ptr(malloc(memory_size), free);
+    if (memory_buffer.get() == NULL) {
+        throw std::runtime_error(
+            "Failed to allocate memory for Fixed memory provider");
+    }
+
+    umf_fixed_memory_provider_params_handle_t params = nullptr;
+    umf_result_t res = umfFixedMemoryProviderParamsCreate(
+        &params, memory_buffer.get(), memory_size);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error(
+            "Failed to create Fixed memory provider params");
+    }
+
+    return params;
+}
+
+umf_result_t destroyFixedMemoryProviderParams(void *params) {
+    return umfFixedMemoryProviderParamsDestroy(
+        (umf_fixed_memory_provider_params_handle_t)params);
+}
+
+template <unsigned arenas = 0> void *createJemallocParams() {
+    umf_jemalloc_pool_params_handle_t params = nullptr;
+    auto ret = umfJemallocPoolParamsCreate(&params);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    if constexpr (arenas != 0) {
+        ret = umfJemallocPoolParamsSetNumArenas(params, arenas);
+        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+    }
+    return params;
+}
+
+umf_result_t destroyJemallocParams(void *params) {
+    return umfJemallocPoolParamsDestroy(
+        (umf_jemalloc_pool_params_handle_t)params);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    jemallocPoolTest, umfPoolTest,
+    ::testing::Values(
+        poolCreateExtParams{
+            umfJemallocPoolOps(), nullptr, nullptr, umfOsMemoryProviderOps(),
+            createOsMemoryProviderParams, destroyOsMemoryProviderParams},
+        poolCreateExtParams{
+            umfJemallocPoolOps(), nullptr, nullptr, umfFixedMemoryProviderOps(),
+            createFixedMemoryProviderParams, destroyFixedMemoryProviderParams},
+        poolCreateExtParams{umfJemallocPoolOps(), createJemallocParams,
+                            destroyJemallocParams, umfOsMemoryProviderOps(),
+                            createOsMemoryProviderParams,
+                            destroyOsMemoryProviderParams},
+        poolCreateExtParams{umfJemallocPoolOps(), createJemallocParams<1>,
+                            destroyJemallocParams, umfOsMemoryProviderOps(),
+                            createOsMemoryProviderParams,
+                            destroyOsMemoryProviderParams}));
 
 // this test makes sure that jemalloc does not use
 // memory provider to allocate metadata (and hence
@@ -27,11 +99,41 @@ TEST_F(test, metadataNotAllocatedUsingProvider) {
 
     // set coarse grain allocations to PROT_NONE so that we can be sure
     // jemalloc does not touch any of the allocated memory
-    auto params = umfOsMemoryProviderParamsDefault();
-    params.protection = UMF_PROTECTION_NONE;
 
-    auto pool = poolCreateExtUnique(
-        {umfJemallocPoolOps(), nullptr, umfOsMemoryProviderOps(), &params});
+    auto providerParamsCreate = []() {
+        umf_os_memory_provider_params_handle_t params = nullptr;
+        umf_result_t res = umfOsMemoryProviderParamsCreate(&params);
+        if (res != UMF_RESULT_SUCCESS) {
+            throw std::runtime_error(
+                "Failed to create OS Memory Provider params");
+        }
+        res =
+            umfOsMemoryProviderParamsSetProtection(params, UMF_PROTECTION_NONE);
+        if (res != UMF_RESULT_SUCCESS) {
+            throw std::runtime_error(
+                "Failed to set OS Memory Provider params protection");
+        }
+        return (void *)params;
+    };
+
+    auto providerParamsDestroy = [](void *params) {
+        umf_result_t res = umfOsMemoryProviderParamsDestroy(
+            (umf_os_memory_provider_params_handle_t)params);
+        if (res != UMF_RESULT_SUCCESS) {
+            throw std::runtime_error(
+                "Failed to destroy OS Memory Provider params");
+        }
+        return res;
+    };
+
+    auto pool = poolCreateExtUnique({
+        umfJemallocPoolOps(),
+        nullptr,
+        nullptr,
+        umfOsMemoryProviderOps(),
+        (pfnProviderParamsCreate)providerParamsCreate,
+        (pfnProviderParamsDestroy)providerParamsDestroy,
+    });
 
     std::vector<std::shared_ptr<void>> allocs;
     for (size_t i = 0; i < numAllocs; i++) {
@@ -40,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 ec07a7c2f..574803fd3 100644
--- a/test/pools/pool_base_alloc.cpp
+++ b/test/pools/pool_base_alloc.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2023 Intel Corporation
+// Copyright (C) 2023-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -17,21 +17,21 @@ struct base_alloc_pool : public umf_test::pool_base_t {
 
     void *malloc(size_t size) noexcept { return umf_ba_global_alloc(size); }
     void *calloc(size_t, size_t) noexcept {
-        umf::getPoolLastStatusRef<base_alloc_pool>() =
+        umf_test::getPoolLastStatusRef<base_alloc_pool>() =
             UMF_RESULT_ERROR_NOT_SUPPORTED;
         return NULL;
     }
     void *realloc(void *, size_t) noexcept {
-        umf::getPoolLastStatusRef<base_alloc_pool>() =
+        umf_test::getPoolLastStatusRef<base_alloc_pool>() =
             UMF_RESULT_ERROR_NOT_SUPPORTED;
         return NULL;
     }
     void *aligned_malloc(size_t, size_t) noexcept {
-        umf::getPoolLastStatusRef<base_alloc_pool>() =
+        umf_test::getPoolLastStatusRef<base_alloc_pool>() =
             UMF_RESULT_ERROR_NOT_SUPPORTED;
         return NULL;
     }
-    size_t malloc_usable_size(void *ptr) noexcept {
+    size_t malloc_usable_size(const void *ptr) noexcept {
         return umf_ba_global_malloc_usable_size(ptr);
     }
     umf_result_t free(void *ptr) noexcept {
@@ -39,13 +39,14 @@ struct base_alloc_pool : public umf_test::pool_base_t {
         return UMF_RESULT_SUCCESS;
     }
     umf_result_t get_last_allocation_error() {
-        return umf::getPoolLastStatusRef<base_alloc_pool>();
+        return umf_test::getPoolLastStatusRef<base_alloc_pool>();
     }
 };
 
-umf_memory_pool_ops_t BA_POOL_OPS = umf::poolMakeCOps<base_alloc_pool, void>();
+umf_memory_pool_ops_t BA_POOL_OPS =
+    umf_test::poolMakeCOps<base_alloc_pool, void>();
 
 INSTANTIATE_TEST_SUITE_P(baPool, umfPoolTest,
                          ::testing::Values(poolCreateExtParams{
-                             &BA_POOL_OPS, nullptr,
-                             &umf_test::BASE_PROVIDER_OPS, nullptr}));
+                             &BA_POOL_OPS, nullptr, nullptr,
+                             &umf_test::BASE_PROVIDER_OPS, nullptr, nullptr}));
diff --git a/test/pools/pool_coarse.hpp b/test/pools/pool_coarse.hpp
new file mode 100644
index 000000000..b1efb4fee
--- /dev/null
+++ b/test/pools/pool_coarse.hpp
@@ -0,0 +1,16 @@
+// Copyright (C) 2024 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef UMF_TEST_POOL_COARSE_HPP
+#define UMF_TEST_POOL_COARSE_HPP 1
+
+#include "pool.hpp"
+#include "poolFixtures.hpp"
+
+using umf_test::test;
+using namespace umf_test;
+
+#define FILE_PATH ((char *)"tmp_file_provider")
+
+#endif /* UMF_TEST_POOL_COARSE_HPP */
diff --git a/test/pools/scalable_coarse_devdax.cpp b/test/pools/scalable_coarse_devdax.cpp
new file mode 100644
index 000000000..86c580402
--- /dev/null
+++ b/test/pools/scalable_coarse_devdax.cpp
@@ -0,0 +1,48 @@
+// Copyright (C) 2024-2025 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "umf/pools/pool_scalable.h"
+#include "umf/providers/provider_devdax_memory.h"
+
+#include "pool_coarse.hpp"
+
+bool devDaxEnvSet() {
+    char *path = getenv("UMF_TESTS_DEVDAX_PATH");
+    char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
+    if (path == nullptr || path[0] == 0 || size == nullptr || size[0] == 0) {
+        return false;
+    }
+
+    return true;
+}
+
+void *createDevDaxParams() {
+    char *path = getenv("UMF_TESTS_DEVDAX_PATH");
+    char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
+
+    umf_devdax_memory_provider_params_handle_t params = NULL;
+    umf_result_t res =
+        umfDevDaxMemoryProviderParamsCreate(&params, path, atol(size));
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error(
+            "Failed to create DevDax Memory Provider params");
+    }
+
+    return params;
+}
+
+umf_result_t destroyDevDaxParams(void *params) {
+    return umfDevDaxMemoryProviderParamsDestroy(
+        (umf_devdax_memory_provider_params_handle_t)params);
+}
+
+static std::vector<poolCreateExtParams> poolParamsList =
+    devDaxEnvSet() ? std::vector<poolCreateExtParams>{poolCreateExtParams{
+                         umfScalablePoolOps(), nullptr, nullptr,
+                         umfDevDaxMemoryProviderOps(), createDevDaxParams,
+                         destroyDevDaxParams}}
+                   : std::vector<poolCreateExtParams>{};
+
+INSTANTIATE_TEST_SUITE_P(scalableCoarseDevDaxTest, umfPoolTest,
+                         ::testing::ValuesIn(poolParamsList));
diff --git a/test/pools/scalable_coarse_file.cpp b/test/pools/scalable_coarse_file.cpp
new file mode 100644
index 000000000..a5fd5b46a
--- /dev/null
+++ b/test/pools/scalable_coarse_file.cpp
@@ -0,0 +1,31 @@
+// Copyright (C) 2024-2025 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "umf/pools/pool_scalable.h"
+#include "umf/providers/provider_file_memory.h"
+
+#include "pool_coarse.hpp"
+
+void *getFileParamsDefault() {
+    umf_file_memory_provider_params_handle_t file_params = NULL;
+    umf_result_t res =
+        umfFileMemoryProviderParamsCreate(&file_params, FILE_PATH);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error(
+            "Failed to create File Memory Provider params");
+    }
+
+    return file_params;
+}
+
+umf_result_t destroyFileParams(void *params) {
+    return umfFileMemoryProviderParamsDestroy(
+        (umf_file_memory_provider_params_handle_t)params);
+}
+
+INSTANTIATE_TEST_SUITE_P(scalableCoarseFileTest, umfPoolTest,
+                         ::testing::Values(poolCreateExtParams{
+                             umfScalablePoolOps(), nullptr, nullptr,
+                             umfFileMemoryProviderOps(), getFileParamsDefault,
+                             destroyFileParams}));
diff --git a/test/pools/scalable_pool.cpp b/test/pools/scalable_pool.cpp
index bdd0682f5..5f392da46 100644
--- a/test/pools/scalable_pool.cpp
+++ b/test/pools/scalable_pool.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2023 Intel Corporation
+// Copyright (C) 2023-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -7,9 +7,183 @@
 
 #include "pool.hpp"
 #include "poolFixtures.hpp"
+#include "provider.hpp"
 
-auto defaultParams = umfOsMemoryProviderParamsDefault();
-INSTANTIATE_TEST_SUITE_P(scalablePoolTest, umfPoolTest,
-                         ::testing::Values(poolCreateExtParams{
-                             umfScalablePoolOps(), nullptr,
-                             umfOsMemoryProviderOps(), &defaultParams}));
+void *createOsMemoryProviderParams() {
+    umf_os_memory_provider_params_handle_t params = nullptr;
+    umf_result_t res = umfOsMemoryProviderParamsCreate(&params);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error("Failed to create os memory provider params");
+    }
+
+    return params;
+}
+
+umf_result_t destroyOsMemoryProviderParams(void *params) {
+    return umfOsMemoryProviderParamsDestroy(
+        (umf_os_memory_provider_params_handle_t)params);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    scalablePoolTest, umfPoolTest,
+    ::testing::Values(poolCreateExtParams{
+        umfScalablePoolOps(), nullptr, nullptr, umfOsMemoryProviderOps(),
+        createOsMemoryProviderParams, destroyOsMemoryProviderParams}));
+
+using scalablePoolParams = std::tuple<size_t, bool>;
+struct umfScalablePoolParamsTest
+    : umf_test::test,
+      ::testing::WithParamInterface<scalablePoolParams> {
+
+    struct validation_params_t {
+        size_t granularity;
+        bool keep_all_memory;
+    };
+
+    struct provider_validator : public umf_test::provider_ba_global {
+        using base_provider = umf_test::provider_ba_global;
+
+        umf_result_t initialize(const validation_params_t *params) {
+            EXPECT_NE(params, nullptr);
+            expected_params = params;
+            return UMF_RESULT_SUCCESS;
+        }
+        umf_result_t alloc(size_t size, size_t align, void **ptr) {
+            EXPECT_EQ(size, expected_params->granularity);
+            return base_provider::alloc(size, align, ptr);
+        }
+        umf_result_t free(void *ptr, size_t size) {
+            EXPECT_EQ(expected_params->keep_all_memory, false);
+            return base_provider::free(ptr, size);
+        }
+
+        const validation_params_t *expected_params;
+    };
+
+    static constexpr umf_memory_provider_ops_t VALIDATOR_PROVIDER_OPS =
+        umf_test::providerMakeCOps<provider_validator, validation_params_t>();
+
+    umfScalablePoolParamsTest() : expected_params{0, false}, params(nullptr) {}
+    void SetUp() override {
+        test::SetUp();
+        auto [granularity, keep_all_memory] = this->GetParam();
+        expected_params.granularity = granularity;
+        expected_params.keep_all_memory = keep_all_memory;
+        umf_result_t ret = umfScalablePoolParamsCreate(&params);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ret = umfScalablePoolParamsSetGranularity(params, granularity);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ret = umfScalablePoolParamsSetKeepAllMemory(params, keep_all_memory);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    }
+
+    void TearDown() override {
+        umfScalablePoolParamsDestroy(params);
+        test::TearDown();
+    }
+
+    umf_test::pool_unique_handle_t makePool() {
+        umf_memory_provider_handle_t hProvider = nullptr;
+        umf_memory_pool_handle_t hPool = nullptr;
+
+        auto ret = umfMemoryProviderCreate(&VALIDATOR_PROVIDER_OPS,
+                                           &expected_params, &hProvider);
+        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+        ret = umfPoolCreate(umfScalablePoolOps(), hProvider, params,
+                            UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &hPool);
+        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+        return umf_test::pool_unique_handle_t(hPool, &umfPoolDestroy);
+    }
+
+    void allocFreeFlow() {
+        static const size_t ALLOC_SIZE = 128;
+        static const size_t NUM_ALLOCATIONS =
+            expected_params.granularity / ALLOC_SIZE * 20;
+        std::vector<void *> ptrs;
+
+        auto pool = makePool();
+        ASSERT_NE(pool, nullptr);
+
+        for (size_t i = 0; i < NUM_ALLOCATIONS; ++i) {
+            auto *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);
+            ASSERT_NE(ptr, nullptr);
+            ptrs.push_back(ptr);
+        }
+
+        for (size_t i = 0; i < NUM_ALLOCATIONS; ++i) {
+            auto ret = umfPoolFree(pool.get(), ptrs[i]);
+            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        }
+
+        // Now pool can call free during pool destruction
+        expected_params.keep_all_memory = false;
+    }
+
+    validation_params_t expected_params;
+    umf_scalable_pool_params_handle_t params;
+};
+
+TEST_P(umfScalablePoolParamsTest, allocFree) { allocFreeFlow(); }
+
+TEST_P(umfScalablePoolParamsTest, updateParams) {
+    expected_params.granularity *= 2;
+    umf_result_t ret = umfScalablePoolParamsSetGranularity(
+        params, expected_params.granularity);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    expected_params.keep_all_memory = !expected_params.keep_all_memory;
+    ret = umfScalablePoolParamsSetKeepAllMemory(
+        params, expected_params.keep_all_memory);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    allocFreeFlow();
+}
+
+TEST_P(umfScalablePoolParamsTest, invalidParams) {
+    umf_result_t ret = umfScalablePoolParamsCreate(nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfScalablePoolParamsSetGranularity(nullptr, 2 * 1024 * 1024);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfScalablePoolParamsSetGranularity(params, 0);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfScalablePoolParamsSetKeepAllMemory(nullptr, true);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfScalablePoolParamsSetKeepAllMemory(nullptr, false);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfScalablePoolParamsDestroy(nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    scalablePoolTest, umfScalablePoolParamsTest,
+    testing::Combine(testing::Values(2 * 1024 * 1024, 3 * 1024 * 1024,
+                                     4 * 1024 * 1024, 5 * 1024 * 1024),
+                     testing::Values(false, true)));
+
+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
new file mode 100644
index 000000000..41724fd91
--- /dev/null
+++ b/test/provider_devdax_memory.cpp
@@ -0,0 +1,493 @@
+// Copyright (C) 2024-2025 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _WIN32
+#include "test_helpers_linux.h"
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#endif
+
+#include "base.hpp"
+
+#include "test_helpers.h"
+#include "utils/cpp_helpers.hpp"
+
+#include <umf/memory_provider.h>
+#include <umf/providers/provider_devdax_memory.h>
+
+using umf_test::test;
+
+#define INVALID_PTR ((void *)0x01)
+
+typedef enum purge_t {
+    PURGE_NONE = 0,
+    PURGE_LAZY = 1,
+    PURGE_FORCE = 2,
+} purge_t;
+
+static const char *Native_error_str[] = {
+    "success",                          // UMF_DEVDAX_RESULT_SUCCESS
+    "memory allocation failed",         // UMF_DEVDAX_RESULT_ERROR_ALLOC_FAILED
+    "allocated address is not aligned", // UMF_DEVDAX_RESULT_ERROR_ADDRESS_NOT_ALIGNED
+    "memory deallocation failed",       // UMF_DEVDAX_RESULT_ERROR_FREE_FAILED
+    "force purging failed", // UMF_DEVDAX_RESULT_ERROR_PURGE_FORCE_FAILED
+};
+
+// test helpers
+
+static int compare_native_error_str(const char *message, int error) {
+    const char *error_str = Native_error_str[error - UMF_DEVDAX_RESULT_SUCCESS];
+    size_t len = strlen(error_str);
+    return strncmp(message, error_str, len);
+}
+
+using providerCreateExtParams =
+    std::tuple<const umf_memory_provider_ops_t *, void *>;
+
+static void providerCreateExt(providerCreateExtParams params,
+                              umf_test::provider_unique_handle_t *handle) {
+    umf_memory_provider_handle_t hProvider = nullptr;
+    auto [provider_ops, provider_params] = params;
+
+    auto ret =
+        umfMemoryProviderCreate(provider_ops, provider_params, &hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hProvider, nullptr);
+
+    *handle = umf_test::provider_unique_handle_t(hProvider,
+                                                 &umfMemoryProviderDestroy);
+}
+
+struct umfProviderTest
+    : umf_test::test,
+      ::testing::WithParamInterface<providerCreateExtParams> {
+    void SetUp() override {
+        test::SetUp();
+        providerCreateExt(this->GetParam(), &provider);
+        umf_result_t umf_result = umfMemoryProviderGetMinPageSize(
+            provider.get(), nullptr, &page_size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+        page_plus_64 = page_size + 64;
+    }
+
+    void TearDown() override { test::TearDown(); }
+
+    umf_test::provider_unique_handle_t provider;
+    size_t page_size;
+    size_t page_plus_64;
+};
+
+static void test_alloc_free_success(umf_memory_provider_handle_t provider,
+                                    size_t size, size_t alignment,
+                                    purge_t purge) {
+    void *ptr = nullptr;
+
+    umf_result_t umf_result =
+        umfMemoryProviderAlloc(provider, size, alignment, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    memset(ptr, 0xFF, size);
+
+    if (purge == PURGE_LAZY) {
+        umf_result = umfMemoryProviderPurgeLazy(provider, ptr, size);
+        ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    } else if (purge == PURGE_FORCE) {
+        umf_result = umfMemoryProviderPurgeForce(provider, ptr, size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+
+    umf_result = umfMemoryProviderFree(provider, ptr, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+static void verify_last_native_error(umf_memory_provider_handle_t provider,
+                                     int32_t err) {
+    const char *message;
+    int32_t error;
+    umfMemoryProviderGetLastNativeError(provider, &message, &error);
+    ASSERT_EQ(error, err);
+    ASSERT_EQ(compare_native_error_str(message, error), 0);
+}
+
+static void test_alloc_failure(umf_memory_provider_handle_t provider,
+                               size_t size, size_t alignment,
+                               umf_result_t result, int32_t err) {
+    void *ptr = nullptr;
+    umf_result_t umf_result =
+        umfMemoryProviderAlloc(provider, size, alignment, &ptr);
+    ASSERT_EQ(umf_result, result);
+    ASSERT_EQ(ptr, nullptr);
+
+    if (umf_result == UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC) {
+        verify_last_native_error(provider, err);
+    }
+}
+
+// TESTS
+
+// Test checking if devdax was mapped with the MAP_SYNC flag:
+TEST_F(test, test_if_mapped_with_MAP_SYNC) {
+    umf_memory_provider_handle_t hProvider = nullptr;
+    umf_result_t umf_result;
+
+    char *path = getenv("UMF_TESTS_DEVDAX_PATH");
+    if (path == nullptr || path[0] == 0) {
+        GTEST_SKIP() << "Test skipped, UMF_TESTS_DEVDAX_PATH is not set";
+    }
+
+    char *size_str = getenv("UMF_TESTS_DEVDAX_SIZE");
+    if (size_str == nullptr || size_str[0] == 0) {
+        GTEST_SKIP() << "Test skipped, UMF_TESTS_DEVDAX_SIZE is not set";
+    }
+
+    size_t size = atol(size_str);
+    umf_devdax_memory_provider_params_handle_t params = NULL;
+    umf_result = umfDevDaxMemoryProviderParamsCreate(&params, path, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(params, nullptr);
+
+    umf_result = umfMemoryProviderCreate(umfDevDaxMemoryProviderOps(), params,
+                                         &hProvider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hProvider, nullptr);
+
+    char *buf;
+    umf_result = umfMemoryProviderAlloc(hProvider, size, 0, (void **)&buf);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(buf, nullptr);
+
+    bool flag_found = is_mapped_with_MAP_SYNC(path, buf, size);
+
+    umf_result = umfMemoryProviderFree(hProvider, buf, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfMemoryProviderDestroy(hProvider);
+    umfDevDaxMemoryProviderParamsDestroy(params);
+
+    // fail test if the "sf" flag was not found
+    ASSERT_EQ(flag_found, true);
+}
+
+// positive tests using test_alloc_free_success
+
+using devdax_params_unique_handle_t =
+    std::unique_ptr<umf_devdax_memory_provider_params_t,
+                    decltype(&umfDevDaxMemoryProviderParamsDestroy)>;
+
+devdax_params_unique_handle_t create_devdax_params() {
+    char *path = getenv("UMF_TESTS_DEVDAX_PATH");
+    char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
+    if (path == nullptr || path[0] == 0 || size == nullptr || size[0] == 0) {
+        return devdax_params_unique_handle_t(
+            nullptr, &umfDevDaxMemoryProviderParamsDestroy);
+    }
+
+    umf_devdax_memory_provider_params_handle_t params = NULL;
+    umf_result_t res =
+        umfDevDaxMemoryProviderParamsCreate(&params, path, atol(size));
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error(
+            "Failed to create DevDax Memory Provider params");
+    }
+
+    return devdax_params_unique_handle_t(params,
+                                         &umfDevDaxMemoryProviderParamsDestroy);
+}
+
+auto defaultDevDaxParams = create_devdax_params();
+
+static std::vector<providerCreateExtParams> devdaxProviderTestParamsList =
+    defaultDevDaxParams.get()
+        ? std::vector<providerCreateExtParams>{providerCreateExtParams{
+              umfDevDaxMemoryProviderOps(), defaultDevDaxParams.get()}}
+        : std::vector<providerCreateExtParams>{};
+
+GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfProviderTest);
+
+INSTANTIATE_TEST_SUITE_P(devdaxProviderTest, umfProviderTest,
+                         ::testing::ValuesIn(devdaxProviderTestParamsList));
+
+TEST_P(umfProviderTest, create_destroy) {}
+
+TEST_P(umfProviderTest, alloc_page_align_0) {
+    test_alloc_free_success(provider.get(), page_size, 0, PURGE_NONE);
+}
+
+TEST_P(umfProviderTest, alloc_2page_align_page_size) {
+    test_alloc_free_success(provider.get(), 2 * page_size, page_size,
+                            PURGE_NONE);
+}
+
+TEST_P(umfProviderTest, alloc_page64_align_page_div_2) {
+    test_alloc_free_success(provider.get(), page_plus_64, page_size / 2,
+                            PURGE_NONE);
+}
+
+TEST_P(umfProviderTest, purge_lazy) {
+    test_alloc_free_success(provider.get(), page_size, 0, PURGE_LAZY);
+}
+
+TEST_P(umfProviderTest, purge_force) {
+    test_alloc_free_success(provider.get(), page_size, 0, PURGE_FORCE);
+}
+
+TEST_P(umfProviderTest, purge_force_unaligned_alloc) {
+    void *ptr;
+    auto ret = umfMemoryProviderAlloc(provider.get(), page_plus_64, 0, &ptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    test_alloc_free_success(provider.get(), page_size, 0, PURGE_FORCE);
+    umfMemoryProviderFree(provider.get(), ptr, page_plus_64);
+}
+// negative tests using test_alloc_failure
+
+TEST_P(umfProviderTest, alloc_page64_align_page_minus_1_WRONG_ALIGNMENT_1) {
+    test_alloc_failure(provider.get(), page_plus_64, page_size - 1,
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
+}
+
+TEST_P(umfProviderTest, alloc_page64_align_one_half_pages_WRONG_ALIGNMENT_2) {
+    test_alloc_failure(provider.get(), page_plus_64,
+                       page_size + (page_size / 2),
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
+}
+
+TEST_P(umfProviderTest, alloc_page64_WRONG_ALIGNMENT_3_pages) {
+    test_alloc_failure(provider.get(), page_plus_64, 3 * page_size,
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
+}
+
+TEST_P(umfProviderTest, alloc_3_pages_WRONG_ALIGNMENT_3_pages) {
+    test_alloc_failure(provider.get(), 3 * page_size, 3 * page_size,
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
+}
+
+TEST_P(umfProviderTest, alloc_WRONG_SIZE) {
+    size_t size = (size_t)(-1) & ~(page_size - 1);
+    test_alloc_failure(provider.get(), size, 0,
+                       UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY, 0);
+}
+
+// other positive tests
+
+TEST_P(umfProviderTest, get_min_page_size) {
+    size_t min_page_size;
+    umf_result_t umf_result = umfMemoryProviderGetMinPageSize(
+        provider.get(), nullptr, &min_page_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_LE(min_page_size, page_size);
+}
+
+TEST_P(umfProviderTest, get_recommended_page_size) {
+    size_t min_page_size;
+    umf_result_t umf_result = umfMemoryProviderGetMinPageSize(
+        provider.get(), nullptr, &min_page_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_LE(min_page_size, page_size);
+
+    size_t recommended_page_size;
+    umf_result = umfMemoryProviderGetRecommendedPageSize(
+        provider.get(), 0, &recommended_page_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_GE(recommended_page_size, min_page_size);
+}
+
+TEST_P(umfProviderTest, get_name) {
+    const char *name = umfMemoryProviderGetName(provider.get());
+    ASSERT_STREQ(name, "DEVDAX");
+}
+
+TEST_P(umfProviderTest, free_size_0_ptr_not_null) {
+    umf_result_t umf_result =
+        umfMemoryProviderFree(provider.get(), INVALID_PTR, 0);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(umfProviderTest, free_NULL) {
+    umf_result_t umf_result = umfMemoryProviderFree(provider.get(), nullptr, 0);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+// other negative tests
+
+TEST_P(umfProviderTest, free_INVALID_POINTER_SIZE_GT_0) {
+    umf_result_t umf_result =
+        umfMemoryProviderFree(provider.get(), INVALID_PTR, page_plus_64);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(umfProviderTest, purge_lazy_INVALID_POINTER) {
+    umf_result_t umf_result =
+        umfMemoryProviderPurgeLazy(provider.get(), INVALID_PTR, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+}
+
+TEST_P(umfProviderTest, purge_force_INVALID_POINTER) {
+    umf_result_t umf_result =
+        umfMemoryProviderPurgeForce(provider.get(), INVALID_PTR, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC);
+
+    verify_last_native_error(provider.get(),
+                             UMF_DEVDAX_RESULT_ERROR_PURGE_FORCE_FAILED);
+}
+
+// params tests
+
+TEST_F(test, params_protection_flag) {
+    umf_devdax_memory_provider_params_handle_t params = nullptr;
+    umf_result_t ret =
+        umfDevDaxMemoryProviderParamsCreate(&params, "/dev/dax0.0", 4096);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(params, nullptr);
+
+    //test all valid combinations
+    for (unsigned protection = UMF_PROTECTION_NONE;
+         protection < (UMF_PROTECTION_MAX - 1) << 1; ++protection) {
+        ret = umfDevDaxMemoryProviderParamsSetProtection(params, protection);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    }
+
+    umfDevDaxMemoryProviderParamsDestroy(params);
+}
+
+// negative params tests
+
+TEST_F(test, params_invalid_protection_flag) {
+    umf_devdax_memory_provider_params_handle_t params = nullptr;
+    umf_result_t ret =
+        umfDevDaxMemoryProviderParamsCreate(&params, "/dev/dax0.0", 4096);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(params, nullptr);
+
+    ret = umfDevDaxMemoryProviderParamsSetProtection(params, 0);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    for (unsigned protection = UMF_PROTECTION_NONE;
+         protection < (UMF_PROTECTION_MAX - 1) << 1; ++protection) {
+        unsigned invalid_protection = protection | (UMF_PROTECTION_MAX << 1);
+        ret = umfDevDaxMemoryProviderParamsSetProtection(params,
+                                                         invalid_protection);
+        ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    }
+
+    umfDevDaxMemoryProviderParamsDestroy(params);
+}
+
+TEST_F(test, params_null_handle) {
+    auto ret =
+        umfDevDaxMemoryProviderParamsCreate(nullptr, "/dev/dax0.0", 4096);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfDevDaxMemoryProviderParamsDestroy(nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    ret =
+        umfDevDaxMemoryProviderParamsSetDeviceDax(nullptr, "/dev/dax0.0", 4096);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfDevDaxMemoryProviderParamsSetProtection(nullptr, 1);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(test, create_empty_path) {
+    const char *path = "";
+    umf_devdax_memory_provider_params_handle_t wrong_params = NULL;
+    auto ret = umfDevDaxMemoryProviderParamsCreate(&wrong_params, path, 4096);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(wrong_params, nullptr);
+}
+
+TEST_F(test, create_null_path) {
+    const char *path = nullptr;
+    umf_devdax_memory_provider_params_handle_t wrong_params = NULL;
+    auto ret = umfDevDaxMemoryProviderParamsCreate(&wrong_params, path, 4096);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(wrong_params, nullptr);
+}
+
+TEST_F(test, set_empty_path) {
+    const char *path = "tmp";
+    const char *empty_path = "";
+    umf_devdax_memory_provider_params_handle_t params = NULL;
+    auto ret = umfDevDaxMemoryProviderParamsCreate(&params, path, 4096);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(params, nullptr);
+
+    ret = umfDevDaxMemoryProviderParamsSetDeviceDax(params, empty_path, 4096);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfDevDaxMemoryProviderParamsDestroy(params);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+}
+
+TEST_F(test, set_null_path) {
+    const char *path = "tmp";
+    const char *null_path = nullptr;
+    umf_devdax_memory_provider_params_handle_t params = NULL;
+    auto ret = umfDevDaxMemoryProviderParamsCreate(&params, path, 4096);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(params, nullptr);
+
+    ret = umfDevDaxMemoryProviderParamsSetDeviceDax(params, null_path, 4096);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfDevDaxMemoryProviderParamsDestroy(params);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+}
+
+TEST_F(test, create_wrong_path) {
+    umf_memory_provider_handle_t hProvider = nullptr;
+    const char *path = "/tmp/dev/dax0.0";
+    umf_devdax_memory_provider_params_handle_t wrong_params = nullptr;
+
+    auto ret = umfDevDaxMemoryProviderParamsCreate(&wrong_params, path, 4096);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(wrong_params, nullptr);
+
+    ret = umfMemoryProviderCreate(umfDevDaxMemoryProviderOps(), wrong_params,
+                                  &hProvider);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(hProvider, nullptr);
+
+    ret = umfDevDaxMemoryProviderParamsDestroy(wrong_params);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+}
+
+TEST_F(test, create_wrong_path_not_exist) {
+    umf_memory_provider_handle_t hProvider = nullptr;
+    const char *path = "/dev/dax1.1";
+    umf_devdax_memory_provider_params_handle_t wrong_params = nullptr;
+
+    auto ret = umfDevDaxMemoryProviderParamsCreate(&wrong_params, path, 4096);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(wrong_params, nullptr);
+
+    ret = umfMemoryProviderCreate(umfDevDaxMemoryProviderOps(), wrong_params,
+                                  &hProvider);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(hProvider, nullptr);
+
+    ret = umfDevDaxMemoryProviderParamsDestroy(wrong_params);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+}
+
+TEST_F(test, create_wrong_size_0) {
+    umf_memory_provider_handle_t hProvider = nullptr;
+    const char *path = "/dev/dax0.0";
+    umf_devdax_memory_provider_params_handle_t wrong_params = nullptr;
+
+    auto ret = umfDevDaxMemoryProviderParamsCreate(&wrong_params, path, 0);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(wrong_params, nullptr);
+
+    ret = umfMemoryProviderCreate(umfDevDaxMemoryProviderOps(), wrong_params,
+                                  &hProvider);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(hProvider, nullptr);
+
+    ret = umfDevDaxMemoryProviderParamsDestroy(wrong_params);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+}
diff --git a/test/provider_devdax_memory_ipc.cpp b/test/provider_devdax_memory_ipc.cpp
new file mode 100644
index 000000000..47b389c95
--- /dev/null
+++ b/test/provider_devdax_memory_ipc.cpp
@@ -0,0 +1,80 @@
+// 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/memory_provider.h>
+#include <umf/providers/provider_devdax_memory.h>
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+#include <umf/pools/pool_jemalloc.h>
+#endif
+#ifdef UMF_POOL_SCALABLE_ENABLED
+#include <umf/pools/pool_scalable.h>
+#endif
+
+#include "ipcFixtures.hpp"
+
+using umf_test::test;
+
+bool devDaxEnvSet() {
+    char *path = getenv("UMF_TESTS_DEVDAX_PATH");
+    char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
+    if (path == nullptr || path[0] == 0 || size == nullptr || size[0] == 0) {
+        return false;
+    }
+
+    return true;
+}
+
+void *defaultDevDaxParamsCreate() {
+    char *path = getenv("UMF_TESTS_DEVDAX_PATH");
+    char *size = getenv("UMF_TESTS_DEVDAX_SIZE");
+    if (path == nullptr || path[0] == 0 || size == nullptr || size[0] == 0) {
+        return nullptr;
+    }
+
+    umf_devdax_memory_provider_params_handle_t params = NULL;
+    umf_result_t res =
+        umfDevDaxMemoryProviderParamsCreate(&params, path, atol(size));
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error(
+            "Failed to create DevDax Memory Provider params");
+    }
+
+    return params;
+}
+
+umf_result_t defaultDevDaxParamsDestroy(void *params) {
+    return umfDevDaxMemoryProviderParamsDestroy(
+        (umf_devdax_memory_provider_params_handle_t)params);
+}
+
+HostMemoryAccessor hostAccessor;
+
+static std::vector<ipcTestParams> getIpcProxyPoolTestParamsList(void) {
+    std::vector<ipcTestParams> ipcProxyPoolTestParamsList = {};
+
+    if (!devDaxEnvSet()) {
+        // return empty list to skip the test
+        return ipcProxyPoolTestParamsList;
+    }
+
+    ipcProxyPoolTestParamsList = {
+        {umfProxyPoolOps(), nullptr, nullptr, umfDevDaxMemoryProviderOps(),
+         defaultDevDaxParamsCreate, defaultDevDaxParamsDestroy, &hostAccessor},
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+        {umfJemallocPoolOps(), nullptr, nullptr, umfDevDaxMemoryProviderOps(),
+         defaultDevDaxParamsCreate, defaultDevDaxParamsDestroy, &hostAccessor},
+#endif
+#ifdef UMF_POOL_SCALABLE_ENABLED
+        {umfScalablePoolOps(), nullptr, nullptr, umfDevDaxMemoryProviderOps(),
+         defaultDevDaxParamsCreate, defaultDevDaxParamsDestroy, &hostAccessor},
+#endif
+    };
+
+    return ipcProxyPoolTestParamsList;
+}
+
+GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest);
+
+INSTANTIATE_TEST_SUITE_P(DevDaxProviderDifferentPoolsTest, umfIpcTest,
+                         ::testing::ValuesIn(getIpcProxyPoolTestParamsList()));
diff --git a/test/provider_devdax_memory_not_impl.cpp b/test/provider_devdax_memory_not_impl.cpp
new file mode 100644
index 000000000..4687825d3
--- /dev/null
+++ b/test/provider_devdax_memory_not_impl.cpp
@@ -0,0 +1,30 @@
+// Copyright (C) 2024-2025 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "base.hpp"
+
+#include <umf/providers/provider_devdax_memory.h>
+
+using umf_test::test;
+
+TEST_F(test, devdax_provider_not_implemented) {
+    umf_devdax_memory_provider_params_handle_t params = nullptr;
+    umf_result_t umf_result =
+        umfDevDaxMemoryProviderParamsCreate(&params, "path", 4096);
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    EXPECT_EQ(params, nullptr);
+
+    umf_result = umfDevDaxMemoryProviderParamsDestroy(nullptr);
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    umf_result =
+        umfDevDaxMemoryProviderParamsSetDeviceDax(nullptr, "path", 4096);
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    umf_result = umfDevDaxMemoryProviderParamsSetProtection(nullptr, 0);
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    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
new file mode 100644
index 000000000..244544731
--- /dev/null
+++ b/test/provider_file_memory.cpp
@@ -0,0 +1,558 @@
+// Copyright (C) 2024-2025 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "base.hpp"
+
+#include "test_helpers.h"
+#include "utils/cpp_helpers.hpp"
+#ifndef _WIN32
+#include "test_helpers_linux.h"
+#endif
+
+#include <umf/memory_provider.h>
+#include <umf/providers/provider_file_memory.h>
+
+using umf_test::test;
+
+#define FILE_PATH ((char *)"tmp_file")
+#define INVALID_PTR ((void *)0x01)
+
+typedef enum purge_t {
+    PURGE_NONE = 0,
+    PURGE_LAZY = 1,
+    PURGE_FORCE = 2,
+} purge_t;
+
+static const char *Native_error_str[] = {
+    "success",                    // UMF_FILE_RESULT_SUCCESS
+    "memory allocation failed",   // UMF_FILE_RESULT_ERROR_ALLOC_FAILED
+    "memory deallocation failed", // UMF_FILE_RESULT_ERROR_FREE_FAILED
+    "force purging failed",       // UMF_FILE_RESULT_ERROR_PURGE_FORCE_FAILED
+};
+
+// test helpers
+
+static int compare_native_error_str(const char *message, int error) {
+    const char *error_str = Native_error_str[error - UMF_FILE_RESULT_SUCCESS];
+    size_t len = strlen(error_str);
+    return strncmp(message, error_str, len);
+}
+
+using providerCreateExtParams =
+    std::tuple<const umf_memory_provider_ops_t *, void *>;
+
+static void providerCreateExt(providerCreateExtParams params,
+                              umf_test::provider_unique_handle_t *handle) {
+    umf_memory_provider_handle_t hProvider = nullptr;
+    auto [provider_ops, provider_params] = params;
+
+    auto ret =
+        umfMemoryProviderCreate(provider_ops, provider_params, &hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hProvider, nullptr);
+
+    *handle = umf_test::provider_unique_handle_t(hProvider,
+                                                 &umfMemoryProviderDestroy);
+}
+
+struct FileProviderParamsDefault
+    : umf_test::test,
+      ::testing::WithParamInterface<providerCreateExtParams> {
+    void SetUp() override {
+        test::SetUp();
+        providerCreateExt(this->GetParam(), &provider);
+        umf_result_t umf_result =
+            umfMemoryProviderGetMinPageSize(provider.get(), NULL, &page_size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+        page_plus_64 = page_size + 64;
+    }
+
+    void TearDown() override { test::TearDown(); }
+
+    umf_test::provider_unique_handle_t provider;
+    size_t page_size;
+    size_t page_plus_64;
+};
+
+struct FileProviderParamsShared : FileProviderParamsDefault {};
+
+static void test_alloc_free_success(umf_memory_provider_handle_t provider,
+                                    size_t size, size_t alignment,
+                                    purge_t purge) {
+    void *ptr = nullptr;
+
+    umf_result_t umf_result =
+        umfMemoryProviderAlloc(provider, size, alignment, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    memset(ptr, 0xFF, size);
+
+    if (purge == PURGE_LAZY) {
+        umf_result = umfMemoryProviderPurgeLazy(provider, ptr, size);
+        ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    } else if (purge == PURGE_FORCE) {
+        umf_result = umfMemoryProviderPurgeForce(provider, ptr, size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+
+    umf_result = umfMemoryProviderFree(provider, ptr, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+static void verify_last_native_error(umf_memory_provider_handle_t provider,
+                                     int32_t err) {
+    const char *message;
+    int32_t error;
+    umfMemoryProviderGetLastNativeError(provider, &message, &error);
+    ASSERT_EQ(error, err);
+    ASSERT_EQ(compare_native_error_str(message, error), 0);
+}
+
+static void test_alloc_failure(umf_memory_provider_handle_t provider,
+                               size_t size, size_t alignment,
+                               umf_result_t result, int32_t err) {
+    void *ptr = nullptr;
+    umf_result_t umf_result =
+        umfMemoryProviderAlloc(provider, size, alignment, &ptr);
+    ASSERT_EQ(umf_result, result);
+    ASSERT_EQ(ptr, nullptr);
+
+    if (umf_result == UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC) {
+        verify_last_native_error(provider, err);
+    }
+}
+
+// TESTS
+
+// Test checking if FSDAX was mapped with the MAP_SYNC flag:
+TEST_F(test, test_if_mapped_with_MAP_SYNC) {
+    umf_memory_provider_handle_t hProvider = nullptr;
+    umf_result_t umf_result;
+
+    char *path = getenv("UMF_TESTS_FSDAX_PATH");
+    if (path == nullptr || path[0] == 0) {
+        GTEST_SKIP() << "Test skipped, UMF_TESTS_FSDAX_PATH is not set";
+    }
+
+    umf_file_memory_provider_params_handle_t params = nullptr;
+    umf_result = umfFileMemoryProviderParamsCreate(&params, path);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(params, nullptr);
+
+    umf_result =
+        umfFileMemoryProviderParamsSetVisibility(params, UMF_MEM_MAP_SHARED);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result =
+        umfMemoryProviderCreate(umfFileMemoryProviderOps(), params, &hProvider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hProvider, nullptr);
+
+    char *buf;
+    size_t size = 2 * 1024 * 1024; // 2MB
+    umf_result = umfMemoryProviderAlloc(hProvider, size, 0, (void **)&buf);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(buf, nullptr);
+
+    bool flag_found = is_mapped_with_MAP_SYNC(path, buf, size);
+
+    umf_result = umfMemoryProviderFree(hProvider, buf, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfMemoryProviderDestroy(hProvider);
+    umfFileMemoryProviderParamsDestroy(params);
+
+    // fail test if the "sf" flag was not found
+    ASSERT_EQ(flag_found, true);
+}
+
+// positive tests using test_alloc_free_success
+
+using file_params_unique_handle_t =
+    std::unique_ptr<umf_file_memory_provider_params_t,
+                    decltype(&umfFileMemoryProviderParamsDestroy)>;
+
+file_params_unique_handle_t get_file_params_default(char *path) {
+    umf_file_memory_provider_params_handle_t file_params = NULL;
+    umf_result_t res = umfFileMemoryProviderParamsCreate(&file_params, path);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error(
+            "Failed to create File Memory Provider params");
+    }
+
+    return file_params_unique_handle_t(file_params,
+                                       &umfFileMemoryProviderParamsDestroy);
+}
+
+file_params_unique_handle_t file_params_default =
+    get_file_params_default(FILE_PATH);
+
+file_params_unique_handle_t get_file_params_shared(char *path) {
+    umf_file_memory_provider_params_handle_t file_params = NULL;
+    umf_result_t res = umfFileMemoryProviderParamsCreate(&file_params, path);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error(
+            "Failed to create File Memory Provider params");
+    }
+
+    res = umfFileMemoryProviderParamsSetVisibility(file_params,
+                                                   UMF_MEM_MAP_SHARED);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfFileMemoryProviderParamsDestroy(file_params);
+        throw std::runtime_error("Failed to set visibility to shared for File "
+                                 "Memory Provider params");
+    }
+
+    return file_params_unique_handle_t(file_params,
+                                       &umfFileMemoryProviderParamsDestroy);
+}
+
+file_params_unique_handle_t file_params_shared =
+    get_file_params_shared(FILE_PATH);
+
+INSTANTIATE_TEST_SUITE_P(fileProviderTest, FileProviderParamsDefault,
+                         ::testing::Values(providerCreateExtParams{
+                             umfFileMemoryProviderOps(),
+                             file_params_default.get()}));
+
+TEST_P(FileProviderParamsDefault, create_destroy) {}
+
+TEST_P(FileProviderParamsDefault, two_allocations) {
+    umf_result_t umf_result;
+    void *ptr1 = nullptr;
+    void *ptr2 = nullptr;
+    size_t size = page_plus_64;
+    size_t alignment = page_size;
+
+    umf_result = umfMemoryProviderAlloc(provider.get(), size, alignment, &ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr1, nullptr);
+
+    umf_result = umfMemoryProviderAlloc(provider.get(), size, alignment, &ptr2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr2, nullptr);
+
+    ASSERT_NE(ptr1, ptr2);
+    if ((uintptr_t)ptr1 > (uintptr_t)ptr2) {
+        ASSERT_GT((uintptr_t)ptr1 - (uintptr_t)ptr2, size);
+    } else {
+        ASSERT_GT((uintptr_t)ptr2 - (uintptr_t)ptr1, size);
+    }
+
+    memset(ptr1, 0x11, size);
+    memset(ptr2, 0x22, size);
+
+    umf_result = umfMemoryProviderFree(provider.get(), ptr1, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfMemoryProviderFree(provider.get(), ptr2, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(FileProviderParamsDefault, alloc_page64_align_0) {
+    test_alloc_free_success(provider.get(), page_plus_64, 0, PURGE_NONE);
+}
+
+TEST_P(FileProviderParamsDefault, alloc_page64_align_page_div_2) {
+    test_alloc_free_success(provider.get(), page_plus_64, page_size / 2,
+                            PURGE_NONE);
+}
+
+TEST_P(FileProviderParamsDefault, purge_lazy) {
+    test_alloc_free_success(provider.get(), page_plus_64, 0, PURGE_LAZY);
+}
+
+TEST_P(FileProviderParamsDefault, purge_force) {
+    test_alloc_free_success(provider.get(), page_plus_64, 0, PURGE_FORCE);
+}
+
+// negative tests using test_alloc_failure
+
+TEST_P(FileProviderParamsDefault, alloc_WRONG_SIZE) {
+    test_alloc_failure(provider.get(), -1, 0, UMF_RESULT_ERROR_INVALID_ARGUMENT,
+                       0);
+}
+
+TEST_P(FileProviderParamsDefault, alloc_page64_WRONG_ALIGNMENT_3_pages) {
+    test_alloc_failure(provider.get(), page_plus_64, 3 * page_size,
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
+}
+
+TEST_P(FileProviderParamsDefault, alloc_3pages_WRONG_ALIGNMENT_3pages) {
+    test_alloc_failure(provider.get(), 3 * page_size, 3 * page_size,
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
+}
+
+TEST_P(FileProviderParamsDefault,
+       alloc_page64_align_page_minus_1_WRONG_ALIGNMENT_1) {
+    test_alloc_failure(provider.get(), page_plus_64, page_size - 1,
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
+}
+
+TEST_P(FileProviderParamsDefault,
+       alloc_page64_align_one_half_pages_WRONG_ALIGNMENT_2) {
+    test_alloc_failure(provider.get(), page_plus_64,
+                       page_size + (page_size / 2),
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
+}
+
+// negative IPC tests
+
+TEST_P(FileProviderParamsDefault, get_ipc_handle_size_wrong_visibility) {
+    size_t size;
+    umf_result_t umf_result =
+        umfMemoryProviderGetIPCHandleSize(provider.get(), &size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(FileProviderParamsDefault, get_ipc_handle_wrong_visibility) {
+    char providerIpcData;
+    umf_result_t umf_result = umfMemoryProviderGetIPCHandle(
+        provider.get(), INVALID_PTR, 1, &providerIpcData);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(FileProviderParamsDefault, put_ipc_handle_wrong_visibility) {
+    char providerIpcData;
+    umf_result_t umf_result =
+        umfMemoryProviderPutIPCHandle(provider.get(), &providerIpcData);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(FileProviderParamsDefault, open_ipc_handle_wrong_visibility) {
+    char providerIpcData;
+    void *ptr;
+    umf_result_t umf_result =
+        umfMemoryProviderOpenIPCHandle(provider.get(), &providerIpcData, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(FileProviderParamsDefault, close_ipc_handle_wrong_visibility) {
+    umf_result_t umf_result =
+        umfMemoryProviderCloseIPCHandle(provider.get(), INVALID_PTR, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+// other positive tests
+
+TEST_P(FileProviderParamsDefault, get_min_page_size) {
+    size_t min_page_size;
+    umf_result_t umf_result = umfMemoryProviderGetMinPageSize(
+        provider.get(), nullptr, &min_page_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_LE(min_page_size, page_size);
+}
+
+TEST_P(FileProviderParamsDefault, get_recommended_page_size) {
+    size_t min_page_size;
+    umf_result_t umf_result = umfMemoryProviderGetMinPageSize(
+        provider.get(), nullptr, &min_page_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_LE(min_page_size, page_size);
+
+    size_t recommended_page_size;
+    umf_result = umfMemoryProviderGetRecommendedPageSize(
+        provider.get(), 0, &recommended_page_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_GE(recommended_page_size, min_page_size);
+}
+
+TEST_P(FileProviderParamsDefault, get_name) {
+    const char *name = umfMemoryProviderGetName(provider.get());
+    ASSERT_STREQ(name, "FILE");
+}
+
+TEST_P(FileProviderParamsDefault, free_size_0_ptr_not_null) {
+    umf_result_t umf_result =
+        umfMemoryProviderFree(provider.get(), INVALID_PTR, 0);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(FileProviderParamsDefault, free_NULL) {
+    umf_result_t umf_result = umfMemoryProviderFree(provider.get(), nullptr, 0);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+// other negative tests
+
+TEST_F(test, params_null_handle) {
+    umf_result_t umf_result =
+        umfFileMemoryProviderParamsCreate(nullptr, FILE_PATH);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result = umfFileMemoryProviderParamsDestroy(nullptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfFileMemoryProviderParamsSetPath(nullptr, FILE_PATH);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result =
+        umfFileMemoryProviderParamsSetProtection(nullptr, UMF_PROTECTION_READ);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result =
+        umfFileMemoryProviderParamsSetVisibility(nullptr, UMF_MEM_MAP_PRIVATE);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(test, create_empty_path) {
+    const char *path = "";
+
+    umf_file_memory_provider_params_handle_t wrong_params = nullptr;
+    umf_result_t umf_result =
+        umfFileMemoryProviderParamsCreate(&wrong_params, path);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(wrong_params, nullptr);
+}
+
+TEST_F(test, create_null_path) {
+    const char *path = nullptr;
+
+    umf_file_memory_provider_params_handle_t wrong_params = nullptr;
+    umf_result_t umf_result =
+        umfFileMemoryProviderParamsCreate(&wrong_params, path);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(wrong_params, nullptr);
+}
+
+TEST_F(test, set_empty_path) {
+    const char *empty_path = "";
+
+    umf_file_memory_provider_params_handle_t params = nullptr;
+    umf_result_t umf_result =
+        umfFileMemoryProviderParamsCreate(&params, FILE_PATH);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfFileMemoryProviderParamsSetPath(params, empty_path);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result = umfFileMemoryProviderParamsDestroy(params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_F(test, set_null_path) {
+    const char *null_path = nullptr;
+
+    umf_file_memory_provider_params_handle_t params = nullptr;
+    umf_result_t umf_result =
+        umfFileMemoryProviderParamsCreate(&params, FILE_PATH);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfFileMemoryProviderParamsSetPath(params, null_path);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result = umfFileMemoryProviderParamsDestroy(params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(FileProviderParamsDefault, free_INVALID_POINTER_SIZE_GT_0) {
+    umf_result_t umf_result =
+        umfMemoryProviderFree(provider.get(), INVALID_PTR, page_plus_64);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(FileProviderParamsDefault, purge_lazy_INVALID_POINTER) {
+    umf_result_t umf_result =
+        umfMemoryProviderPurgeLazy(provider.get(), INVALID_PTR, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+}
+
+TEST_P(FileProviderParamsDefault, purge_force_INVALID_POINTER) {
+    umf_result_t umf_result =
+        umfMemoryProviderPurgeForce(provider.get(), INVALID_PTR, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC);
+
+    verify_last_native_error(provider.get(),
+                             UMF_FILE_RESULT_ERROR_PURGE_FORCE_FAILED);
+}
+
+// IPC tests
+
+INSTANTIATE_TEST_SUITE_P(fileProviderTest, FileProviderParamsShared,
+                         ::testing::Values(providerCreateExtParams{
+                             umfFileMemoryProviderOps(),
+                             file_params_shared.get()}));
+
+TEST_P(FileProviderParamsShared, IPC_base_success_test) {
+    umf_result_t umf_result;
+    void *ptr = nullptr;
+    size_t size = page_size;
+    void *ipc_handle = nullptr;
+    size_t ipc_handle_size;
+    void *new_ptr = nullptr;
+
+    umf_result =
+        umfMemoryProviderGetIPCHandleSize(provider.get(), &ipc_handle_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ipc_handle_size, 0);
+
+    umf_result = umfMemoryProviderAlloc(provider.get(), size, page_size, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    memset(ptr, 0xFF, size);
+
+    umf_result =
+        umfMemoryProviderAlloc(provider.get(), ipc_handle_size, 0, &ipc_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ipc_handle, nullptr);
+    memset(ipc_handle, 0x0, ipc_handle_size);
+
+    umf_result =
+        umfMemoryProviderGetIPCHandle(provider.get(), ptr, size, ipc_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result =
+        umfMemoryProviderOpenIPCHandle(provider.get(), ipc_handle, &new_ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(new_ptr, nullptr);
+
+    // it requires mapping with UMF_MEM_MAP_SHARED to work
+    int ret = memcmp(ptr, new_ptr, size);
+    ASSERT_EQ(ret, 0);
+
+    umf_result = umfMemoryProviderFree(provider.get(), ptr, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(FileProviderParamsShared, IPC_file_not_exist) {
+    umf_result_t umf_result;
+    void *ptr = nullptr;
+    size_t size = page_size;
+    void *ipc_handle = nullptr;
+    size_t ipc_handle_size;
+    void *new_ptr = nullptr;
+
+    umf_result =
+        umfMemoryProviderGetIPCHandleSize(provider.get(), &ipc_handle_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ipc_handle_size, 0);
+
+    umf_result = umfMemoryProviderAlloc(provider.get(), size, page_size, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+    memset(ptr, 0xFF, size);
+
+    umf_result =
+        umfMemoryProviderAlloc(provider.get(), ipc_handle_size, 0, &ipc_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ipc_handle, nullptr);
+    memset(ipc_handle, 0x0, ipc_handle_size);
+
+    umf_result =
+        umfMemoryProviderGetIPCHandle(provider.get(), ptr, size, ipc_handle);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    int ret = unlink(FILE_PATH);
+    ASSERT_EQ(ret, 0);
+
+    umf_result =
+        umfMemoryProviderOpenIPCHandle(provider.get(), ipc_handle, &new_ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(new_ptr, nullptr);
+
+    umf_result = umfMemoryProviderFree(provider.get(), ptr, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
diff --git a/test/provider_file_memory_ipc.cpp b/test/provider_file_memory_ipc.cpp
new file mode 100644
index 000000000..0408b2fe2
--- /dev/null
+++ b/test/provider_file_memory_ipc.cpp
@@ -0,0 +1,146 @@
+// 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/memory_provider.h>
+#include <umf/providers/provider_file_memory.h>
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+#include <umf/pools/pool_jemalloc.h>
+#endif
+#ifdef UMF_POOL_SCALABLE_ENABLED
+#include <umf/pools/pool_scalable.h>
+#endif
+
+#include "ipcFixtures.hpp"
+
+using umf_test::test;
+
+#define FILE_PATH ((char *)"tmp_file")
+
+void *createFileParamsShared() {
+    umf_file_memory_provider_params_handle_t file_params = NULL;
+    umf_result_t res =
+        umfFileMemoryProviderParamsCreate(&file_params, FILE_PATH);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error(
+            "Failed to create File Memory Provider params");
+    }
+
+    res = umfFileMemoryProviderParamsSetVisibility(file_params,
+                                                   UMF_MEM_MAP_SHARED);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfFileMemoryProviderParamsDestroy(file_params);
+        throw std::runtime_error("Failed to set visibility to shared for File "
+                                 "Memory Provider params");
+    }
+
+    return file_params;
+}
+
+umf_result_t destroyFileParamsShared(void *params) {
+    return umfFileMemoryProviderParamsDestroy(
+        (umf_file_memory_provider_params_handle_t)params);
+}
+
+void *createFileParamsFSDAX() {
+    umf_file_memory_provider_params_handle_t file_params = NULL;
+    umf_result_t res = umfFileMemoryProviderParamsCreate(
+        &file_params, getenv("UMF_TESTS_FSDAX_PATH"));
+    if (res != UMF_RESULT_SUCCESS) {
+        //test will be skipped.
+        return nullptr;
+    }
+
+    res = umfFileMemoryProviderParamsSetVisibility(file_params,
+                                                   UMF_MEM_MAP_SHARED);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfFileMemoryProviderParamsDestroy(file_params);
+        throw std::runtime_error("Failed to set visibility to shared for File "
+                                 "Memory Provider params");
+    }
+
+    return file_params;
+}
+
+umf_result_t destroyFileParamsFSDAX(void *params) {
+    return umfFileMemoryProviderParamsDestroy(
+        (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 = {
+// TODO: enable it when sizes of allocations in ipcFixtures.hpp are fixed
+//    {umfProxyPoolOps(), nullptr, umfFileMemoryProviderOps(),
+//     file_params_shared.get(), &hostAccessor},
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+    {umfJemallocPoolOps(), createJemallocParams, destroyJemallocParams,
+     umfFileMemoryProviderOps(), createFileParamsShared,
+     destroyFileParamsShared, &hostAccessor},
+#endif
+#ifdef UMF_POOL_SCALABLE_ENABLED
+    {umfScalablePoolOps(), nullptr, nullptr, umfFileMemoryProviderOps(),
+     createFileParamsShared, destroyFileParamsShared, &hostAccessor},
+#endif
+};
+
+static std::vector<ipcTestParams> getIpcFsDaxTestParamsList(void) {
+    std::vector<ipcTestParams> ipcFsDaxTestParamsList = {};
+
+    char *path = getenv("UMF_TESTS_FSDAX_PATH");
+    if (path == nullptr || path[0] == 0) {
+        // skipping the test, UMF_TESTS_FSDAX_PATH is not set
+        return ipcFsDaxTestParamsList;
+    }
+
+    ipcFsDaxTestParamsList = {
+// TODO: enable it when sizes of allocations in ipcFixtures.hpp are fixed
+//        {umfProxyPoolOps(), nullptr, umfFileMemoryProviderOps(),
+//         file_params_fsdax.get(), &hostAccessor},
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+        {umfJemallocPoolOps(), createJemallocParams, destroyJemallocParams,
+         umfFileMemoryProviderOps(), createFileParamsFSDAX,
+         destroyFileParamsFSDAX, &hostAccessor},
+#endif
+#ifdef UMF_POOL_SCALABLE_ENABLED
+        {umfScalablePoolOps(), nullptr, nullptr, umfFileMemoryProviderOps(),
+         createFileParamsFSDAX, destroyFileParamsFSDAX, &hostAccessor},
+#endif
+    };
+
+    return ipcFsDaxTestParamsList;
+}
+
+GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest);
+
+INSTANTIATE_TEST_SUITE_P(FileProviderDifferentPoolsTest, umfIpcTest,
+                         ::testing::ValuesIn(ipcManyPoolsTestParamsList));
+
+INSTANTIATE_TEST_SUITE_P(FileProviderDifferentPoolsFSDAXTest, umfIpcTest,
+                         ::testing::ValuesIn(getIpcFsDaxTestParamsList()));
diff --git a/test/provider_file_memory_not_impl.cpp b/test/provider_file_memory_not_impl.cpp
new file mode 100644
index 000000000..c0bde74e2
--- /dev/null
+++ b/test/provider_file_memory_not_impl.cpp
@@ -0,0 +1,33 @@
+// Copyright (C) 2024-2025 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "base.hpp"
+
+#include <umf/providers/provider_file_memory.h>
+
+using umf_test::test;
+
+TEST_F(test, file_provider_not_implemented) {
+    umf_file_memory_provider_params_handle_t params = nullptr;
+    umf_result_t umf_result =
+        umfFileMemoryProviderParamsCreate(&params, "path");
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    EXPECT_EQ(params, nullptr);
+
+    umf_result = umfFileMemoryProviderParamsDestroy(nullptr);
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    umf_result = umfFileMemoryProviderParamsSetPath(nullptr, "path");
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    umf_result = umfFileMemoryProviderParamsSetProtection(nullptr, 0);
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    umf_result =
+        umfFileMemoryProviderParamsSetVisibility(nullptr, UMF_MEM_MAP_PRIVATE);
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    const umf_memory_provider_ops_t *ops = umfFileMemoryProviderOps();
+    EXPECT_EQ(ops, nullptr);
+}
diff --git a/test/provider_fixed_memory.cpp b/test/provider_fixed_memory.cpp
new file mode 100644
index 000000000..83727de2b
--- /dev/null
+++ b/test/provider_fixed_memory.cpp
@@ -0,0 +1,605 @@
+// Copyright (C) 2024-2025 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "base.hpp"
+
+#include "test_helpers.h"
+#include "utils/cpp_helpers.hpp"
+#ifndef _WIN32
+#include "test_helpers_linux.h"
+#endif
+
+#include <umf/memory_provider.h>
+#include <umf/pools/pool_proxy.h>
+#include <umf/providers/provider_fixed_memory.h>
+
+using umf_test::test;
+
+#define FIXED_BUFFER_SIZE (10 * utils_get_page_size())
+#define INVALID_PTR ((void *)0x01)
+
+typedef enum purge_t {
+    PURGE_NONE = 0,
+    PURGE_LAZY = 1,
+    PURGE_FORCE = 2,
+} purge_t;
+
+static const char *Native_error_str[] = {
+    "success",              // UMF_FIXED_RESULT_SUCCESS
+    "force purging failed", // UMF_FIXED_RESULT_ERROR_PURGE_FORCE_FAILED
+};
+
+// Test helpers
+
+static int compare_native_error_str(const char *message, int error) {
+    const char *error_str = Native_error_str[error - UMF_FIXED_RESULT_SUCCESS];
+    size_t len = strlen(error_str);
+    return strncmp(message, error_str, len);
+}
+
+using providerCreateExtParams =
+    std::tuple<const umf_memory_provider_ops_t *, void *>;
+
+static void providerCreateExt(providerCreateExtParams params,
+                              umf_test::provider_unique_handle_t *handle) {
+    umf_memory_provider_handle_t hProvider = nullptr;
+    auto [provider_ops, provider_params] = params;
+
+    auto ret =
+        umfMemoryProviderCreate(provider_ops, provider_params, &hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hProvider, nullptr);
+
+    *handle = umf_test::provider_unique_handle_t(hProvider,
+                                                 &umfMemoryProviderDestroy);
+}
+
+struct FixedProviderTest
+    : umf_test::test,
+      ::testing::WithParamInterface<providerCreateExtParams> {
+    void SetUp() override {
+        test::SetUp();
+
+        // Allocate a memory buffer to use with the fixed memory provider
+        memory_size = FIXED_BUFFER_SIZE; // Allocate 10 pages
+        memory_buffer = malloc(memory_size);
+        ASSERT_NE(memory_buffer, nullptr);
+
+        // Create provider parameters
+        umf_fixed_memory_provider_params_handle_t params = nullptr;
+        umf_result_t res = umfFixedMemoryProviderParamsCreate(
+            &params, memory_buffer, memory_size);
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+        ASSERT_NE(params, nullptr);
+
+        providerCreateExt(std::make_tuple(umfFixedMemoryProviderOps(), params),
+                          &provider);
+
+        umfFixedMemoryProviderParamsDestroy(params);
+        umf_result_t umf_result =
+            umfMemoryProviderGetMinPageSize(provider.get(), NULL, &page_size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+        page_plus_64 = page_size + 64;
+    }
+
+    void TearDown() override {
+        if (memory_buffer) {
+            free(memory_buffer);
+            memory_buffer = nullptr;
+        }
+        test::TearDown();
+    }
+
+    void test_alloc_free_success(size_t size, size_t alignment, purge_t purge) {
+        void *ptr = nullptr;
+        auto provider = this->provider.get();
+
+        umf_result_t umf_result =
+            umfMemoryProviderAlloc(provider, size, alignment, &ptr);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ptr, nullptr);
+
+        memset(ptr, 0xFF, size);
+
+        if (purge == PURGE_LAZY) {
+            umf_result = umfMemoryProviderPurgeLazy(provider, ptr, size);
+            ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+        } else if (purge == PURGE_FORCE) {
+            umf_result = umfMemoryProviderPurgeForce(provider, ptr, size);
+            ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        }
+
+        umf_result = umfMemoryProviderFree(provider, ptr, size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+
+    void verify_last_native_error(int32_t err) {
+        const char *message;
+        int32_t error;
+        auto provider = this->provider.get();
+        umfMemoryProviderGetLastNativeError(provider, &message, &error);
+        ASSERT_EQ(error, err);
+        ASSERT_EQ(compare_native_error_str(message, error), 0);
+    }
+
+    void test_alloc_failure(size_t size, size_t alignment, umf_result_t result,
+                            int32_t err) {
+        void *ptr = nullptr;
+        auto provider = this->provider.get();
+
+        umf_result_t umf_result =
+            umfMemoryProviderAlloc(provider, size, alignment, &ptr);
+        ASSERT_EQ(umf_result, result);
+        ASSERT_EQ(ptr, nullptr);
+
+        if (umf_result == UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC) {
+            verify_last_native_error(err);
+        }
+    }
+
+    umf_test::provider_unique_handle_t provider;
+    size_t page_size;
+    size_t page_plus_64;
+    void *memory_buffer = nullptr;
+    size_t memory_size = 0;
+};
+
+// TESTS
+
+// Positive tests using test_alloc_free_success
+
+INSTANTIATE_TEST_SUITE_P(fixedProviderTest, FixedProviderTest,
+                         ::testing::Values(providerCreateExtParams{
+                             umfFixedMemoryProviderOps(), nullptr}));
+
+TEST_P(FixedProviderTest, create_destroy) {
+    // Creation and destruction are handled in SetUp and TearDown
+}
+
+TEST_F(test, create_no_params) {
+    umf_memory_provider_handle_t provider = nullptr;
+    auto result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), nullptr,
+                                          &provider);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(provider, nullptr);
+}
+
+TEST_P(FixedProviderTest, two_allocations) {
+    umf_result_t umf_result;
+    void *ptr1 = nullptr;
+    void *ptr2 = nullptr;
+    size_t size = page_plus_64;
+    size_t alignment = page_size;
+
+    umf_result = umfMemoryProviderAlloc(provider.get(), size, alignment, &ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr1, nullptr);
+
+    umf_result = umfMemoryProviderAlloc(provider.get(), size, alignment, &ptr2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr2, nullptr);
+
+    ASSERT_NE(ptr1, ptr2);
+    if ((uintptr_t)ptr1 > (uintptr_t)ptr2) {
+        ASSERT_GT((uintptr_t)ptr1 - (uintptr_t)ptr2, size);
+    } else {
+        ASSERT_GT((uintptr_t)ptr2 - (uintptr_t)ptr1, size);
+    }
+
+    memset(ptr1, 0x11, size);
+    memset(ptr2, 0x22, size);
+
+    umf_result = umfMemoryProviderFree(provider.get(), ptr1, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfMemoryProviderFree(provider.get(), ptr2, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(FixedProviderTest, alloc_page64_align_0) {
+    test_alloc_free_success(page_plus_64, 0, PURGE_NONE);
+}
+
+TEST_P(FixedProviderTest, alloc_page64_align_page_div_2) {
+    test_alloc_free_success(page_plus_64, page_size / 2, PURGE_NONE);
+}
+
+TEST_P(FixedProviderTest, purge_lazy) {
+    test_alloc_free_success(page_size, 0, PURGE_LAZY);
+}
+
+TEST_P(FixedProviderTest, purge_force) {
+    test_alloc_free_success(page_size, 0, PURGE_FORCE);
+}
+
+// Negative tests using test_alloc_failure
+
+TEST_P(FixedProviderTest, alloc_WRONG_SIZE) {
+    test_alloc_failure((size_t)-1, 0, UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY, 0);
+}
+
+TEST_P(FixedProviderTest, alloc_page64_WRONG_ALIGNMENT_3_pages) {
+    test_alloc_failure(page_plus_64, 3 * page_size,
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
+}
+
+TEST_P(FixedProviderTest, alloc_3pages_WRONG_ALIGNMENT_3pages) {
+    test_alloc_failure(3 * page_size, 3 * page_size,
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
+}
+
+TEST_P(FixedProviderTest, alloc_page64_align_page_plus_1_WRONG_ALIGNMENT_1) {
+    test_alloc_failure(page_plus_64, page_size + 1,
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
+}
+
+TEST_P(FixedProviderTest, alloc_page64_align_one_half_pages_WRONG_ALIGNMENT_2) {
+    test_alloc_failure(page_plus_64, page_size + (page_size / 2),
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
+}
+
+TEST_P(FixedProviderTest, alloc_size_exceeds_buffer) {
+    size_t size = memory_size + page_size;
+    test_alloc_failure(size, 0, UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY, 0);
+}
+
+// Other positive tests
+
+TEST_P(FixedProviderTest, get_min_page_size) {
+    size_t min_page_size;
+    umf_result_t umf_result = umfMemoryProviderGetMinPageSize(
+        provider.get(), nullptr, &min_page_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_LE(min_page_size, page_size);
+}
+
+TEST_P(FixedProviderTest, get_recommended_page_size) {
+    size_t min_page_size;
+    umf_result_t umf_result = umfMemoryProviderGetMinPageSize(
+        provider.get(), nullptr, &min_page_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_LE(min_page_size, page_size);
+
+    size_t recommended_page_size;
+    umf_result = umfMemoryProviderGetRecommendedPageSize(
+        provider.get(), 0, &recommended_page_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_GE(recommended_page_size, min_page_size);
+}
+
+TEST_P(FixedProviderTest, get_name) {
+    const char *name = umfMemoryProviderGetName(provider.get());
+    ASSERT_STREQ(name, "FIXED");
+}
+
+TEST_P(FixedProviderTest, free_size_0_ptr_not_null) {
+    umf_result_t umf_result =
+        umfMemoryProviderFree(provider.get(), INVALID_PTR, 0);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(FixedProviderTest, free_NULL) {
+    umf_result_t umf_result = umfMemoryProviderFree(provider.get(), nullptr, 0);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+// Other negative tests
+
+TEST_P(FixedProviderTest, free_INVALID_POINTER_SIZE_GT_0) {
+    umf_result_t umf_result =
+        umfMemoryProviderFree(provider.get(), INVALID_PTR, page_plus_64);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(FixedProviderTest, purge_lazy_INVALID_POINTER) {
+    umf_result_t umf_result =
+        umfMemoryProviderPurgeLazy(provider.get(), INVALID_PTR, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+}
+
+TEST_P(FixedProviderTest, purge_force_INVALID_POINTER) {
+    umf_result_t umf_result =
+        umfMemoryProviderPurgeForce(provider.get(), INVALID_PTR, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC);
+
+    verify_last_native_error(UMF_FIXED_RESULT_ERROR_PURGE_FORCE_FAILED);
+}
+
+// Params tests
+
+TEST_F(test, params_null_handle) {
+    constexpr size_t memory_size = 100;
+    char memory_buffer[memory_size];
+    umf_result_t umf_result =
+        umfFixedMemoryProviderParamsCreate(nullptr, memory_buffer, memory_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result = umfFixedMemoryProviderParamsDestroy(nullptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_F(test, create_with_null_ptr) {
+    constexpr size_t memory_size = 100;
+    umf_fixed_memory_provider_params_handle_t wrong_params = nullptr;
+    umf_result_t umf_result =
+        umfFixedMemoryProviderParamsCreate(&wrong_params, nullptr, memory_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(wrong_params, nullptr);
+}
+
+TEST_F(test, create_with_zero_size) {
+    constexpr size_t memory_size = 100;
+    char memory_buffer[memory_size];
+    umf_fixed_memory_provider_params_handle_t wrong_params = nullptr;
+    umf_result_t umf_result =
+        umfFixedMemoryProviderParamsCreate(&wrong_params, memory_buffer, 0);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(wrong_params, nullptr);
+}
+
+TEST_F(test, params_several_set_memory) {
+    umf_memory_provider_handle_t provider1 = nullptr, provider2 = nullptr;
+    size_t memory_size1 = FIXED_BUFFER_SIZE,
+           memory_size2 = FIXED_BUFFER_SIZE * 10;
+    size_t alloc_size1 = memory_size1 / 2, alloc_size2 = memory_size2 / 2;
+    void *memory_buffer1 = nullptr;
+    void *memory_buffer2 = nullptr;
+    memory_buffer1 = malloc(memory_size1);
+    memory_buffer2 = malloc(memory_size2);
+    void *ptr1 = nullptr;
+    void *ptr2 = nullptr;
+    const char *source_str = "Allocated memory!";
+
+    umf_fixed_memory_provider_params_handle_t params = nullptr;
+    umf_result_t umf_result = umfFixedMemoryProviderParamsCreate(
+        &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;
+    void *ptr2 = nullptr;
+    size_t size = page_size;
+    size_t alignment = page_size;
+
+    umf_result = umfMemoryProviderAlloc(provider.get(), size, alignment, &ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr1, nullptr);
+
+    umf_result = umfMemoryProviderAlloc(provider.get(), size, alignment, &ptr2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr2, nullptr);
+
+    ASSERT_EQ((uintptr_t)ptr2 - (uintptr_t)ptr1, size);
+
+    memset(ptr1, 0x11, size);
+    memset(ptr2, 0x22, size);
+
+    size_t merged_size = size * 2;
+    umf_result = umfMemoryProviderAllocationMerge(provider.get(), ptr1, ptr2,
+                                                  merged_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfMemoryProviderFree(provider.get(), ptr1, merged_size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(FixedProviderTest, split) {
+    umf_result_t umf_result;
+    void *ptr1 = nullptr;
+    void *ptr2 = nullptr;
+    size_t size = page_size;
+    size_t alignment = page_size;
+
+    umf_result =
+        umfMemoryProviderAlloc(provider.get(), size * 2, alignment, &ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr1, nullptr);
+
+    umf_result =
+        umfMemoryProviderAllocationSplit(provider.get(), ptr1, size * 2, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ptr2 = (void *)((uintptr_t)ptr1 + size);
+    memset(ptr1, 0x11, size);
+
+    umf_result = umfMemoryProviderFree(provider.get(), ptr1, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    memset(ptr2, 0x22, size);
+    umf_result = umfMemoryProviderFree(provider.get(), ptr2, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(FixedProviderTest, pool_from_ptr_whole_size_success) {
+    umf_result_t umf_result;
+    size_t size_of_first_alloc;
+    size_t size_of_pool_from_ptr;
+    void *ptr_for_pool = nullptr;
+    void *ptr = nullptr;
+
+    umf_memory_pool_handle_t proxyFixedPool = nullptr;
+    umf_result = umfPoolCreate(umfProxyPoolOps(), provider.get(), nullptr, 0,
+                               &proxyFixedPool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    size_of_first_alloc = FIXED_BUFFER_SIZE - (2 * page_size);
+    ptr_for_pool = umfPoolMalloc(proxyFixedPool, size_of_first_alloc);
+    ASSERT_NE(ptr_for_pool, nullptr);
+
+    // Create provider parameters
+    size_of_pool_from_ptr = size_of_first_alloc; // whole size
+    umf_fixed_memory_provider_params_handle_t params = nullptr;
+    umf_result = umfFixedMemoryProviderParamsCreate(&params, ptr_for_pool,
+                                                    size_of_pool_from_ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(params, nullptr);
+
+    umf_memory_provider_handle_t providerFromPtr = nullptr;
+    umf_result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
+                                         &providerFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(providerFromPtr, nullptr);
+
+    umf_memory_pool_handle_t poolFromPtr = nullptr;
+    umf_result = umfPoolCreate(umfProxyPoolOps(), providerFromPtr, nullptr, 0,
+                               &poolFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ptr = umfPoolMalloc(poolFromPtr, size_of_pool_from_ptr);
+    ASSERT_NE(ptr, nullptr);
+
+    memset(ptr, 0xFF, size_of_pool_from_ptr);
+
+    umf_result = umfPoolFree(poolFromPtr, ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolDestroy(poolFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umfMemoryProviderDestroy(providerFromPtr);
+    umfFixedMemoryProviderParamsDestroy(params);
+
+    umf_result = umfPoolFree(proxyFixedPool, ptr_for_pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolDestroy(proxyFixedPool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(FixedProviderTest, pool_from_ptr_half_size_success) {
+    umf_result_t umf_result;
+    size_t size_of_first_alloc;
+    size_t size_of_pool_from_ptr;
+    void *ptr_for_pool = nullptr;
+    void *ptr = nullptr;
+
+    umf_memory_pool_handle_t proxyFixedPool = nullptr;
+    umf_result = umfPoolCreate(umfProxyPoolOps(), provider.get(), nullptr, 0,
+                               &proxyFixedPool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    size_of_first_alloc = FIXED_BUFFER_SIZE - (2 * page_size);
+    ptr_for_pool = umfPoolMalloc(proxyFixedPool, size_of_first_alloc);
+    ASSERT_NE(ptr_for_pool, nullptr);
+
+    // Create provider parameters
+    size_of_pool_from_ptr = size_of_first_alloc / 2; // half size
+    umf_fixed_memory_provider_params_handle_t params = nullptr;
+    umf_result = umfFixedMemoryProviderParamsCreate(&params, ptr_for_pool,
+                                                    size_of_pool_from_ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(params, nullptr);
+
+    umf_memory_provider_handle_t providerFromPtr = nullptr;
+    umf_result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
+                                         &providerFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(providerFromPtr, nullptr);
+
+    umf_memory_pool_handle_t poolFromPtr = nullptr;
+    umf_result = umfPoolCreate(umfProxyPoolOps(), providerFromPtr, nullptr, 0,
+                               &poolFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ptr = umfPoolMalloc(poolFromPtr, size_of_pool_from_ptr);
+    ASSERT_NE(ptr, nullptr);
+
+    memset(ptr, 0xFF, size_of_pool_from_ptr);
+
+    umf_result = umfPoolFree(poolFromPtr, ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolDestroy(poolFromPtr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umfMemoryProviderDestroy(providerFromPtr);
+    umfFixedMemoryProviderParamsDestroy(params);
+
+    umf_result = umfPoolFree(proxyFixedPool, ptr_for_pool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolDestroy(proxyFixedPool);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
diff --git a/test/provider_os_memory.cpp b/test/provider_os_memory.cpp
index 5b9de43fa..96396c18f 100644
--- a/test/provider_os_memory.cpp
+++ b/test/provider_os_memory.cpp
@@ -1,21 +1,24 @@
-// Copyright (C) 2023 Intel Corporation
+// Copyright (C) 2023-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 #include "base.hpp"
 
-#include "cpp_helpers.hpp"
+#include "ipcFixtures.hpp"
+#include "test_helpers.h"
+#include "utils/cpp_helpers.hpp"
 
 #include <umf/memory_provider.h>
+#include <umf/pools/pool_disjoint.h>
 #include <umf/providers/provider_os_memory.h>
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+#include <umf/pools/pool_jemalloc.h>
+#endif
 
 using umf_test::test;
 
 #define INVALID_PTR ((void *)0x01)
 
-#define ASSERT_IS_ALIGNED(ptr, alignment)                                      \
-    ASSERT_EQ(((uintptr_t)ptr % alignment), 0)
-
 typedef enum purge_t {
     PURGE_NONE = 0,
     PURGE_LAZY = 1,
@@ -41,19 +44,21 @@ 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 *>;
 
-umf::provider_unique_handle_t
-providerCreateExt(providerCreateExtParams params) {
+static void providerCreateExt(providerCreateExtParams params,
+                              umf_test::provider_unique_handle_t *handle) {
     umf_memory_provider_handle_t hProvider = nullptr;
     auto [provider_ops, provider_params] = params;
 
     auto ret =
         umfMemoryProviderCreate(provider_ops, provider_params, &hProvider);
-    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
-    EXPECT_NE(hProvider, nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hProvider, nullptr);
 
-    return umf::provider_unique_handle_t(hProvider, &umfMemoryProviderDestroy);
+    *handle = umf_test::provider_unique_handle_t(hProvider,
+                                                 &umfMemoryProviderDestroy);
 }
 
 struct umfProviderTest
@@ -61,17 +66,17 @@ struct umfProviderTest
       ::testing::WithParamInterface<providerCreateExtParams> {
     void SetUp() override {
         test::SetUp();
-        provider = providerCreateExt(this->GetParam());
+        providerCreateExt(this->GetParam(), &provider);
         umf_result_t umf_result =
             umfMemoryProviderGetMinPageSize(provider.get(), NULL, &page_size);
-        EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
         page_plus_64 = page_size + 64;
     }
 
     void TearDown() override { test::TearDown(); }
 
-    umf::provider_unique_handle_t provider;
+    umf_test::provider_unique_handle_t provider;
     size_t page_size;
     size_t page_plus_64;
 };
@@ -132,16 +137,23 @@ static umf_result_t create_os_provider_with_mode(umf_numa_mode_t mode,
                                                  unsigned node_list_size) {
     umf_result_t umf_result;
     umf_memory_provider_handle_t os_memory_provider = nullptr;
-    umf_os_memory_provider_params_t os_memory_provider_params =
-        umfOsMemoryProviderParamsDefault();
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
 
-    os_memory_provider_params.numa_mode = mode;
-    os_memory_provider_params.numa_list = node_list;
-    os_memory_provider_params.numa_list_len = node_list_size;
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-    umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(),
-                                         &os_memory_provider_params,
-                                         &os_memory_provider);
+    umf_result =
+        umfOsMemoryProviderParamsSetNumaMode(os_memory_provider_params, mode);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfOsMemoryProviderParamsSetNumaList(
+        os_memory_provider_params, node_list, node_list_size);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result =
+        umfMemoryProviderCreate(umfOsMemoryProviderOps(),
+                                os_memory_provider_params, &os_memory_provider);
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
     if (umf_result == UMF_RESULT_SUCCESS) {
         EXPECT_NE(os_memory_provider, nullptr);
         umfMemoryProviderDestroy(os_memory_provider);
@@ -187,29 +199,53 @@ TEST_F(test, create_ZERO_WEIGHT_PARTITION) {
     umf_numa_split_partition_t p = {0, 0};
     umf_result_t umf_result;
     umf_memory_provider_handle_t os_memory_provider = nullptr;
-    umf_os_memory_provider_params_t os_memory_provider_params =
-        umfOsMemoryProviderParamsDefault();
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = NULL;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfOsMemoryProviderParamsSetNumaMode(os_memory_provider_params,
+                                                      UMF_NUMA_MODE_SPLIT);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-    os_memory_provider_params.numa_mode = UMF_NUMA_MODE_SPLIT;
-    os_memory_provider_params.numa_list = &valid_list;
-    os_memory_provider_params.numa_list_len = valid_list_len;
-    os_memory_provider_params.partitions = &p;
-    os_memory_provider_params.partitions_len = 1;
+    umf_result = umfOsMemoryProviderParamsSetNumaList(
+        os_memory_provider_params, &valid_list, valid_list_len);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfOsMemoryProviderParamsSetPartitions(
+        os_memory_provider_params, &p, 1);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
     umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(),
                                          &os_memory_provider_params,
                                          &os_memory_provider);
 
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
     EXPECT_EQ(os_memory_provider, nullptr);
     ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
 
 // positive tests using test_alloc_free_success
 
-auto defaultParams = umfOsMemoryProviderParamsDefault();
+using os_params_unique_handle_t =
+    std::unique_ptr<umf_os_memory_provider_params_t,
+                    decltype(&umfOsMemoryProviderParamsDestroy)>;
+
+os_params_unique_handle_t createOsMemoryProviderParams() {
+    umf_os_memory_provider_params_handle_t params = nullptr;
+    umf_result_t res = umfOsMemoryProviderParamsCreate(&params);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error("Failed to create os memory provider params");
+    }
+
+    return os_params_unique_handle_t(params, &umfOsMemoryProviderParamsDestroy);
+}
+auto defaultParams = createOsMemoryProviderParams();
+
 INSTANTIATE_TEST_SUITE_P(osProviderTest, umfProviderTest,
                          ::testing::Values(providerCreateExtParams{
-                             umfOsMemoryProviderOps(), &defaultParams}));
+                             umfOsMemoryProviderOps(), defaultParams.get()}));
 
 TEST_P(umfProviderTest, create_destroy) {}
 
@@ -259,6 +295,12 @@ TEST_P(umfProviderTest, alloc_WRONG_SIZE) {
                        UMF_OS_RESULT_ERROR_ALLOC_FAILED);
 }
 
+TEST_P(umfProviderTest, alloc_MAX_SIZE) {
+    test_alloc_failure(provider.get(), SIZE_MAX, 0,
+                       UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC,
+                       UMF_OS_RESULT_ERROR_ALLOC_FAILED);
+}
+
 // other positive tests
 
 TEST_P(umfProviderTest, get_min_page_size) {
@@ -326,3 +368,136 @@ TEST_P(umfProviderTest, purge_force_INVALID_POINTER) {
     verify_last_native_error(provider.get(),
                              UMF_OS_RESULT_ERROR_PURGE_FORCE_FAILED);
 }
+
+TEST_P(umfProviderTest, get_ipc_handle_size_wrong_visibility) {
+    size_t size;
+    umf_result_t umf_result =
+        umfMemoryProviderGetIPCHandleSize(provider.get(), &size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(umfProviderTest, get_ipc_handle_wrong_visibility) {
+    char providerIpcData;
+    umf_result_t umf_result = umfMemoryProviderGetIPCHandle(
+        provider.get(), INVALID_PTR, 1, &providerIpcData);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(umfProviderTest, put_ipc_handle_wrong_visibility) {
+    char providerIpcData;
+    umf_result_t umf_result =
+        umfMemoryProviderPutIPCHandle(provider.get(), &providerIpcData);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(umfProviderTest, open_ipc_handle_wrong_visibility) {
+    char providerIpcData;
+    void *ptr;
+    umf_result_t umf_result =
+        umfMemoryProviderOpenIPCHandle(provider.get(), &providerIpcData, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(umfProviderTest, close_ipc_handle_wrong_visibility) {
+    umf_result_t umf_result =
+        umfMemoryProviderCloseIPCHandle(provider.get(), INVALID_PTR, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest);
+
+void *createOsMemoryProviderParamsShared() {
+    umf_os_memory_provider_params_handle_t params = nullptr;
+    umf_result_t res = umfOsMemoryProviderParamsCreate(&params);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error("Failed to create os memory provider params");
+    }
+    res = umfOsMemoryProviderParamsSetVisibility(params, UMF_MEM_MAP_SHARED);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error("Failed to set protection");
+    }
+
+    return params;
+}
+
+umf_result_t destroyOsMemoryProviderParamsShared(void *params) {
+    return umfOsMemoryProviderParamsDestroy(
+        static_cast<umf_os_memory_provider_params_handle_t>(params));
+}
+
+HostMemoryAccessor hostAccessor;
+
+void *createDisjointPoolParams() {
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    umf_result_t res = umfDisjointPoolParamsCreate(&params);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error("Failed to create pool params");
+    }
+    res = umfDisjointPoolParamsSetSlabMinSize(params, 4096);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfDisjointPoolParamsDestroy(params);
+        throw std::runtime_error("Failed to set slab min size");
+    }
+    res = umfDisjointPoolParamsSetMaxPoolableSize(params, 4096);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfDisjointPoolParamsDestroy(params);
+        throw std::runtime_error("Failed to set max poolable size");
+    }
+    res = umfDisjointPoolParamsSetCapacity(params, 4);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfDisjointPoolParamsDestroy(params);
+        throw std::runtime_error("Failed to set capacity");
+    }
+    res = umfDisjointPoolParamsSetMinBucketSize(params, 64);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfDisjointPoolParamsDestroy(params);
+        throw std::runtime_error("Failed to set min bucket size");
+    }
+
+    return params;
+}
+
+umf_result_t destroyDisjointPoolParams(void *params) {
+    return umfDisjointPoolParamsDestroy(
+        static_cast<umf_disjoint_pool_params_handle_t>(params));
+}
+
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+void *createJemallocParams() {
+    umf_jemalloc_pool_params_handle_t jemalloc_params = NULL;
+    umf_result_t res = umfJemallocPoolParamsCreate(&jemalloc_params);
+    if (res != UMF_RESULT_SUCCESS) {
+        throw std::runtime_error("Failed to create Jemalloc Pool params");
+    }
+
+    // This test creates multiple pools, so we need to reduce the number of arenas
+    // to avoid hitting the maximum arena limit on systems with many cores.
+    res = umfJemallocPoolParamsSetNumArenas(jemalloc_params, 1);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfJemallocPoolParamsDestroy(jemalloc_params);
+        throw std::runtime_error("Failed to set number of arenas for Jemalloc "
+                                 "Pool params");
+    }
+    return jemalloc_params;
+}
+
+umf_result_t destroyJemallocParams(void *params) {
+    return umfJemallocPoolParamsDestroy(
+        (umf_jemalloc_pool_params_handle_t)params);
+}
+
+#endif
+
+static std::vector<ipcTestParams> ipcTestParamsList = {
+    {umfDisjointPoolOps(), createDisjointPoolParams, destroyDisjointPoolParams,
+     umfOsMemoryProviderOps(), createOsMemoryProviderParamsShared,
+     destroyOsMemoryProviderParamsShared, &hostAccessor},
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+    {umfJemallocPoolOps(), createJemallocParams, destroyJemallocParams,
+     umfOsMemoryProviderOps(), createOsMemoryProviderParamsShared,
+     destroyOsMemoryProviderParamsShared, &hostAccessor},
+#endif
+};
+
+INSTANTIATE_TEST_SUITE_P(osProviderTest, umfIpcTest,
+                         ::testing::ValuesIn(ipcTestParamsList));
diff --git a/test/provider_os_memory_config.cpp b/test/provider_os_memory_config.cpp
index 78008f898..ed3456618 100644
--- a/test/provider_os_memory_config.cpp
+++ b/test/provider_os_memory_config.cpp
@@ -22,13 +22,16 @@ struct providerConfigTest : testing::Test {
     const size_t size = 128;
     void *ptr = nullptr;
     std::string dest = "destination";
-    umf_os_memory_provider_params_t params = umfOsMemoryProviderParamsDefault();
+    umf_os_memory_provider_params_handle_t params = nullptr;
 
     void SetUp() override {
         int ret = numa_available();
         if (ret) {
             GTEST_SKIP() << "Test skipped, NUMA not available";
         }
+
+        auto res = umfOsMemoryProviderParamsCreate(&params);
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
     }
 
     void TearDown() override {
@@ -38,9 +41,11 @@ struct providerConfigTest : testing::Test {
         if (provider) {
             umfMemoryProviderDestroy(provider);
         }
+
+        umfOsMemoryProviderParamsDestroy(params);
     }
 
-    void create_provider(umf_os_memory_provider_params_t *params) {
+    void create_provider(umf_os_memory_provider_params_handle_t params) {
         auto res = umfMemoryProviderCreate(umfOsMemoryProviderOps(), params,
                                            &provider);
         ASSERT_EQ(res, UMF_RESULT_SUCCESS);
@@ -68,9 +73,9 @@ struct providerConfigTest : testing::Test {
 
 TEST_F(providerConfigTest, protection_flag_none) {
     // pages may not be accessed - PROT_NONE
-    params.protection = UMF_PROTECTION_NONE;
+    umfOsMemoryProviderParamsSetProtection(params, UMF_PROTECTION_NONE);
 
-    create_provider(&params);
+    create_provider(params);
     allocate_memory();
 
     // read failure
@@ -82,9 +87,9 @@ TEST_F(providerConfigTest, protection_flag_none) {
 
 TEST_F(providerConfigTest, protection_flag_read) {
     // pages may be read - PROT_READ
-    params.protection = UMF_PROTECTION_READ;
+    umfOsMemoryProviderParamsSetProtection(params, UMF_PROTECTION_READ);
 
-    create_provider(&params);
+    create_provider(params);
     allocate_memory();
 
     // read success
@@ -96,9 +101,9 @@ TEST_F(providerConfigTest, protection_flag_read) {
 
 TEST_F(providerConfigTest, protection_flag_write) {
     // pages may be written to - PROT_WRITE
-    params.protection = UMF_PROTECTION_WRITE;
+    umfOsMemoryProviderParamsSetProtection(params, UMF_PROTECTION_WRITE);
 
-    create_provider(&params);
+    create_provider(params);
     allocate_memory();
 
     // write success
@@ -107,9 +112,10 @@ TEST_F(providerConfigTest, protection_flag_write) {
 
 TEST_F(providerConfigTest, protection_flag_read_write) {
     // pages may be read and written to - PROT_READ | PROT_WRITE
-    params.protection = UMF_PROTECTION_READ | UMF_PROTECTION_WRITE;
+    umfOsMemoryProviderParamsSetProtection(params, UMF_PROTECTION_READ |
+                                                       UMF_PROTECTION_WRITE);
 
-    create_provider(&params);
+    create_provider(params);
     allocate_memory();
 
     // read success
@@ -119,21 +125,115 @@ TEST_F(providerConfigTest, protection_flag_read_write) {
     write_memory("write string");
 }
 
+TEST_F(providerConfigTest, set_params_null_params_handle) {
+    umf_result_t res = umfOsMemoryProviderParamsCreate(nullptr);
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfOsMemoryProviderParamsDestroy(nullptr);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfOsMemoryProviderParamsSetProtection(nullptr, UMF_PROTECTION_READ);
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfOsMemoryProviderParamsSetVisibility(nullptr, UMF_MEM_MAP_PRIVATE);
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfOsMemoryProviderParamsSetShmName(nullptr, "shm_name");
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfOsMemoryProviderParamsSetNumaList(nullptr, nullptr, 0);
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfOsMemoryProviderParamsSetNumaMode(nullptr, UMF_NUMA_MODE_DEFAULT);
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfOsMemoryProviderParamsSetPartSize(nullptr, 0);
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfOsMemoryProviderParamsSetPartitions(nullptr, nullptr, 0);
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(providerConfigTest, set_params_shm_name) {
+    umf_result_t res = umfOsMemoryProviderParamsSetShmName(params, nullptr);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfOsMemoryProviderParamsSetShmName(params, "shm_name");
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfOsMemoryProviderParamsSetShmName(params, "");
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfOsMemoryProviderParamsSetShmName(params, nullptr);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+}
+
+TEST_F(providerConfigTest, set_params_numa_list) {
+    unsigned numa_list[1] = {0};
+
+    umf_result_t res = umfOsMemoryProviderParamsSetNumaList(params, nullptr, 0);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfOsMemoryProviderParamsSetNumaList(params, numa_list, 1);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfOsMemoryProviderParamsSetNumaList(params, nullptr, 1);
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfOsMemoryProviderParamsSetNumaList(params, numa_list, 0);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    // repeat the valid set to check memory leaks under Valgrind
+    res = umfOsMemoryProviderParamsSetNumaList(params, numa_list, 1);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+}
+
+TEST_F(providerConfigTest, set_params_partitions) {
+    umf_numa_split_partition_t partitions[1] = {{0, 1}};
+
+    umf_result_t res =
+        umfOsMemoryProviderParamsSetPartitions(params, nullptr, 0);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfOsMemoryProviderParamsSetPartitions(params, partitions, 1);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfOsMemoryProviderParamsSetPartitions(params, nullptr, 1);
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfOsMemoryProviderParamsSetPartitions(params, partitions, 0);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    // repeat the valid set to check memory leaks under Valgrind
+    res = umfOsMemoryProviderParamsSetPartitions(params, partitions, 1);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+}
+
 struct providerConfigTestNumaMode
     : providerConfigTest,
       testing::WithParamInterface<umf_numa_mode_t> {
     struct bitmask *allowed_nodes = nullptr;
-    umf_os_memory_provider_params_t params = umfOsMemoryProviderParamsDefault();
+    umf_numa_mode_t expected_numa_mode;
 
     void SetUp() override {
         providerConfigTest::SetUp();
-        params.numa_mode = GetParam();
+
+        if (::providerConfigTest::IsSkipped()) {
+            GTEST_SKIP();
+        }
+
+        expected_numa_mode = GetParam();
+
+        auto res =
+            umfOsMemoryProviderParamsSetNumaMode(params, expected_numa_mode);
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
     }
 
     void TearDown() override {
         if (allowed_nodes) {
             numa_bitmask_free(allowed_nodes);
         }
+
         providerConfigTest::TearDown();
     }
 };
@@ -152,24 +252,27 @@ INSTANTIATE_TEST_SUITE_P(numa_modes, providerConfigTestNumaMode,
 #endif
 
 TEST_P(providerConfigTestNumaMode, numa_modes) {
-    if (params.numa_mode != UMF_NUMA_MODE_DEFAULT &&
-        params.numa_mode != UMF_NUMA_MODE_LOCAL) {
+    unsigned numa_list_len = 0;
+    unsigned *numa_list = nullptr;
+    if (expected_numa_mode != UMF_NUMA_MODE_DEFAULT &&
+        expected_numa_mode != UMF_NUMA_MODE_LOCAL) {
         allowed_nodes = numa_get_mems_allowed();
         // convert bitmask to array of nodes
-        params.numa_list_len = numa_bitmask_weight(allowed_nodes);
-        params.numa_list = (unsigned *)malloc(params.numa_list_len *
-                                              sizeof(*params.numa_list));
-        ASSERT_NE(params.numa_list, nullptr);
+        numa_list_len = numa_bitmask_weight(allowed_nodes);
+        numa_list = (unsigned *)malloc(numa_list_len * sizeof(*numa_list));
+        ASSERT_NE(numa_list, nullptr);
         unsigned count = 0;
-        for (unsigned i = 0; i < params.numa_list_len; i++) {
+        for (unsigned i = 0; i < numa_list_len; i++) {
             if (numa_bitmask_isbitset(allowed_nodes, i)) {
-                params.numa_list[count++] = i;
+                numa_list[count++] = i;
             }
         }
-        ASSERT_EQ(count, params.numa_list_len);
+        ASSERT_EQ(count, numa_list_len);
+
+        umfOsMemoryProviderParamsSetNumaList(params, numa_list, numa_list_len);
     }
 
-    create_provider(&params);
+    create_provider(params);
     allocate_memory();
     write_memory("write string");
 
@@ -177,25 +280,25 @@ TEST_P(providerConfigTestNumaMode, numa_modes) {
     long ret = get_mempolicy(&actual_mode, nullptr, 0, ptr, MPOL_F_ADDR);
     ASSERT_EQ(ret, 0);
 
-    if (params.numa_mode == UMF_NUMA_MODE_DEFAULT) {
+    if (expected_numa_mode == UMF_NUMA_MODE_DEFAULT) {
         ASSERT_EQ(actual_mode, MPOL_DEFAULT);
-    } else if (params.numa_mode == UMF_NUMA_MODE_BIND) {
+    } else if (expected_numa_mode == UMF_NUMA_MODE_BIND) {
         ASSERT_EQ(actual_mode, MPOL_BIND);
-    } else if (params.numa_mode == UMF_NUMA_MODE_INTERLEAVE) {
+    } else if (expected_numa_mode == UMF_NUMA_MODE_INTERLEAVE) {
         ASSERT_EQ(actual_mode, MPOL_INTERLEAVE);
-    } else if (params.numa_mode == UMF_NUMA_MODE_PREFERRED) {
+    } else if (expected_numa_mode == UMF_NUMA_MODE_PREFERRED) {
         // MPOL_PREFERRED_MANY is equivalent to MPOL_PREFERRED if a single node is set
         if (actual_mode != MPOL_PREFERRED_MANY) {
             ASSERT_EQ(actual_mode, MPOL_PREFERRED);
         }
-    } else if (params.numa_mode == UMF_NUMA_MODE_LOCAL) {
+    } else if (expected_numa_mode == UMF_NUMA_MODE_LOCAL) {
         // MPOL_PREFERRED_* is equivalent to MPOL_LOCAL if no node is set
         if (actual_mode == MPOL_PREFERRED ||
             actual_mode == MPOL_PREFERRED_MANY) {
-            ASSERT_EQ(params.numa_list_len, 0);
+            ASSERT_EQ(numa_list_len, 0);
         } else {
             ASSERT_EQ(actual_mode, MPOL_LOCAL);
         }
     }
-    free(params.numa_list);
+    free(numa_list);
 }
diff --git a/test/provider_os_memory_multiple_numa_nodes.cpp b/test/provider_os_memory_multiple_numa_nodes.cpp
index 0f7f0fb2e..cfc58f2f0 100644
--- a/test/provider_os_memory_multiple_numa_nodes.cpp
+++ b/test/provider_os_memory_multiple_numa_nodes.cpp
@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 #include "base.hpp"
-#include "numa_helpers.h"
+#include "numa_helpers.hpp"
 #include "test_helpers.h"
 
 #include <algorithm>
@@ -14,12 +14,10 @@
 
 #include <umf/providers/provider_os_memory.h>
 
-static umf_os_memory_provider_params_t UMF_OS_MEMORY_PROVIDER_PARAMS_TEST =
-    umfOsMemoryProviderParamsDefault();
-
 std::vector<unsigned> get_available_numa_nodes() {
-    UT_ASSERTne(numa_available(), -1);
-    UT_ASSERTne(numa_all_nodes_ptr, nullptr);
+    if (numa_available() == -1 || numa_all_nodes_ptr == nullptr) {
+        return std::vector<unsigned>();
+    }
 
     std::vector<unsigned> available_numa_nodes;
     // Get all available NUMA nodes numbers.
@@ -41,7 +39,14 @@ std::vector<int> get_available_cpus() {
     CPU_ZERO(mask);
 
     int ret = sched_getaffinity(0, sizeof(cpu_set_t), mask);
-    UT_ASSERTeq(ret, 0);
+
+    if (ret != 0) {
+        available_cpus.emplace_back(-1);
+        CPU_FREE(mask);
+
+        return available_cpus;
+    }
+
     // Get all available cpus.
     printf("All CPUs: ");
     for (size_t i = 0; i < CPU_SETSIZE; ++i) {
@@ -57,9 +62,6 @@ std::vector<int> get_available_cpus() {
 }
 
 void set_all_available_nodemask_bits(bitmask *nodemask) {
-    UT_ASSERTne(numa_available(), -1);
-    UT_ASSERTne(numa_all_nodes_ptr, nullptr);
-
     numa_bitmask_clearall(nodemask);
 
     // Set all available NUMA nodes numbers.
@@ -80,23 +82,26 @@ struct testNuma : testing::Test {
         ASSERT_NE(nodemask, nullptr);
     }
 
-    void
-    initOsProvider(umf_os_memory_provider_params_t os_memory_provider_params) {
+    void initOsProvider(
+        umf_os_memory_provider_params_handle_t os_memory_provider_params) {
         umf_result_t umf_result;
         umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(),
-                                             &os_memory_provider_params,
+                                             os_memory_provider_params,
                                              &os_memory_provider);
         ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
         ASSERT_NE(os_memory_provider, nullptr);
     }
 
-    struct bitmask *retrieve_nodemask(void *addr) {
-        struct bitmask *retrieved_nodemask = numa_allocate_nodemask();
-        UT_ASSERTne(nodemask, nullptr);
-        int ret = get_mempolicy(nullptr, retrieved_nodemask->maskp,
+    void retrieve_nodemask(void *addr, bitmask **retrieved_nodemask) {
+        *retrieved_nodemask = numa_allocate_nodemask();
+
+        ASSERT_NE(nodemask, nullptr);
+        ASSERT_NE(*retrieved_nodemask, nullptr);
+
+        int ret = get_mempolicy(nullptr, (*retrieved_nodemask)->maskp,
                                 nodemask->size, addr, MPOL_F_ADDR);
-        UT_ASSERTeq(ret, 0);
-        return retrieved_nodemask;
+
+        ASSERT_EQ(ret, 0);
     }
 
     void TearDown() override {
@@ -122,29 +127,52 @@ struct testNuma : testing::Test {
 };
 
 struct testNumaOnEachNode : testNuma, testing::WithParamInterface<unsigned> {};
-struct testNumaOnEachCpu : testNuma, testing::WithParamInterface<int> {};
+
+/*
+ - In case of the lack of support for NUMA on the system
+ get_available_numa_nodes() returns an empty vector<unsigned>
+ - Then in INSTANTIATE_TEST_SUITE_P an empty container is passed as the 3rd arg
+ (param_generator)
+ - Therefore INSTANTIATE_TEST_SUITE_P expands to nothing, which causes the test
+ to fail in the test suite GoogleTestVerification
+- GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(testNumaOnEachNode) allows the
+test suite testNumaOnEachNode to be uninstantiated, suppressing
+the test failure
+- Additionally, the fixture testNumaOnEachNode uses SetUp from testNuma before
+running every test, thus the test is eventually skipped when the lack of NUMA
+support is determined by numa_available()
+- (Therefore probably a vector with dummy values could be returned instead of
+using the macro)
+*/
+GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(testNumaOnEachNode);
 
 INSTANTIATE_TEST_SUITE_P(testNumaNodesAllocations, testNumaOnEachNode,
                          ::testing::ValuesIn(get_available_numa_nodes()));
 
-INSTANTIATE_TEST_SUITE_P(testNumaNodesAllocationsAllCpus, testNumaOnEachCpu,
-                         ::testing::ValuesIn(get_available_cpus()));
-
 // Test for allocations on numa nodes. It will be executed on each of
 // the available numa nodes.
 TEST_P(testNumaOnEachNode, checkNumaNodesAllocations) {
     unsigned numa_node_number = GetParam();
     ASSERT_GE(numa_node_number, 0);
+    umf_result_t umf_result;
+
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
 
-    umf_os_memory_provider_params_t os_memory_provider_params =
-        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfOsMemoryProviderParamsSetNumaList(os_memory_provider_params,
+                                                      &numa_node_number, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfOsMemoryProviderParamsSetNumaMode(os_memory_provider_params,
+                                                      UMF_NUMA_MODE_BIND);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-    os_memory_provider_params.numa_list = &numa_node_number;
-    os_memory_provider_params.numa_list_len = 1;
-    os_memory_provider_params.numa_mode = UMF_NUMA_MODE_BIND;
     initOsProvider(os_memory_provider_params);
 
-    umf_result_t umf_result;
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
     umf_result =
         umfMemoryProviderAlloc(os_memory_provider, alloc_size, 0, &ptr);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
@@ -152,24 +180,32 @@ TEST_P(testNumaOnEachNode, checkNumaNodesAllocations) {
 
     // 'ptr' must point to an initialized value before retrieving its numa node
     memset(ptr, 0xFF, alloc_size);
-    int retrieved_numa_node_number = getNumaNodeByPtr(ptr);
-    EXPECT_EQ(retrieved_numa_node_number, numa_node_number);
+    EXPECT_NODE_EQ(ptr, numa_node_number);
 }
 
 // Test for allocations on numa nodes with mode preferred. It will be executed
 // on each of the available numa nodes.
 TEST_P(testNumaOnEachNode, checkModePreferred) {
     unsigned numa_node_number = GetParam();
-    umf_os_memory_provider_params_t os_memory_provider_params =
-        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
+    umf_result_t umf_result;
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-    os_memory_provider_params.numa_list = &numa_node_number;
+    umf_result = umfOsMemoryProviderParamsSetNumaList(os_memory_provider_params,
+                                                      &numa_node_number, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     numa_bitmask_setbit(nodemask, numa_node_number);
-    os_memory_provider_params.numa_list_len = 1;
-    os_memory_provider_params.numa_mode = UMF_NUMA_MODE_PREFERRED;
+
+    umf_result = umfOsMemoryProviderParamsSetNumaMode(os_memory_provider_params,
+                                                      UMF_NUMA_MODE_PREFERRED);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
     initOsProvider(os_memory_provider_params);
 
-    umf_result_t umf_result;
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
     umf_result =
         umfMemoryProviderAlloc(os_memory_provider, alloc_size, 0, &ptr);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
@@ -177,8 +213,7 @@ TEST_P(testNumaOnEachNode, checkModePreferred) {
 
     // 'ptr' must point to an initialized value before retrieving its numa node
     memset(ptr, 0xFF, alloc_size);
-    int retrieved_numa_node_number = getNumaNodeByPtr(ptr);
-    EXPECT_EQ(retrieved_numa_node_number, numa_node_number);
+    EXPECT_NODE_EQ(ptr, numa_node_number);
 }
 
 // Test for allocation on numa node with default mode enabled.
@@ -187,14 +222,19 @@ TEST_P(testNumaOnEachNode, checkModePreferred) {
 TEST_P(testNumaOnEachNode, checkModeDefaultSetMempolicy) {
     unsigned numa_node_number = GetParam();
     numa_bitmask_setbit(nodemask, numa_node_number);
-    umf_os_memory_provider_params_t os_memory_provider_params =
-        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
+    umf_result_t umf_result;
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
     initOsProvider(os_memory_provider_params);
 
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
     long ret = set_mempolicy(MPOL_BIND, nodemask->maskp, nodemask->size);
     ASSERT_EQ(ret, 0);
 
-    umf_result_t umf_result;
     umf_result =
         umfMemoryProviderAlloc(os_memory_provider, alloc_size, 0, &ptr);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
@@ -202,8 +242,7 @@ TEST_P(testNumaOnEachNode, checkModeDefaultSetMempolicy) {
 
     // 'ptr' must point to an initialized value before retrieving its numa node
     memset(ptr, 0xFF, alloc_size);
-    int retrieved_numa_node_number = getNumaNodeByPtr(ptr);
-    EXPECT_EQ(retrieved_numa_node_number, numa_node_number);
+    EXPECT_NODE_EQ(ptr, numa_node_number);
 }
 
 // Test for allocations on a single numa node with interleave mode enabled.
@@ -213,15 +252,24 @@ TEST_P(testNumaOnEachNode, checkModeInterleaveSingleNode) {
 
     constexpr int pages_num = 1024;
     size_t page_size = sysconf(_SC_PAGE_SIZE);
-    umf_os_memory_provider_params_t os_memory_provider_params =
-        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
+    umf_result_t umf_result;
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfOsMemoryProviderParamsSetNumaList(os_memory_provider_params,
+                                                      &numa_node_number, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfOsMemoryProviderParamsSetNumaMode(os_memory_provider_params,
+                                                      UMF_NUMA_MODE_INTERLEAVE);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-    os_memory_provider_params.numa_list = &numa_node_number;
-    os_memory_provider_params.numa_list_len = 1;
-    os_memory_provider_params.numa_mode = UMF_NUMA_MODE_INTERLEAVE;
     initOsProvider(os_memory_provider_params);
 
-    umf_result_t umf_result;
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
     umf_result = umfMemoryProviderAlloc(os_memory_provider,
                                         pages_num * page_size, 0, &ptr);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
@@ -229,10 +277,24 @@ TEST_P(testNumaOnEachNode, checkModeInterleaveSingleNode) {
 
     // 'ptr' must point to an initialized value before retrieving its numa node
     memset(ptr, 0xFF, pages_num * page_size);
-    int retrieved_numa_node_number = getNumaNodeByPtr(ptr);
-    EXPECT_EQ(retrieved_numa_node_number, numa_node_number);
+    EXPECT_NODE_EQ(ptr, numa_node_number);
 }
 
+struct testNumaOnEachCpu : testNuma, testing::WithParamInterface<int> {
+    void SetUp() override {
+        ::testNuma::SetUp();
+
+        int cpuNumber = this->GetParam();
+
+        if (cpuNumber < 0) {
+            GTEST_FAIL() << "get_available_cpus() error";
+        }
+    }
+};
+
+INSTANTIATE_TEST_SUITE_P(testNumaNodesAllocationsAllCpus, testNumaOnEachCpu,
+                         ::testing::ValuesIn(get_available_cpus()));
+
 // Test for allocation on numa node with mode preferred and an empty nodeset.
 // For the empty nodeset the memory is allocated on the node of the CPU that
 // triggered the allocation. It will be executed on each available CPU.
@@ -247,14 +309,22 @@ TEST_P(testNumaOnEachCpu, checkModePreferredEmptyNodeset) {
     int ret = sched_setaffinity(0, sizeof(cpu_set_t), mask);
     CPU_FREE(mask);
 
-    UT_ASSERTeq(ret, 0);
+    ASSERT_EQ(ret, 0);
+
+    umf_result_t umf_result;
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfOsMemoryProviderParamsSetNumaMode(os_memory_provider_params,
+                                                      UMF_NUMA_MODE_PREFERRED);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-    umf_os_memory_provider_params_t os_memory_provider_params =
-        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
-    os_memory_provider_params.numa_mode = UMF_NUMA_MODE_PREFERRED;
     initOsProvider(os_memory_provider_params);
 
-    umf_result_t umf_result;
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
     umf_result =
         umfMemoryProviderAlloc(os_memory_provider, alloc_size, 0, &ptr);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
@@ -262,15 +332,14 @@ TEST_P(testNumaOnEachCpu, checkModePreferredEmptyNodeset) {
 
     // Verify we're on the expected CPU
     int cpu_check = sched_getcpu();
-    UT_ASSERTeq(cpu, cpu_check);
+    ASSERT_EQ(cpu, cpu_check);
 
     int numa_node_number = numa_node_of_cpu(cpu);
     printf("Got CPU: %d, got numa node: %d\n", cpu, numa_node_number);
 
     // 'ptr' must point to an initialized value before retrieving its numa node
     memset(ptr, 0xFF, alloc_size);
-    int retrieved_numa_node_number = getNumaNodeByPtr(ptr);
-    EXPECT_EQ(retrieved_numa_node_number, numa_node_number);
+    EXPECT_NODE_EQ(ptr, numa_node_number);
 }
 
 // Test for allocation on numa node with local mode enabled. The memory is
@@ -285,14 +354,22 @@ TEST_P(testNumaOnEachCpu, checkModeLocal) {
     int ret = sched_setaffinity(0, sizeof(cpu_set_t), mask);
     CPU_FREE(mask);
 
-    UT_ASSERTeq(ret, 0);
+    ASSERT_EQ(ret, 0);
+
+    umf_result_t umf_result;
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfOsMemoryProviderParamsSetNumaMode(os_memory_provider_params,
+                                                      UMF_NUMA_MODE_LOCAL);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-    umf_os_memory_provider_params_t os_memory_provider_params =
-        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
-    os_memory_provider_params.numa_mode = UMF_NUMA_MODE_LOCAL;
     initOsProvider(os_memory_provider_params);
 
-    umf_result_t umf_result;
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
     umf_result =
         umfMemoryProviderAlloc(os_memory_provider, alloc_size, 0, &ptr);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
@@ -300,15 +377,14 @@ TEST_P(testNumaOnEachCpu, checkModeLocal) {
 
     // Verify we're on the expected CPU
     int cpu_check = sched_getcpu();
-    UT_ASSERTeq(cpu, cpu_check);
+    ASSERT_EQ(cpu, cpu_check);
 
     int numa_node_number = numa_node_of_cpu(cpu);
     printf("Got CPU: %d, got numa node: %d\n", cpu, numa_node_number);
 
     // 'ptr' must point to an initialized value before retrieving its numa node
     memset(ptr, 0xFF, alloc_size);
-    int retrieved_numa_node_number = getNumaNodeByPtr(ptr);
-    EXPECT_EQ(retrieved_numa_node_number, numa_node_number);
+    EXPECT_NODE_EQ(ptr, numa_node_number);
 }
 
 // Test for allocation on numa node with default mode enabled.
@@ -316,11 +392,16 @@ TEST_P(testNumaOnEachCpu, checkModeLocal) {
 // default policy - it allocates pages on the node of the CPU that triggered
 // the allocation.
 TEST_F(testNuma, checkModeDefault) {
-    umf_os_memory_provider_params_t os_memory_provider_params =
-        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
+    umf_result_t umf_result;
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
     initOsProvider(os_memory_provider_params);
 
-    umf_result_t umf_result;
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
     umf_result =
         umfMemoryProviderAlloc(os_memory_provider, alloc_size, 0, &ptr);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
@@ -332,8 +413,7 @@ TEST_F(testNuma, checkModeDefault) {
 
     // 'ptr' must point to an initialized value before retrieving its numa node
     memset(ptr, 0xFF, alloc_size);
-    int retrieved_numa_node_number = getNumaNodeByPtr(ptr);
-    EXPECT_EQ(retrieved_numa_node_number, numa_node_number);
+    EXPECT_NODE_EQ(ptr, numa_node_number);
 }
 
 // Test for allocations on numa nodes with interleave mode enabled.
@@ -341,18 +421,27 @@ TEST_F(testNuma, checkModeDefault) {
 TEST_F(testNuma, checkModeInterleave) {
     constexpr int pages_num = 1024;
     size_t page_size = sysconf(_SC_PAGE_SIZE);
-    umf_os_memory_provider_params_t os_memory_provider_params =
-        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
+    umf_result_t umf_result;
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
     std::vector<unsigned> numa_nodes = get_available_numa_nodes();
     set_all_available_nodemask_bits(nodemask);
 
-    os_memory_provider_params.numa_list = numa_nodes.data();
-    os_memory_provider_params.numa_list_len = numa_nodes.size();
-    os_memory_provider_params.numa_mode = UMF_NUMA_MODE_INTERLEAVE;
+    umf_result = umfOsMemoryProviderParamsSetNumaList(
+        os_memory_provider_params, numa_nodes.data(), numa_nodes.size());
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfOsMemoryProviderParamsSetNumaMode(os_memory_provider_params,
+                                                      UMF_NUMA_MODE_INTERLEAVE);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
     initOsProvider(os_memory_provider_params);
 
-    umf_result_t umf_result;
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
     umf_result = umfMemoryProviderAlloc(os_memory_provider,
                                         pages_num * page_size, 0, &ptr);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
@@ -363,14 +452,31 @@ TEST_F(testNuma, checkModeInterleave) {
 
     // Test where each page will be allocated.
     // Get the first numa node for ptr; Each next page is expected to be on next nodes.
-    size_t index = getNumaNodeByPtr((char *)ptr);
+    int node = -1;
+    ASSERT_NO_FATAL_FAILURE(getNumaNodeByPtr(ptr, &node));
+    ASSERT_GE(node, 0);
+    int index = -1;
+    for (size_t i = 0; i < numa_nodes.size(); i++) {
+        if (numa_nodes[i] == (unsigned)node) {
+            index = i;
+            break;
+        }
+    }
+    ASSERT_GE(index, 0);
+    ASSERT_LT(index, numa_nodes.size());
+
     for (size_t i = 1; i < (size_t)pages_num; i++) {
         index = (index + 1) % numa_nodes.size();
-        ASSERT_EQ(numa_nodes[index],
-                  getNumaNodeByPtr((char *)ptr + page_size * i));
+        EXPECT_NODE_EQ((char *)ptr + page_size * i, numa_nodes[index]);
+    }
+
+    bitmask *retrieved_nodemask = nullptr;
+    retrieve_nodemask(ptr, &retrieved_nodemask);
+
+    if (IS_SKIPPED_OR_FAILED()) {
+        return;
     }
 
-    bitmask *retrieved_nodemask = retrieve_nodemask(ptr);
     int ret = numa_bitmask_equal(retrieved_nodemask, nodemask);
     numa_bitmask_free(retrieved_nodemask);
 
@@ -385,20 +491,32 @@ TEST_F(testNuma, checkModeInterleaveCustomPartSize) {
     ASSERT_GT(_page_size, 0);
     size_t page_size = _page_size;
     size_t part_size = page_size * 100;
-    umf_os_memory_provider_params_t os_memory_provider_params =
-        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
+    umf_result_t umf_result;
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
     std::vector<unsigned> numa_nodes = get_available_numa_nodes();
 
-    os_memory_provider_params.numa_list = numa_nodes.data();
-    os_memory_provider_params.numa_list_len = numa_nodes.size();
-    os_memory_provider_params.numa_mode = UMF_NUMA_MODE_INTERLEAVE;
+    umf_result = umfOsMemoryProviderParamsSetNumaList(
+        os_memory_provider_params, numa_nodes.data(), numa_nodes.size());
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfOsMemoryProviderParamsSetNumaMode(os_memory_provider_params,
+                                                      UMF_NUMA_MODE_INTERLEAVE);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
     // part size do not need to be multiple of page size
-    os_memory_provider_params.part_size = part_size - 1;
+    umf_result = umfOsMemoryProviderParamsSetPartSize(os_memory_provider_params,
+                                                      part_size - 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
     initOsProvider(os_memory_provider_params);
 
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
     size_t size = part_num * part_size;
-    umf_result_t umf_result;
     umf_result = umfMemoryProviderAlloc(os_memory_provider, size, 0, &ptr);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_NE(ptr, nullptr);
@@ -407,13 +525,22 @@ TEST_F(testNuma, checkModeInterleaveCustomPartSize) {
     memset(ptr, 0xFF, size);
     // Test where each page will be allocated.
     // Get the first numa node for ptr; Each next part is expected to be on next nodes.
-    size_t index = getNumaNodeByPtr((char *)ptr);
+    int node = -1;
+    ASSERT_NO_FATAL_FAILURE(getNumaNodeByPtr(ptr, &node));
+    ASSERT_GE(node, 0);
+    int index = -1;
+    for (size_t i = 0; i < numa_nodes.size(); i++) {
+        if (numa_nodes[i] == (unsigned)node) {
+            index = i;
+            break;
+        }
+    }
+    ASSERT_GE(index, 0);
+    ASSERT_LT(index, numa_nodes.size());
+
     for (size_t i = 0; i < (size_t)part_num; i++) {
         for (size_t j = 0; j < part_size; j += page_size) {
-            EXPECT_EQ(numa_nodes[index],
-                      getNumaNodeByPtr((char *)ptr + part_size * i + j))
-                << "for ptr " << ptr << " + " << part_size << " * " << i
-                << " + " << j;
+            ASSERT_NODE_EQ((char *)ptr + part_size * i + j, numa_nodes[index]);
         }
         index = (index + 1) % numa_nodes.size();
     }
@@ -425,7 +552,7 @@ TEST_F(testNuma, checkModeInterleaveCustomPartSize) {
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_NE(ptr, nullptr);
     memset(ptr, 0xFF, size);
-    EXPECT_EQ(numa_nodes[index], getNumaNodeByPtr(ptr));
+    EXPECT_NODE_EQ(ptr, numa_nodes[index]);
     umfMemoryProviderFree(os_memory_provider, ptr, size);
 }
 
@@ -545,9 +672,7 @@ TEST_P(testNumaSplit, checkModeSplit) {
     ASSERT_GT(_page_size, 0);
     size_t page_size = _page_size;
     auto [required_numa_nodes, pages, in, out] = param;
-
-    umf_os_memory_provider_params_t os_memory_provider_params =
-        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
+    umf_result_t umf_result;
 
     std::vector<unsigned> numa_nodes = get_available_numa_nodes();
 
@@ -555,6 +680,11 @@ TEST_P(testNumaSplit, checkModeSplit) {
         GTEST_SKIP_("Not enough numa nodes");
     }
 
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
     ASSERT_EQ(out.size(), pages)
         << "Wrong test input - out array size doesn't match page count";
 
@@ -566,16 +696,24 @@ TEST_P(testNumaSplit, checkModeSplit) {
                      numa_nodes.begin() + required_numa_nodes, g);
     }
 
-    os_memory_provider_params.numa_list = numa_nodes.data();
-    os_memory_provider_params.numa_list_len = required_numa_nodes;
-    os_memory_provider_params.numa_mode = UMF_NUMA_MODE_SPLIT;
+    umf_result = umfOsMemoryProviderParamsSetNumaList(
+        os_memory_provider_params, numa_nodes.data(), required_numa_nodes);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfOsMemoryProviderParamsSetNumaMode(os_memory_provider_params,
+                                                      UMF_NUMA_MODE_SPLIT);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfOsMemoryProviderParamsSetPartitions(
+        os_memory_provider_params, in.data(), in.size());
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-    os_memory_provider_params.partitions = in.data();
-    os_memory_provider_params.partitions_len = in.size();
     initOsProvider(os_memory_provider_params);
 
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
     size_t size = page_size * pages;
-    umf_result_t umf_result;
+
     umf_result = umfMemoryProviderAlloc(os_memory_provider, size, 0, &ptr);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_NE(ptr, nullptr);
@@ -609,17 +747,26 @@ TEST_P(testNumaSplit, checkModeSplit) {
 // Test for allocations on all numa nodes with BIND mode.
 // According to mbind it should go to the closest node.
 TEST_F(testNuma, checkModeBindOnAllNodes) {
-    umf_os_memory_provider_params_t os_memory_provider_params =
-        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
+    umf_result_t umf_result;
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
     std::vector<unsigned> numa_nodes = get_available_numa_nodes();
 
-    os_memory_provider_params.numa_list = numa_nodes.data();
-    os_memory_provider_params.numa_list_len = numa_nodes.size();
-    os_memory_provider_params.numa_mode = UMF_NUMA_MODE_BIND;
+    umf_result = umfOsMemoryProviderParamsSetNumaList(
+        os_memory_provider_params, numa_nodes.data(), numa_nodes.size());
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfOsMemoryProviderParamsSetNumaMode(os_memory_provider_params,
+                                                      UMF_NUMA_MODE_BIND);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
     initOsProvider(os_memory_provider_params);
 
-    umf_result_t umf_result;
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
     umf_result =
         umfMemoryProviderAlloc(os_memory_provider, alloc_size, 0, &ptr);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
@@ -627,7 +774,10 @@ TEST_F(testNuma, checkModeBindOnAllNodes) {
 
     // 'ptr' must point to an initialized value before retrieving its numa node
     memset(ptr, 0xFF, alloc_size);
-    unsigned retrieved_numa_node_number = (unsigned)getNumaNodeByPtr(ptr);
+
+    int node = -1;
+    ASSERT_NO_FATAL_FAILURE(getNumaNodeByPtr(ptr, &node));
+    unsigned retrieved_numa_node_number = (unsigned)node;
 
     int read_cpu = sched_getcpu();
     int read_numa_node = numa_node_of_cpu(read_cpu);
@@ -650,19 +800,28 @@ TEST_F(testNuma, checkModeBindOnAllNodes) {
 // Local mode enabled when numa_list is set.
 // For the local mode the nodeset must be empty.
 TEST_F(testNuma, checkModeLocalIllegalArgSet) {
-    umf_os_memory_provider_params_t os_memory_provider_params =
-        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
+    umf_result_t umf_result;
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
     std::vector<unsigned> numa_nodes = get_available_numa_nodes();
 
-    os_memory_provider_params.numa_list = numa_nodes.data();
-    os_memory_provider_params.numa_list_len = numa_nodes.size();
-    os_memory_provider_params.numa_mode = UMF_NUMA_MODE_LOCAL;
+    umf_result = umfOsMemoryProviderParamsSetNumaList(
+        os_memory_provider_params, numa_nodes.data(), numa_nodes.size());
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfOsMemoryProviderParamsSetNumaMode(os_memory_provider_params,
+                                                      UMF_NUMA_MODE_LOCAL);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-    umf_result_t umf_result;
     umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(),
                                          &os_memory_provider_params,
                                          &os_memory_provider);
+
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
     ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
     ASSERT_EQ(os_memory_provider, nullptr);
 }
@@ -670,18 +829,24 @@ TEST_F(testNuma, checkModeLocalIllegalArgSet) {
 // Default mode enabled when numa_list is set.
 // For the default mode the nodeset must be empty.
 TEST_F(testNuma, checkModeDefaultIllegalArgSet) {
-    umf_os_memory_provider_params_t os_memory_provider_params =
-        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
+    umf_result_t umf_result;
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
     std::vector<unsigned> numa_nodes = get_available_numa_nodes();
 
-    os_memory_provider_params.numa_list = numa_nodes.data();
-    os_memory_provider_params.numa_list_len = numa_nodes.size();
+    umf_result = umfOsMemoryProviderParamsSetNumaList(
+        os_memory_provider_params, numa_nodes.data(), numa_nodes.size());
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
 
-    umf_result_t umf_result;
     umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(),
                                          &os_memory_provider_params,
                                          &os_memory_provider);
+
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
     ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
     ASSERT_EQ(os_memory_provider, nullptr);
 }
@@ -689,14 +854,22 @@ TEST_F(testNuma, checkModeDefaultIllegalArgSet) {
 // Bind mode enabled when numa_list is not set.
 // For the bind mode the nodeset must be non-empty.
 TEST_F(testNuma, checkModeBindIllegalArgSet) {
-    umf_os_memory_provider_params_t os_memory_provider_params =
-        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
-    os_memory_provider_params.numa_mode = UMF_NUMA_MODE_BIND;
-
     umf_result_t umf_result;
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfOsMemoryProviderParamsSetNumaMode(os_memory_provider_params,
+                                                      UMF_NUMA_MODE_BIND);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
     umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(),
                                          &os_memory_provider_params,
                                          &os_memory_provider);
+
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
     ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
     ASSERT_EQ(os_memory_provider, nullptr);
 }
@@ -704,14 +877,53 @@ TEST_F(testNuma, checkModeBindIllegalArgSet) {
 // Interleave mode enabled numa_list is not set.
 // For the interleave mode the nodeset must be non-empty.
 TEST_F(testNuma, checkModeInterleaveIllegalArgSet) {
-    umf_os_memory_provider_params_t os_memory_provider_params =
-        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
-    os_memory_provider_params.numa_mode = UMF_NUMA_MODE_INTERLEAVE;
-
     umf_result_t umf_result;
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+
+    umf_result = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfOsMemoryProviderParamsSetNumaMode(os_memory_provider_params,
+                                                      UMF_NUMA_MODE_INTERLEAVE);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
     umf_result = umfMemoryProviderCreate(umfOsMemoryProviderOps(),
                                          &os_memory_provider_params,
                                          &os_memory_provider);
+
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
     ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
     ASSERT_EQ(os_memory_provider, nullptr);
 }
+
+// Interleave mode set with SIZE_MAX part size
+TEST_F(testNuma, maxPartSize) {
+    std::vector<unsigned> numa_nodes = get_available_numa_nodes();
+
+    umf_os_memory_provider_params_handle_t os_memory_provider_params = nullptr;
+
+    auto res = umfOsMemoryProviderParamsCreate(&os_memory_provider_params);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfOsMemoryProviderParamsSetNumaMode(os_memory_provider_params,
+                                               UMF_NUMA_MODE_INTERLEAVE);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfOsMemoryProviderParamsSetPartSize(os_memory_provider_params,
+                                               SIZE_MAX);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfOsMemoryProviderParamsSetNumaList(
+        os_memory_provider_params, numa_nodes.data(), numa_nodes.size());
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+    res = umfMemoryProviderCreate(umfOsMemoryProviderOps(),
+                                  &os_memory_provider_params,
+                                  &os_memory_provider);
+
+    umfOsMemoryProviderParamsDestroy(os_memory_provider_params);
+
+    ASSERT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(os_memory_provider, nullptr);
+}
diff --git a/test/provider_os_memory_not_impl.cpp b/test/provider_os_memory_not_impl.cpp
new file mode 100644
index 000000000..127ba32e4
--- /dev/null
+++ b/test/provider_os_memory_not_impl.cpp
@@ -0,0 +1,46 @@
+// Copyright (C) 2024-2025 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "base.hpp"
+
+#include <umf/providers/provider_os_memory.h>
+
+using umf_test::test;
+
+TEST_F(test, os_provider_not_implemented) {
+    umf_os_memory_provider_params_handle_t params = nullptr;
+    umf_result_t umf_result = umfOsMemoryProviderParamsCreate(&params);
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    EXPECT_EQ(params, nullptr);
+
+    umf_result = umfOsMemoryProviderParamsDestroy(params);
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    umf_result = umfOsMemoryProviderParamsSetProtection(params, 0);
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    umf_result =
+        umfOsMemoryProviderParamsSetVisibility(params, UMF_MEM_MAP_PRIVATE);
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    umf_result = umfOsMemoryProviderParamsSetShmName(params, "shm_name");
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    umf_result = umfOsMemoryProviderParamsSetNumaList(params, nullptr, 0);
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    umf_result =
+        umfOsMemoryProviderParamsSetNumaMode(params, UMF_NUMA_MODE_DEFAULT);
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    umf_result = umfOsMemoryProviderParamsSetPartSize(params, 4096);
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    umf_numa_split_partition_t partitions[1];
+    umf_result = umfOsMemoryProviderParamsSetPartitions(params, partitions, 1);
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    const umf_memory_provider_ops_t *ops = umfOsMemoryProviderOps();
+    EXPECT_EQ(ops, nullptr);
+}
diff --git a/test/provider_tracking.cpp b/test/provider_tracking.cpp
new file mode 100644
index 000000000..b41ff6012
--- /dev/null
+++ b/test/provider_tracking.cpp
@@ -0,0 +1,389 @@
+// 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 "base.hpp"
+
+#include "test_helpers.h"
+#include "utils/cpp_helpers.hpp"
+#ifndef _WIN32
+#include "test_helpers_linux.h"
+#endif
+
+#include <umf/memory_provider.h>
+#include <umf/pools/pool_proxy.h>
+#include <umf/providers/provider_fixed_memory.h>
+
+using umf_test::test;
+
+#define FIXED_BUFFER_SIZE (512 * utils_get_page_size())
+#define INVALID_PTR ((void *)0x01)
+
+using providerCreateExtParams =
+    std::tuple<const umf_memory_provider_ops_t *, void *>;
+
+static void providerCreateExt(providerCreateExtParams params,
+                              umf_test::provider_unique_handle_t *handle) {
+    umf_memory_provider_handle_t hProvider = nullptr;
+    auto [provider_ops, provider_params] = params;
+
+    auto ret =
+        umfMemoryProviderCreate(provider_ops, provider_params, &hProvider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hProvider, nullptr);
+
+    *handle = umf_test::provider_unique_handle_t(hProvider,
+                                                 &umfMemoryProviderDestroy);
+}
+
+struct TrackingProviderTest
+    : umf_test::test,
+      ::testing::WithParamInterface<providerCreateExtParams> {
+    void SetUp() override {
+        test::SetUp();
+
+        // Allocate a memory buffer to use with the fixed memory provider
+        memory_size = FIXED_BUFFER_SIZE;
+        memory_buffer = malloc(memory_size);
+        ASSERT_NE(memory_buffer, nullptr);
+
+        // Create provider parameters
+        umf_fixed_memory_provider_params_handle_t params = nullptr;
+        umf_result_t res = umfFixedMemoryProviderParamsCreate(
+            &params, memory_buffer, memory_size);
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+        ASSERT_NE(params, nullptr);
+
+        providerCreateExt(std::make_tuple(umfFixedMemoryProviderOps(), params),
+                          &provider);
+
+        umfFixedMemoryProviderParamsDestroy(params);
+        umf_result_t umf_result =
+            umfMemoryProviderGetMinPageSize(provider.get(), NULL, &page_size);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+        page_plus_64 = page_size + 64;
+
+        umf_memory_pool_handle_t hPool = nullptr;
+        umf_result = umfPoolCreate(umfProxyPoolOps(), provider.get(), nullptr,
+                                   0, &hPool);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+        pool = umf_test::pool_unique_handle_t(hPool, &umfPoolDestroy);
+    }
+
+    void TearDown() override {
+        if (memory_buffer) {
+            free(memory_buffer);
+            memory_buffer = nullptr;
+        }
+        test::TearDown();
+    }
+
+    umf_test::provider_unique_handle_t provider;
+    umf_test::pool_unique_handle_t pool;
+    size_t page_size;
+    size_t page_plus_64;
+    void *memory_buffer = nullptr;
+    size_t memory_size = 0;
+};
+
+static void
+createPoolFromAllocation(void *ptr0, size_t size1,
+                         umf_memory_provider_handle_t *_providerFromPtr,
+                         umf_memory_pool_handle_t *_poolFromPtr) {
+    umf_result_t umf_result;
+
+    // Create provider parameters
+    umf_fixed_memory_provider_params_handle_t params = nullptr;
+    umf_result = umfFixedMemoryProviderParamsCreate(&params, ptr0, size1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(params, nullptr);
+
+    umf_memory_provider_handle_t provider1 = nullptr;
+    umf_result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
+                                         &provider1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider1, nullptr);
+
+    umf_memory_pool_handle_t pool1 = nullptr;
+    umf_result =
+        umfPoolCreate(umfProxyPoolOps(), provider1, nullptr, 0, &pool1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfFixedMemoryProviderParamsDestroy(params);
+
+    *_providerFromPtr = provider1;
+    *_poolFromPtr = pool1;
+}
+
+// TESTS
+
+INSTANTIATE_TEST_SUITE_P(trackingProviderTest, TrackingProviderTest,
+                         ::testing::Values(providerCreateExtParams{
+                             umfFixedMemoryProviderOps(), nullptr}));
+
+TEST_P(TrackingProviderTest, create_destroy) {
+    // Creation and destruction are handled in SetUp and TearDown
+}
+
+TEST_P(TrackingProviderTest, whole_size_success) {
+    umf_result_t umf_result;
+    size_t size0;
+    size_t size1;
+    void *ptr0 = nullptr;
+    void *ptr1 = nullptr;
+
+    umf_memory_pool_handle_t pool0 = pool.get();
+
+    size0 = FIXED_BUFFER_SIZE - (2 * page_size);
+    ptr0 = umfPoolAlignedMalloc(pool0, size0, utils_get_page_size());
+    ASSERT_NE(ptr0, nullptr);
+
+    size1 = size0; // whole size
+
+    umf_memory_provider_handle_t provider1 = nullptr;
+    umf_memory_pool_handle_t pool1 = nullptr;
+    createPoolFromAllocation(ptr0, size1, &provider1, &pool1);
+
+    ptr1 = umfPoolMalloc(pool1, size1);
+    ASSERT_NE(ptr1, nullptr);
+
+    umf_result = umfPoolFree(pool1, ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolDestroy(pool1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(provider1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolFree(pool0, ptr0);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(TrackingProviderTest, half_size_success) {
+    umf_result_t umf_result;
+    size_t size0;
+    size_t size1;
+    void *ptr0 = nullptr;
+    void *ptr1 = nullptr;
+
+    umf_memory_pool_handle_t pool0 = pool.get();
+
+    size0 = FIXED_BUFFER_SIZE - (2 * page_size);
+    ptr0 = umfPoolAlignedMalloc(pool0, size0, utils_get_page_size());
+    ASSERT_NE(ptr0, nullptr);
+
+    size1 = size0 / 2; // half size
+
+    umf_memory_provider_handle_t provider1 = nullptr;
+    umf_memory_pool_handle_t pool1 = nullptr;
+    createPoolFromAllocation(ptr0, size1, &provider1, &pool1);
+
+    ptr1 = umfPoolMalloc(pool1, size1);
+    ASSERT_NE(ptr1, nullptr);
+
+    umf_result = umfPoolFree(pool1, ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolDestroy(pool1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(provider1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolFree(pool0, ptr0);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+TEST_P(TrackingProviderTest, failure_exceeding_size) {
+    umf_result_t umf_result;
+    size_t size0;
+    size_t size1;
+    void *ptr0 = nullptr;
+    void *ptr1 = nullptr;
+
+    umf_memory_pool_handle_t pool0 = pool.get();
+
+    size0 = FIXED_BUFFER_SIZE - (2 * page_size);
+    ptr0 = umfPoolAlignedMalloc(pool0, size0, utils_get_page_size());
+    ASSERT_NE(ptr0, nullptr);
+
+    size1 = FIXED_BUFFER_SIZE - page_size; // exceeding size
+
+    umf_memory_provider_handle_t provider1 = nullptr;
+    umf_memory_pool_handle_t pool1 = nullptr;
+    createPoolFromAllocation(ptr0, size1, &provider1, &pool1);
+
+    ptr1 = umfPoolMalloc(pool1, size1);
+    ASSERT_EQ(ptr1, nullptr);
+
+    umf_result = umfPoolDestroy(pool1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(provider1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolFree(pool0, ptr0);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+}
+
+#define MAX_ARRAY 9
+#define TEST_LEVEL_SUCCESS 7
+#define TEST_LEVEL_FAILURE 8
+
+TEST_P(TrackingProviderTest, success_max_levels) {
+    umf_result_t umf_result;
+    size_t size;
+    void *ptr[MAX_ARRAY] = {0};
+    umf_memory_provider_handle_t providers[MAX_ARRAY] = {0};
+    umf_memory_pool_handle_t pools[MAX_ARRAY] = {0};
+
+    size = FIXED_BUFFER_SIZE - (2 * page_size);
+    pools[0] = pool.get();
+
+    for (int i = 0; i < TEST_LEVEL_SUCCESS; i++) {
+        fprintf(stderr, "Alloc #%d\n", i);
+        ptr[i] = umfPoolAlignedMalloc(pools[i], size, utils_get_page_size());
+        ASSERT_NE(ptr[i], nullptr);
+
+        createPoolFromAllocation(ptr[i], size, &providers[i + 1],
+                                 &pools[i + 1]);
+    }
+
+    int s = TEST_LEVEL_SUCCESS;
+    fprintf(stderr, "Alloc #%d\n", s);
+    ptr[s] = umfPoolAlignedMalloc(pools[s], size, utils_get_page_size());
+    ASSERT_NE(ptr[s], nullptr);
+
+    fprintf(stderr, "Free #%d\n", s);
+    umf_result = umfPoolFree(pools[s], ptr[s]);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    for (int i = TEST_LEVEL_SUCCESS - 1; i >= 0; i--) {
+        umf_result = umfPoolDestroy(pools[i + 1]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        umf_result = umfMemoryProviderDestroy(providers[i + 1]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+        fprintf(stderr, "Free #%d\n", i);
+        umf_result = umfPoolFree(pools[i], ptr[i]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+}
+
+TEST_P(TrackingProviderTest, failure_exceeding_levels) {
+    umf_result_t umf_result;
+    size_t size;
+    void *ptr[MAX_ARRAY] = {0};
+    umf_memory_provider_handle_t providers[MAX_ARRAY] = {0};
+    umf_memory_pool_handle_t pools[MAX_ARRAY] = {0};
+
+    size = FIXED_BUFFER_SIZE - (2 * page_size);
+    pools[0] = pool.get();
+
+    for (int i = 0; i < TEST_LEVEL_FAILURE; i++) {
+        fprintf(stderr, "Alloc #%d\n", i);
+        ptr[i] = umfPoolAlignedMalloc(pools[i], size, utils_get_page_size());
+        ASSERT_NE(ptr[i], nullptr);
+
+        createPoolFromAllocation(ptr[i], size, &providers[i + 1],
+                                 &pools[i + 1]);
+    }
+
+    // tracker level is too high
+    int f = TEST_LEVEL_FAILURE;
+    fprintf(stderr, "Alloc #%d\n", f);
+    ptr[f] = umfPoolAlignedMalloc(pools[f], size, utils_get_page_size());
+    ASSERT_EQ(ptr[f], nullptr);
+
+    for (int i = TEST_LEVEL_FAILURE - 1; i >= 0; i--) {
+        umf_result = umfPoolDestroy(pools[i + 1]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+        umf_result = umfMemoryProviderDestroy(providers[i + 1]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+        fprintf(stderr, "Free #%d\n", i);
+        umf_result = umfPoolFree(pools[i], ptr[i]);
+        ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    }
+}
+
+TEST_P(TrackingProviderTest, reverted_free_half_size) {
+    umf_result_t umf_result;
+    size_t size0;
+    size_t size1;
+    void *ptr0 = nullptr;
+    void *ptr1 = nullptr;
+
+    umf_memory_pool_handle_t pool0 = pool.get();
+
+    size0 = FIXED_BUFFER_SIZE - (2 * page_size);
+    ptr0 = umfPoolAlignedMalloc(pool0, size0, utils_get_page_size());
+    ASSERT_NE(ptr0, nullptr);
+
+    umf_memory_provider_handle_t provider1 = nullptr;
+    umf_memory_pool_handle_t pool1 = nullptr;
+    createPoolFromAllocation(ptr0, size0, &provider1, &pool1);
+
+    size1 = size0 / 2; // half size
+
+    ptr1 = umfPoolMalloc(pool1, size1);
+    ASSERT_NE(ptr1, nullptr);
+
+    // Freeing the "busy" pointer from the first pool is an Undefined Behavior
+    // It fails now if the sizes are different.
+    // see: https://github.com/oneapi-src/unified-memory-framework/pull/1161
+    umf_result = umfPoolFree(pool0, ptr0);
+
+    umf_result = umfPoolFree(pool1, ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolDestroy(pool1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(provider1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // It could have been freed above,
+    // so we cannot verify the result here.
+    umf_result = umfPoolFree(pool0, ptr0);
+}
+
+TEST_P(TrackingProviderTest, reverted_free_the_same_size) {
+    umf_result_t umf_result;
+    size_t size0;
+    size_t size1;
+    void *ptr0 = nullptr;
+    void *ptr1 = nullptr;
+
+    umf_memory_pool_handle_t pool0 = pool.get();
+
+    size0 = FIXED_BUFFER_SIZE - (2 * page_size);
+    ptr0 = umfPoolAlignedMalloc(pool0, size0, utils_get_page_size());
+    ASSERT_NE(ptr0, nullptr);
+
+    umf_memory_provider_handle_t provider1 = nullptr;
+    umf_memory_pool_handle_t pool1 = nullptr;
+    createPoolFromAllocation(ptr0, size0, &provider1, &pool1);
+
+    size1 = size0; // the same size
+
+    ptr1 = umfPoolMalloc(pool1, size1);
+    ASSERT_NE(ptr1, nullptr);
+
+    // Freeing the "busy" pointer from the first pool is an Undefined Behavior
+    // It succeeds now if the sizes are equal.
+    // see: https://github.com/oneapi-src/unified-memory-framework/pull/1161
+    umf_result = umfPoolFree(pool0, ptr0);
+
+    // try to free the pointer from the second pool (the same size)
+    umf_result = umfPoolFree(pool1, ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfPoolDestroy(pool1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    umf_result = umfMemoryProviderDestroy(provider1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // It could have been freed above,
+    // so we cannot verify the result here.
+    umf_result = umfPoolFree(pool0, ptr0);
+}
diff --git a/test/provider_tracking_fixture_tests.cpp b/test/provider_tracking_fixture_tests.cpp
new file mode 100644
index 000000000..8ab708275
--- /dev/null
+++ b/test/provider_tracking_fixture_tests.cpp
@@ -0,0 +1,92 @@
+// Copyright (C) 2025 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <umf/memory_provider.h>
+#include <umf/pools/pool_proxy.h>
+#include <umf/providers/provider_file_memory.h>
+
+#include "base.hpp"
+#include "provider.hpp"
+
+#include "test_helpers.h"
+#include "utils/cpp_helpers.hpp"
+#ifndef _WIN32
+#include "test_helpers_linux.h"
+#endif
+
+#include "poolFixtures.hpp"
+
+#define FILE_PATH ((char *)"tmp_file")
+
+struct provider_from_pool : public umf_test::provider_base_t {
+    umf_memory_pool_handle_t pool;
+    umf_result_t initialize(const umf_memory_pool_t *_pool) noexcept {
+        if (!_pool) {
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+        // drop const qualifier
+        pool = (umf_memory_pool_handle_t)_pool;
+        return UMF_RESULT_SUCCESS;
+    }
+    umf_result_t alloc(size_t size, size_t align, void **ptr) noexcept {
+        *ptr = umfPoolAlignedMalloc(pool, size, align);
+        return (*ptr) ? UMF_RESULT_SUCCESS
+                      : UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+    umf_result_t free(void *ptr, size_t) noexcept {
+        return umfPoolFree(pool, ptr);
+    }
+    const char *get_name() noexcept { return "provider_from_pool"; }
+
+    virtual ~provider_from_pool() {
+        if (pool) {
+            umfPoolDestroy(pool);
+            pool = nullptr;
+        }
+    }
+};
+
+umf_memory_provider_ops_t PROVIDER_FROM_POOL_OPS =
+    umf_test::providerMakeCOps<provider_from_pool, umf_memory_pool_t>();
+
+static void *providerFromPoolParamsCreate(void) {
+    umf_file_memory_provider_params_handle_t paramsFile = NULL;
+    umf_result_t umf_result =
+        umfFileMemoryProviderParamsCreate(&paramsFile, FILE_PATH);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    EXPECT_NE(paramsFile, nullptr);
+
+    umf_memory_provider_handle_t providerFile = nullptr;
+    umf_result = umfMemoryProviderCreate(umfFileMemoryProviderOps(), paramsFile,
+                                         &providerFile);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    EXPECT_NE(providerFile, nullptr);
+
+    umf_memory_pool_handle_t poolProxyFile = nullptr;
+    umf_result =
+        umfPoolCreate(umfProxyPoolOps(), providerFile, nullptr,
+                      UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &poolProxyFile);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    EXPECT_NE(poolProxyFile, nullptr);
+
+    umf_result = umfFileMemoryProviderParamsDestroy(paramsFile);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    paramsFile = nullptr;
+
+    return poolProxyFile;
+}
+
+// TESTS
+
+INSTANTIATE_TEST_SUITE_P(TrackingProviderPoolTest, umfPoolTest,
+                         ::testing::Values(poolCreateExtParams{
+                             umfProxyPoolOps(), nullptr, nullptr,
+                             &PROVIDER_FROM_POOL_OPS,
+                             providerFromPoolParamsCreate, nullptr}));
+
+INSTANTIATE_TEST_SUITE_P(TrackingProviderMultiPoolTest, umfMultiPoolTest,
+                         ::testing::Values(poolCreateExtParams{
+                             umfProxyPoolOps(), nullptr, nullptr,
+                             &PROVIDER_FROM_POOL_OPS,
+                             providerFromPoolParamsCreate, nullptr}));
diff --git a/test/providers/cuda_helpers.cpp b/test/providers/cuda_helpers.cpp
new file mode 100644
index 000000000..3e81c184f
--- /dev/null
+++ b/test/providers/cuda_helpers.cpp
@@ -0,0 +1,486 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include <assert.h>
+#include <memory>
+#include <stdlib.h>
+
+#include "cuda_helpers.h"
+#include "utils_concurrency.h"
+#include "utils_load_library.h"
+
+struct libcu_ops {
+    CUresult (*cuInit)(unsigned int flags);
+    CUresult (*cuCtxCreate)(CUcontext *pctx, unsigned int flags, CUdevice dev);
+    CUresult (*cuCtxDestroy)(CUcontext ctx);
+    CUresult (*cuCtxGetCurrent)(CUcontext *pctx);
+    CUresult (*cuCtxSetCurrent)(CUcontext ctx);
+    CUresult (*cuDeviceGet)(CUdevice *device, int ordinal);
+    CUresult (*cuMemAlloc)(CUdeviceptr *dptr, size_t size);
+    CUresult (*cuMemFree)(CUdeviceptr dptr);
+    CUresult (*cuMemHostAlloc)(void **pp, size_t size, unsigned int flags);
+    CUresult (*cuMemAllocManaged)(CUdeviceptr *dptr, size_t bytesize,
+                                  unsigned int flags);
+    CUresult (*cuMemFreeHost)(void *p);
+    CUresult (*cuMemsetD32)(CUdeviceptr dstDevice, unsigned int pattern,
+                            size_t size);
+    CUresult (*cuMemcpy)(CUdeviceptr dst, CUdeviceptr src, size_t size);
+    CUresult (*cuPointerGetAttribute)(void *data, CUpointer_attribute attribute,
+                                      CUdeviceptr ptr);
+    CUresult (*cuPointerGetAttributes)(unsigned int numAttributes,
+                                       CUpointer_attribute *attributes,
+                                       void **data, CUdeviceptr ptr);
+    CUresult (*cuMemHostGetFlags)(unsigned int *pFlags, void *p);
+    CUresult (*cuStreamSynchronize)(CUstream hStream);
+    CUresult (*cuCtxSynchronize)(void);
+} libcu_ops;
+
+#if USE_DLOPEN
+// Generic no-op stub function for all callbacks
+template <typename... Args> CUresult noop_stub(Args &&...) {
+    return CUDA_SUCCESS; // Always return CUDA_SUCCESS
+}
+
+struct DlHandleCloser {
+    void operator()(void *dlHandle) {
+        if (dlHandle) {
+            libcu_ops.cuInit = [](auto... args) { return noop_stub(args...); };
+            libcu_ops.cuCtxCreate = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libcu_ops.cuCtxDestroy = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libcu_ops.cuCtxGetCurrent = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libcu_ops.cuCtxSetCurrent = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libcu_ops.cuDeviceGet = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libcu_ops.cuMemAlloc = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libcu_ops.cuMemFree = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libcu_ops.cuMemHostAlloc = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libcu_ops.cuMemAllocManaged = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libcu_ops.cuMemFreeHost = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libcu_ops.cuMemsetD32 = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libcu_ops.cuMemcpy = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libcu_ops.cuPointerGetAttribute = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libcu_ops.cuPointerGetAttributes = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libcu_ops.cuMemHostGetFlags = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libcu_ops.cuStreamSynchronize = [](auto... args) {
+                return noop_stub(args...);
+            };
+            libcu_ops.cuCtxSynchronize = [](auto... args) {
+                return noop_stub(args...);
+            };
+            utils_close_library(dlHandle);
+        }
+    }
+};
+
+std::unique_ptr<void, DlHandleCloser> cuDlHandle = nullptr;
+int InitCUDAOps() {
+#ifdef _WIN32
+    const char *lib_name = "nvcuda.dll";
+#else
+    const char *lib_name = "libcuda.so";
+#endif
+    // CUDA symbols
+#if OPEN_CU_LIBRARY_GLOBAL
+    // NOTE UMF_UTIL_OPEN_LIBRARY_GLOBAL adds all loaded symbols to the
+    // global symbol table.
+    int open_flags = UMF_UTIL_OPEN_LIBRARY_GLOBAL;
+#else
+    int open_flags = 0;
+#endif
+    cuDlHandle = std::unique_ptr<void, DlHandleCloser>(
+        utils_open_library(lib_name, open_flags));
+
+    // NOTE: some symbols defined in the lib have _vX postfixes - this is
+    // important to load the proper version of functions
+    *(void **)&libcu_ops.cuInit =
+        utils_get_symbol_addr(cuDlHandle.get(), "cuInit", lib_name);
+    if (libcu_ops.cuInit == nullptr) {
+        fprintf(stderr, "cuInit symbol not found in %s\n", lib_name);
+        return -1;
+    }
+    *(void **)&libcu_ops.cuCtxCreate =
+        utils_get_symbol_addr(cuDlHandle.get(), "cuCtxCreate_v2", lib_name);
+    if (libcu_ops.cuCtxCreate == nullptr) {
+        fprintf(stderr, "cuCtxCreate_v2 symbol not found in %s\n", lib_name);
+        return -1;
+    }
+    *(void **)&libcu_ops.cuCtxDestroy =
+        utils_get_symbol_addr(cuDlHandle.get(), "cuCtxDestroy_v2", lib_name);
+    if (libcu_ops.cuCtxDestroy == nullptr) {
+        fprintf(stderr, "cuCtxDestroy symbol not found in %s\n", lib_name);
+        return -1;
+    }
+    *(void **)&libcu_ops.cuCtxGetCurrent =
+        utils_get_symbol_addr(cuDlHandle.get(), "cuCtxGetCurrent", lib_name);
+    if (libcu_ops.cuCtxGetCurrent == nullptr) {
+        fprintf(stderr, "cuCtxGetCurrent symbol not found in %s\n", lib_name);
+        return -1;
+    }
+    *(void **)&libcu_ops.cuCtxSetCurrent =
+        utils_get_symbol_addr(cuDlHandle.get(), "cuCtxSetCurrent", lib_name);
+    if (libcu_ops.cuCtxSetCurrent == nullptr) {
+        fprintf(stderr, "cuCtxSetCurrent symbol not found in %s\n", lib_name);
+        return -1;
+    }
+    *(void **)&libcu_ops.cuDeviceGet =
+        utils_get_symbol_addr(cuDlHandle.get(), "cuDeviceGet", lib_name);
+    if (libcu_ops.cuDeviceGet == nullptr) {
+        fprintf(stderr, "cuDeviceGet symbol not found in %s\n", lib_name);
+        return -1;
+    }
+    *(void **)&libcu_ops.cuMemAlloc =
+        utils_get_symbol_addr(cuDlHandle.get(), "cuMemAlloc_v2", lib_name);
+    if (libcu_ops.cuMemAlloc == nullptr) {
+        fprintf(stderr, "cuMemAlloc_v2 symbol not found in %s\n", lib_name);
+        return -1;
+    }
+    *(void **)&libcu_ops.cuMemFree =
+        utils_get_symbol_addr(cuDlHandle.get(), "cuMemFree_v2", lib_name);
+    if (libcu_ops.cuMemFree == nullptr) {
+        fprintf(stderr, "cuMemFree_v2 symbol not found in %s\n", lib_name);
+        return -1;
+    }
+    *(void **)&libcu_ops.cuMemHostAlloc =
+        utils_get_symbol_addr(cuDlHandle.get(), "cuMemHostAlloc", lib_name);
+    if (libcu_ops.cuMemHostAlloc == nullptr) {
+        fprintf(stderr, "cuMemHostAlloc symbol not found in %s\n", lib_name);
+        return -1;
+    }
+    *(void **)&libcu_ops.cuMemAllocManaged =
+        utils_get_symbol_addr(cuDlHandle.get(), "cuMemAllocManaged", lib_name);
+    if (libcu_ops.cuMemAllocManaged == nullptr) {
+        fprintf(stderr, "cuMemAllocManaged symbol not found in %s\n", lib_name);
+        return -1;
+    }
+    *(void **)&libcu_ops.cuMemFreeHost =
+        utils_get_symbol_addr(cuDlHandle.get(), "cuMemFreeHost", lib_name);
+    if (libcu_ops.cuMemFreeHost == nullptr) {
+        fprintf(stderr, "cuMemFreeHost symbol not found in %s\n", lib_name);
+        return -1;
+    }
+    *(void **)&libcu_ops.cuMemsetD32 =
+        utils_get_symbol_addr(cuDlHandle.get(), "cuMemsetD32_v2", lib_name);
+    if (libcu_ops.cuMemsetD32 == nullptr) {
+        fprintf(stderr, "cuMemsetD32_v2 symbol not found in %s\n", lib_name);
+        return -1;
+    }
+    *(void **)&libcu_ops.cuMemcpy =
+        utils_get_symbol_addr(cuDlHandle.get(), "cuMemcpy", lib_name);
+    if (libcu_ops.cuMemcpy == nullptr) {
+        fprintf(stderr, "cuMemcpy symbol not found in %s\n", lib_name);
+        return -1;
+    }
+    *(void **)&libcu_ops.cuPointerGetAttribute = utils_get_symbol_addr(
+        cuDlHandle.get(), "cuPointerGetAttribute", lib_name);
+    if (libcu_ops.cuPointerGetAttribute == nullptr) {
+        fprintf(stderr, "cuPointerGetAttribute symbol not found in %s\n",
+                lib_name);
+        return -1;
+    }
+    *(void **)&libcu_ops.cuPointerGetAttributes = utils_get_symbol_addr(
+        cuDlHandle.get(), "cuPointerGetAttributes", lib_name);
+    if (libcu_ops.cuPointerGetAttributes == nullptr) {
+        fprintf(stderr, "cuPointerGetAttributes symbol not found in %s\n",
+                lib_name);
+        return -1;
+    }
+    *(void **)&libcu_ops.cuMemHostGetFlags =
+        utils_get_symbol_addr(cuDlHandle.get(), "cuMemHostGetFlags", lib_name);
+    if (libcu_ops.cuMemHostGetFlags == nullptr) {
+        fprintf(stderr, "cuMemHostGetFlags symbol not found in %s\n", lib_name);
+        return -1;
+    }
+    *(void **)&libcu_ops.cuStreamSynchronize = utils_get_symbol_addr(
+        cuDlHandle.get(), "cuStreamSynchronize", lib_name);
+    if (libcu_ops.cuStreamSynchronize == nullptr) {
+        fprintf(stderr, "cuStreamSynchronize symbol not found in %s\n",
+                lib_name);
+        return -1;
+    }
+    *(void **)&libcu_ops.cuCtxSynchronize =
+        utils_get_symbol_addr(cuDlHandle.get(), "cuCtxSynchronize", lib_name);
+    if (libcu_ops.cuCtxSynchronize == nullptr) {
+        fprintf(stderr, "cuCtxSynchronize symbol not found in %s\n", lib_name);
+        return -1;
+    }
+
+    return 0;
+}
+
+#else  // USE_DLOPEN
+int InitCUDAOps() {
+    // CUDA is linked statically but we prepare ops structure to
+    // make test code consistent
+    libcu_ops.cuInit = cuInit;
+    libcu_ops.cuCtxCreate = cuCtxCreate;
+    libcu_ops.cuCtxDestroy = cuCtxDestroy;
+    libcu_ops.cuCtxGetCurrent = cuCtxGetCurrent;
+    libcu_ops.cuCtxSetCurrent = cuCtxSetCurrent;
+    libcu_ops.cuDeviceGet = cuDeviceGet;
+    libcu_ops.cuMemAlloc = cuMemAlloc;
+    libcu_ops.cuMemHostAlloc = cuMemHostAlloc;
+    libcu_ops.cuMemAllocManaged = cuMemAllocManaged;
+    libcu_ops.cuMemFree = cuMemFree;
+    libcu_ops.cuMemFreeHost = cuMemFreeHost;
+    libcu_ops.cuMemsetD32 = cuMemsetD32;
+    libcu_ops.cuMemcpy = cuMemcpy;
+    libcu_ops.cuPointerGetAttribute = cuPointerGetAttribute;
+    libcu_ops.cuPointerGetAttributes = cuPointerGetAttributes;
+    libcu_ops.cuMemHostGetFlags = cuMemHostGetFlags;
+    libcu_ops.cuStreamSynchronize = cuStreamSynchronize;
+    libcu_ops.cuCtxSynchronize = cuCtxSynchronize;
+
+    return 0;
+}
+#endif // USE_DLOPEN
+
+CUresult set_context(CUcontext required_ctx, CUcontext *restore_ctx) {
+    CUcontext current_ctx = NULL;
+    CUresult cu_result = libcu_ops.cuCtxGetCurrent(&current_ctx);
+    if (cu_result != CUDA_SUCCESS) {
+        fprintf(stderr, "cuCtxGetCurrent() failed.\n");
+        return cu_result;
+    }
+
+    if (restore_ctx != NULL) {
+        *restore_ctx = current_ctx;
+    }
+
+    if (current_ctx != required_ctx) {
+        cu_result = libcu_ops.cuCtxSetCurrent(required_ctx);
+        if (cu_result != CUDA_SUCCESS) {
+            fprintf(stderr, "cuCtxSetCurrent() failed.\n");
+        }
+    }
+
+    return cu_result;
+}
+
+static int init_cuda_lib(void) {
+    CUresult result = libcu_ops.cuInit(0);
+    if (result != CUDA_SUCCESS) {
+        return -1;
+    }
+    return 0;
+}
+
+int cuda_fill(CUcontext context, CUdevice device, void *ptr, size_t size,
+              const void *pattern, size_t pattern_size) {
+    (void)device;
+    (void)pattern_size;
+
+    // TODO support patterns > sizeof(unsigned int)
+    if (pattern_size > sizeof(unsigned int)) {
+        fprintf(stderr, "patterns > sizeof(unsigned int) are unsupported!\n");
+        return -1;
+    }
+
+    // set required context
+    CUcontext curr_context = nullptr;
+    set_context(context, &curr_context);
+
+    int ret = 0;
+    CUresult res =
+        libcu_ops.cuMemsetD32((CUdeviceptr)ptr, *(unsigned int *)pattern,
+                              size / sizeof(unsigned int));
+    if (res != CUDA_SUCCESS) {
+        fprintf(stderr, "cuMemsetD32(%llu, %u, %zu) failed!\n",
+                (CUdeviceptr)ptr, *(unsigned int *)pattern,
+                size / pattern_size);
+        return -1;
+    }
+
+    res = libcu_ops.cuCtxSynchronize();
+    if (res != CUDA_SUCCESS) {
+        fprintf(stderr, "cuCtxSynchronize() failed!\n");
+        return -1;
+    }
+
+    // restore context
+    set_context(curr_context, &curr_context);
+    return ret;
+}
+
+int cuda_copy(CUcontext context, CUdevice device, void *dst_ptr,
+              const void *src_ptr, size_t size) {
+    (void)device;
+
+    // set required context
+    CUcontext curr_context = nullptr;
+    set_context(context, &curr_context);
+
+    int ret = 0;
+    CUresult res =
+        libcu_ops.cuMemcpy((CUdeviceptr)dst_ptr, (CUdeviceptr)src_ptr, size);
+    if (res != CUDA_SUCCESS) {
+        fprintf(stderr, "cuMemcpy() failed!\n");
+        return -1;
+    }
+
+    res = libcu_ops.cuCtxSynchronize();
+    if (res != CUDA_SUCCESS) {
+        fprintf(stderr, "cuCtxSynchronize() failed!\n");
+        return -1;
+    }
+
+    // restore context
+    set_context(curr_context, &curr_context);
+    return ret;
+}
+
+umf_usm_memory_type_t get_mem_type(CUcontext context, void *ptr) {
+
+    (void)context;
+
+    unsigned int managed;
+    unsigned int type;
+    void *attrib_vals[2] = {&managed, &type};
+    CUpointer_attribute attribs[2] = {CU_POINTER_ATTRIBUTE_IS_MANAGED,
+                                      CU_POINTER_ATTRIBUTE_MEMORY_TYPE};
+
+    CUresult res = libcu_ops.cuPointerGetAttributes(2, attribs, attrib_vals,
+                                                    (CUdeviceptr)ptr);
+    if (res != CUDA_SUCCESS) {
+        fprintf(stderr, "cuPointerGetAttributes() failed!\n");
+        return UMF_MEMORY_TYPE_UNKNOWN;
+    }
+
+    if (type == CU_MEMORYTYPE_DEVICE && managed == 0) {
+        return UMF_MEMORY_TYPE_DEVICE;
+    } else if (type == CU_MEMORYTYPE_DEVICE && managed == 1) {
+        return UMF_MEMORY_TYPE_SHARED;
+    } else if (type == CU_MEMORYTYPE_HOST) {
+        return UMF_MEMORY_TYPE_HOST;
+    }
+
+    return UMF_MEMORY_TYPE_UNKNOWN;
+}
+
+unsigned int get_mem_host_alloc_flags(void *ptr) {
+    unsigned int flags;
+    CUresult res = libcu_ops.cuMemHostGetFlags(&flags, ptr);
+    if (res != CUDA_SUCCESS) {
+        fprintf(stderr, "cuPointerGetAttribute() failed!\n");
+        return 0;
+    }
+
+    return flags;
+}
+
+CUcontext get_mem_context(void *ptr) {
+    CUcontext context;
+    CUresult res = libcu_ops.cuPointerGetAttribute(
+        &context, CU_POINTER_ATTRIBUTE_CONTEXT, (CUdeviceptr)ptr);
+    if (res != CUDA_SUCCESS) {
+        fprintf(stderr, "cuPointerGetAttribute() failed!\n");
+        return nullptr;
+    }
+
+    return context;
+}
+
+int get_mem_device(void *ptr) {
+    int device;
+    CUresult res = libcu_ops.cuPointerGetAttribute(
+        &device, CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL, (CUdeviceptr)ptr);
+    if (res != CUDA_SUCCESS) {
+        fprintf(stderr, "cuPointerGetAttribute() failed!\n");
+        return -1;
+    }
+
+    return device;
+}
+
+CUcontext get_current_context() {
+    CUcontext context;
+    CUresult res = libcu_ops.cuCtxGetCurrent(&context);
+    if (res != CUDA_SUCCESS) {
+        fprintf(stderr, "cuCtxGetCurrent() failed!\n");
+        return nullptr;
+    }
+
+    return context;
+}
+
+UTIL_ONCE_FLAG cuda_init_flag;
+int InitResult;
+void init_cuda_once() {
+    InitResult = InitCUDAOps();
+    if (InitResult != 0) {
+        return;
+    }
+    InitResult = init_cuda_lib();
+}
+
+int init_cuda(void) {
+    utils_init_once(&cuda_init_flag, init_cuda_once);
+
+    return InitResult;
+}
+
+int get_cuda_device(CUdevice *device) {
+    CUdevice cuDevice = -1;
+
+    CUresult res = libcu_ops.cuDeviceGet(&cuDevice, 0);
+    if (res != CUDA_SUCCESS || cuDevice < 0) {
+        return -1;
+    }
+
+    *device = cuDevice;
+    return 0;
+}
+
+int create_context(CUdevice device, CUcontext *context) {
+    CUcontext cuContext = nullptr;
+
+    CUresult res = libcu_ops.cuCtxCreate(&cuContext, 0, device);
+    if (res != CUDA_SUCCESS || cuContext == nullptr) {
+        return -1;
+    }
+
+    *context = cuContext;
+    return 0;
+}
+
+int destroy_context(CUcontext context) {
+    CUresult res = libcu_ops.cuCtxDestroy(context);
+    if (res != CUDA_SUCCESS) {
+        fprintf(stderr, "cuCtxDestroy() failed!\n");
+        return -1;
+    }
+
+    return 0;
+}
diff --git a/test/providers/cuda_helpers.h b/test/providers/cuda_helpers.h
new file mode 100644
index 000000000..944e6dbef
--- /dev/null
+++ b/test/providers/cuda_helpers.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef TEST_COMMON_CUDA_HELPERS_HPP
+#define TEST_COMMON_CUDA_HELPERS_HPP
+
+#include <umf/providers/provider_cuda.h>
+
+// disable warning 4201: nonstandard extension used: nameless struct/union
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4201)
+#endif // _MSC_VER
+
+#include "cuda.h"
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif // _MSC_VER
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int init_cuda(void);
+
+int get_cuda_device(CUdevice *device);
+
+int create_context(CUdevice device, CUcontext *context);
+
+CUresult set_context(CUcontext required_ctx, CUcontext *restore_ctx);
+
+int destroy_context(CUcontext context);
+
+int cuda_fill(CUcontext context, CUdevice device, void *ptr, size_t size,
+              const void *pattern, size_t pattern_size);
+
+int cuda_copy(CUcontext context, CUdevice device, void *dst_ptr,
+              const void *src_ptr, size_t size);
+
+umf_usm_memory_type_t get_mem_type(CUcontext context, void *ptr);
+
+unsigned int get_mem_host_alloc_flags(void *ptr);
+
+CUcontext get_mem_context(void *ptr);
+
+int get_mem_device(void *ptr);
+
+CUcontext get_current_context();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TEST_COMMON_CUDA_HELPERS_HPP
diff --git a/test/providers/ipc_cuda_prov.sh b/test/providers/ipc_cuda_prov.sh
new file mode 100755
index 000000000..bb4be9474
--- /dev/null
+++ b/test/providers/ipc_cuda_prov.sh
@@ -0,0 +1,24 @@
+#
+# Copyright (C) 2024-2025 Intel Corporation
+#
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+#
+
+#!/bin/bash
+
+set -e
+
+# port should be a number from the range <1024, 65535>
+PORT=$(( 1024 + ( $$ % ( 65535 - 1024 ))))
+
+UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
+
+echo "Starting ipc_cuda_prov CONSUMER on port $PORT ..."
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_cuda_prov_consumer $PORT &
+
+echo "Waiting 1 sec ..."
+sleep 1
+
+echo "Starting ipc_cuda_prov PRODUCER on port $PORT ..."
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_cuda_prov_producer $PORT
diff --git a/test/providers/ipc_cuda_prov_common.c b/test/providers/ipc_cuda_prov_common.c
new file mode 100644
index 000000000..a38e4d061
--- /dev/null
+++ b/test/providers/ipc_cuda_prov_common.c
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include <stdio.h>
+
+#include <umf/providers/provider_cuda.h>
+
+#include "cuda_helpers.h"
+#include "ipc_cuda_prov_common.h"
+
+void memcopy(void *dst, const void *src, size_t size, void *context) {
+    cuda_copy_ctx_t *cu_params = (cuda_copy_ctx_t *)context;
+    int ret = cuda_copy(cu_params->context, cu_params->device, dst, (void *)src,
+                        size);
+    if (ret != 0) {
+        fprintf(stderr, "cuda_copy failed with error %d\n", ret);
+    }
+}
diff --git a/test/providers/ipc_cuda_prov_common.h b/test/providers/ipc_cuda_prov_common.h
new file mode 100644
index 000000000..e50546efd
--- /dev/null
+++ b/test/providers/ipc_cuda_prov_common.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef UMF_TEST_IPC_CUDA_PROV_COMMON_H
+#define UMF_TEST_IPC_CUDA_PROV_COMMON_H
+
+#include <stddef.h>
+
+typedef struct cuda_copy_ctx_t {
+    CUcontext context;
+    CUdevice device;
+} cuda_copy_ctx_t;
+
+void memcopy(void *dst, const void *src, size_t size, void *context);
+
+#endif // UMF_TEST_IPC_CUDA_PROV_COMMON_H
diff --git a/test/providers/ipc_cuda_prov_consumer.c b/test/providers/ipc_cuda_prov_consumer.c
new file mode 100644
index 000000000..3d4a70707
--- /dev/null
+++ b/test/providers/ipc_cuda_prov_consumer.c
@@ -0,0 +1,103 @@
+/*
+ * 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 <stdio.h>
+#include <stdlib.h>
+
+#include <umf/pools/pool_disjoint.h>
+#include <umf/providers/provider_cuda.h>
+
+#include "cuda_helpers.h"
+#include "ipc_common.h"
+#include "ipc_cuda_prov_common.h"
+
+int main(int argc, char *argv[]) {
+    if (argc < 2) {
+        fprintf(stderr, "usage: %s <port>\n", argv[0]);
+        return -1;
+    }
+
+    int port = atoi(argv[1]);
+    CUdevice hDevice = -1;
+    CUcontext hContext = NULL;
+
+    int ret = init_cuda();
+    if (ret != 0) {
+        fprintf(stderr, "init_cuda() failed!\n");
+        return -1;
+    }
+
+    ret = get_cuda_device(&hDevice);
+    if (ret != 0) {
+        fprintf(stderr, "get_cuda_device() failed!\n");
+        return -1;
+    }
+
+    ret = create_context(hDevice, &hContext);
+    if (ret != 0) {
+        fprintf(stderr, "create_context() failed!\n");
+        return -1;
+    }
+
+    umf_cuda_memory_provider_params_handle_t cu_params = NULL;
+    umf_result_t umf_result = umfCUDAMemoryProviderParamsCreate(&cu_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create CUDA params!\n");
+        ret = -1;
+        goto destroy_context;
+    }
+
+    umf_result = umfCUDAMemoryProviderParamsSetContext(cu_params, hContext);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "Failed to set context in CUDA Memory Provider params!\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    umf_result = umfCUDAMemoryProviderParamsSetDevice(cu_params, hDevice);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "Failed to set device in CUDA Memory Provider params!\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    umf_result = umfCUDAMemoryProviderParamsSetMemoryType(
+        cu_params, UMF_MEMORY_TYPE_DEVICE);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set memory type in CUDA memory "
+                        "provider params!\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    umf_disjoint_pool_params_handle_t pool_params = NULL;
+
+    umf_result = umfDisjointPoolParamsCreate(&pool_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create pool params!\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    cuda_copy_ctx_t copy_ctx = {hContext, hDevice};
+
+    ret =
+        run_consumer(port, umfDisjointPoolOps(), pool_params,
+                     umfCUDAMemoryProviderOps(), cu_params, memcopy, &copy_ctx);
+
+    umfDisjointPoolParamsDestroy(pool_params);
+
+destroy_provider_params:
+    umfCUDAMemoryProviderParamsDestroy(cu_params);
+
+destroy_context:
+    destroy_context(hContext);
+
+    return ret;
+}
diff --git a/test/providers/ipc_cuda_prov_producer.c b/test/providers/ipc_cuda_prov_producer.c
new file mode 100644
index 000000000..a7421da06
--- /dev/null
+++ b/test/providers/ipc_cuda_prov_producer.c
@@ -0,0 +1,103 @@
+/*
+ * 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 <stdio.h>
+#include <stdlib.h>
+
+#include <umf/pools/pool_disjoint.h>
+#include <umf/providers/provider_cuda.h>
+
+#include "cuda_helpers.h"
+#include "ipc_common.h"
+#include "ipc_cuda_prov_common.h"
+
+int main(int argc, char *argv[]) {
+    if (argc < 2) {
+        fprintf(stderr, "usage: %s <port>\n", argv[0]);
+        return -1;
+    }
+
+    int port = atoi(argv[1]);
+    CUdevice hDevice = -1;
+    CUcontext hContext = NULL;
+
+    int ret = init_cuda();
+    if (ret != 0) {
+        fprintf(stderr, "init_cuda() failed!\n");
+        return -1;
+    }
+
+    ret = get_cuda_device(&hDevice);
+    if (ret != 0) {
+        fprintf(stderr, "get_cuda_device() failed!\n");
+        return -1;
+    }
+
+    ret = create_context(hDevice, &hContext);
+    if (ret != 0) {
+        fprintf(stderr, "create_context() failed!\n");
+        return -1;
+    }
+
+    umf_cuda_memory_provider_params_handle_t cu_params = NULL;
+    umf_result_t umf_result = umfCUDAMemoryProviderParamsCreate(&cu_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create CUDA params!\n");
+        ret = -1;
+        goto destroy_context;
+    }
+
+    umf_result = umfCUDAMemoryProviderParamsSetContext(cu_params, hContext);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "Failed to set context in CUDA Memory Provider params!\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    umf_result = umfCUDAMemoryProviderParamsSetDevice(cu_params, hDevice);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "Failed to set device in CUDA Memory Provider params!\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    umf_result = umfCUDAMemoryProviderParamsSetMemoryType(
+        cu_params, UMF_MEMORY_TYPE_DEVICE);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set memory type in CUDA memory "
+                        "provider params!\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    umf_disjoint_pool_params_handle_t pool_params = NULL;
+
+    umf_result = umfDisjointPoolParamsCreate(&pool_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create pool params!\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    cuda_copy_ctx_t copy_ctx = {hContext, hDevice};
+
+    ret =
+        run_producer(port, umfDisjointPoolOps(), pool_params,
+                     umfCUDAMemoryProviderOps(), cu_params, memcopy, &copy_ctx);
+
+    umfDisjointPoolParamsDestroy(pool_params);
+
+destroy_provider_params:
+    umfCUDAMemoryProviderParamsDestroy(cu_params);
+
+destroy_context:
+    destroy_context(hContext);
+
+    return ret;
+}
diff --git a/test/providers/ipc_level_zero_prov.sh b/test/providers/ipc_level_zero_prov.sh
index d6bcef4f3..cebd90932 100755
--- a/test/providers/ipc_level_zero_prov.sh
+++ b/test/providers/ipc_level_zero_prov.sh
@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024-2025 Intel Corporation
 #
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -12,28 +12,13 @@ set -e
 # port should be a number from the range <1024, 65535>
 PORT=$(( 1024 + ( $$ % ( 65535 - 1024 ))))
 
-# The ipc_level_zero_prov test requires using pidfd_getfd(2)
-# to obtain a duplicate of another process's file descriptor.
-# Permission to duplicate another process's file descriptor
-# is governed by a ptrace access mode PTRACE_MODE_ATTACH_REALCREDS check (see ptrace(2))
-# that can be changed using the /proc/sys/kernel/yama/ptrace_scope interface.
-PTRACE_SCOPE_FILE="/proc/sys/kernel/yama/ptrace_scope"
-VAL=0
-if [ -f $PTRACE_SCOPE_FILE ]; then
-	PTRACE_SCOPE_VAL=$(cat $PTRACE_SCOPE_FILE)
-	if [ $PTRACE_SCOPE_VAL -ne $VAL ]; then
-		echo "SKIP: ptrace_scope is not set to 0 (classic ptrace permissions) - skipping the test"
-		exit 125 # skip code defined in CMakeLists.txt
-	fi
-fi
-
 UMF_LOG_VAL="level:debug;flush:debug;output:stderr;pid:yes"
 
 echo "Starting ipc_level_zero_prov CONSUMER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_level_zero_prov_consumer $PORT &
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_level_zero_prov_consumer $PORT &
 
 echo "Waiting 1 sec ..."
 sleep 1
 
 echo "Starting ipc_level_zero_prov PRODUCER on port $PORT ..."
-UMF_LOG=$UMF_LOG_VAL ./umf_test-ipc_level_zero_prov_producer $PORT
+UMF_LOG=$UMF_LOG_VAL ./test_ipc_level_zero_prov_producer $PORT
diff --git a/test/providers/ipc_level_zero_prov_common.c b/test/providers/ipc_level_zero_prov_common.c
index 11813653d..485cb41b5 100644
--- a/test/providers/ipc_level_zero_prov_common.c
+++ b/test/providers/ipc_level_zero_prov_common.c
@@ -6,18 +6,16 @@
  */
 
 #include "ipc_level_zero_prov_common.h"
-#include "level_zero_helpers.h"
+#include "utils_level_zero.h"
 
 #include <umf/providers/provider_level_zero.h>
 
 #include <stdio.h>
 
 void memcopy(void *dst, const void *src, size_t size, void *context) {
-    level_zero_memory_provider_params_t *l0_params =
-        (level_zero_memory_provider_params_t *)context;
-    int ret =
-        level_zero_copy(l0_params->level_zero_context_handle,
-                        l0_params->level_zero_device_handle, dst, src, size);
+    level_zero_copy_ctx_t *l0_params = (level_zero_copy_ctx_t *)context;
+    int ret = utils_ze_level_zero_copy(l0_params->context, l0_params->device,
+                                       dst, src, size);
     if (ret != 0) {
         fprintf(stderr, "level_zero_copy failed with error %d\n", ret);
     }
diff --git a/test/providers/ipc_level_zero_prov_common.h b/test/providers/ipc_level_zero_prov_common.h
index dff51d08b..ea444133d 100644
--- a/test/providers/ipc_level_zero_prov_common.h
+++ b/test/providers/ipc_level_zero_prov_common.h
@@ -10,6 +10,13 @@
 
 #include <stddef.h>
 
+#include "ze_api.h"
+
+typedef struct level_zero_copy_ctx_t {
+    ze_context_handle_t context;
+    ze_device_handle_t device;
+} level_zero_copy_ctx_t;
+
 void memcopy(void *dst, const void *src, size_t size, void *context);
 
 #endif // UMF_TEST_IPC_LEVEL_ZERO_PROV_COMMON_H
diff --git a/test/providers/ipc_level_zero_prov_consumer.c b/test/providers/ipc_level_zero_prov_consumer.c
index 6d59ced53..5fb212881 100644
--- a/test/providers/ipc_level_zero_prov_consumer.c
+++ b/test/providers/ipc_level_zero_prov_consumer.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -8,23 +8,108 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <umf/pools/pool_disjoint.h>
 #include <umf/providers/provider_level_zero.h>
 
 #include "ipc_common.h"
 #include "ipc_level_zero_prov_common.h"
-#include "level_zero_helpers.h"
+#include "utils_level_zero.h"
 
 int main(int argc, char *argv[]) {
     if (argc < 2) {
-        fprintf(stderr, "usage: %s <port> [shm_name]\n", argv[0]);
+        fprintf(stderr, "usage: %s <port>\n", argv[0]);
         return -1;
     }
 
     int port = atoi(argv[1]);
+    uint32_t driver_idx = 0;
+    ze_driver_handle_t hDriver = NULL;
+    ze_device_handle_t hDevice = NULL;
+    ze_context_handle_t hContext = NULL;
 
-    level_zero_memory_provider_params_t l0_params =
-        create_level_zero_prov_params(UMF_MEMORY_TYPE_DEVICE);
+    int ret = utils_ze_init_level_zero();
+    if (ret != 0) {
+        fprintf(stderr, "utils_ze_init_level_zero() failed!\n");
+        return -1;
+    }
+
+    ret = utils_ze_find_driver_with_gpu(&driver_idx, &hDriver);
+    if (ret != 0 || hDriver == NULL) {
+        fprintf(stderr, "utils_ze_find_driver_with_gpu() failed!\n");
+        return -1;
+    }
+
+    ret = utils_ze_find_gpu_device(hDriver, &hDevice);
+    if (ret != 0 || hDevice == NULL) {
+        fprintf(stderr, "utils_ze_find_gpu_device() failed!\n");
+        return -1;
+    }
+
+    ret = utils_ze_create_context(hDriver, &hContext);
+    if (ret != 0) {
+        fprintf(stderr, "utils_ze_create_context() failed!\n");
+        return -1;
+    }
+
+    umf_level_zero_memory_provider_params_handle_t l0_params = NULL;
+    umf_result_t umf_result =
+        umfLevelZeroMemoryProviderParamsCreate(&l0_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "Failed to create Level Zero Memory Provider params!\n");
+        ret = -1;
+        goto destroy_context;
+    }
+
+    umf_result =
+        umfLevelZeroMemoryProviderParamsSetContext(l0_params, hContext);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(
+            stderr,
+            "Failed to set context in Level Zero Memory Provider params!\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    umf_result = umfLevelZeroMemoryProviderParamsSetDevice(l0_params, hDevice);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "Failed to set device in Level Zero Memory Provider params!\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    umf_result = umfLevelZeroMemoryProviderParamsSetMemoryType(
+        l0_params, UMF_MEMORY_TYPE_DEVICE);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set memory type in Level Zero Memory "
+                        "Provider params!\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    umf_disjoint_pool_params_handle_t pool_params = NULL;
+
+    umf_result = umfDisjointPoolParamsCreate(&pool_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create pool params!\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    level_zero_copy_ctx_t copy_ctx = {hContext, hDevice};
+
+    ret = run_consumer(port, umfDisjointPoolOps(), pool_params,
+                       umfLevelZeroMemoryProviderOps(), l0_params, memcopy,
+                       &copy_ctx);
+
+    umfDisjointPoolParamsDestroy(pool_params);
+
+destroy_provider_params:
+    umfLevelZeroMemoryProviderParamsDestroy(l0_params);
+
+destroy_context:
+    utils_ze_destroy_context(hContext);
 
-    return run_consumer(port, umfLevelZeroMemoryProviderOps(), &l0_params,
-                        memcopy, &l0_params);
+    return ret;
 }
diff --git a/test/providers/ipc_level_zero_prov_producer.c b/test/providers/ipc_level_zero_prov_producer.c
index d2d95d885..e6ffcf2ed 100644
--- a/test/providers/ipc_level_zero_prov_producer.c
+++ b/test/providers/ipc_level_zero_prov_producer.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -8,23 +8,108 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <umf/pools/pool_disjoint.h>
 #include <umf/providers/provider_level_zero.h>
 
 #include "ipc_common.h"
 #include "ipc_level_zero_prov_common.h"
-#include "level_zero_helpers.h"
+#include "utils_level_zero.h"
 
 int main(int argc, char *argv[]) {
     if (argc < 2) {
-        fprintf(stderr, "usage: %s <port> [shm_name]\n", argv[0]);
+        fprintf(stderr, "usage: %s <port>\n", argv[0]);
         return -1;
     }
 
     int port = atoi(argv[1]);
+    uint32_t driver_idx = 0;
+    ze_driver_handle_t hDriver = NULL;
+    ze_device_handle_t hDevice = NULL;
+    ze_context_handle_t hContext = NULL;
 
-    level_zero_memory_provider_params_t l0_params =
-        create_level_zero_prov_params(UMF_MEMORY_TYPE_DEVICE);
+    int ret = utils_ze_init_level_zero();
+    if (ret != 0) {
+        fprintf(stderr, "utils_ze_init_level_zero() failed!\n");
+        return -1;
+    }
+
+    ret = utils_ze_find_driver_with_gpu(&driver_idx, &hDriver);
+    if (ret != 0 || hDriver == NULL) {
+        fprintf(stderr, "utils_ze_find_driver_with_gpu() failed!\n");
+        return -1;
+    }
+
+    ret = utils_ze_find_gpu_device(hDriver, &hDevice);
+    if (ret != 0 || hDevice == NULL) {
+        fprintf(stderr, "utils_ze_find_gpu_device() failed!\n");
+        return -1;
+    }
+
+    ret = utils_ze_create_context(hDriver, &hContext);
+    if (ret != 0) {
+        fprintf(stderr, "utils_ze_create_context() failed!\n");
+        return -1;
+    }
+
+    umf_level_zero_memory_provider_params_handle_t l0_params = NULL;
+    umf_result_t umf_result =
+        umfLevelZeroMemoryProviderParamsCreate(&l0_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "Failed to create Level Zero Memory Provider params!\n");
+        ret = -1;
+        goto destroy_context;
+    }
+
+    umf_result =
+        umfLevelZeroMemoryProviderParamsSetContext(l0_params, hContext);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(
+            stderr,
+            "Failed to set context in Level Zero Memory Provider params!\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    umf_result = umfLevelZeroMemoryProviderParamsSetDevice(l0_params, hDevice);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr,
+                "Failed to set device in Level Zero Memory Provider params!\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    umf_result = umfLevelZeroMemoryProviderParamsSetMemoryType(
+        l0_params, UMF_MEMORY_TYPE_DEVICE);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set memory type in Level Zero Memory "
+                        "Provider params!\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    umf_disjoint_pool_params_handle_t pool_params = NULL;
+
+    umf_result = umfDisjointPoolParamsCreate(&pool_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create pool params!\n");
+        ret = -1;
+        goto destroy_provider_params;
+    }
+
+    level_zero_copy_ctx_t copy_ctx = {hContext, hDevice};
+
+    ret = run_producer(port, umfDisjointPoolOps(), pool_params,
+                       umfLevelZeroMemoryProviderOps(), l0_params, memcopy,
+                       &copy_ctx);
+
+    umfDisjointPoolParamsDestroy(pool_params);
+
+destroy_provider_params:
+    umfLevelZeroMemoryProviderParamsDestroy(l0_params);
+
+destroy_context:
+    utils_ze_destroy_context(hContext);
 
-    return run_producer(port, umfLevelZeroMemoryProviderOps(), &l0_params,
-                        memcopy, &l0_params);
+    return ret;
 }
diff --git a/test/providers/provider_cuda.cpp b/test/providers/provider_cuda.cpp
new file mode 100644
index 000000000..00d8e9d8f
--- /dev/null
+++ b/test/providers/provider_cuda.cpp
@@ -0,0 +1,630 @@
+// Copyright (C) 2024-2025 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifdef _WIN32
+//workaround for std::numeric_limits on windows
+#define NOMINMAX
+#endif
+
+#include <mutex>
+
+#include <umf/providers/provider_cuda.h>
+
+#include "cuda_helpers.h"
+#include "ipcFixtures.hpp"
+#include "pool.hpp"
+#include "utils_load_library.h"
+
+using umf_test::test;
+using namespace umf_test;
+
+class CUDATestHelper {
+  public:
+    CUDATestHelper();
+
+    ~CUDATestHelper() {
+        if (hContext_) {
+            destroy_context(hContext_);
+        }
+    }
+
+    CUcontext get_test_context() const { return hContext_; }
+
+    CUdevice get_test_device() const { return hDevice_; }
+
+  private:
+    CUcontext hContext_ = nullptr;
+    CUdevice hDevice_ = -1;
+};
+
+CUDATestHelper::CUDATestHelper() {
+    int ret = init_cuda();
+    if (ret != 0) {
+        fprintf(stderr, "init_cuda() failed!\n");
+        return;
+    }
+
+    ret = get_cuda_device(&hDevice_);
+    if (ret != 0) {
+        fprintf(stderr, "get_cuda_device() failed!\n");
+        return;
+    }
+
+    ret = create_context(hDevice_, &hContext_);
+    if (ret != 0) {
+        fprintf(stderr, "create_context() failed!\n");
+        return;
+    }
+}
+
+umf_cuda_memory_provider_params_handle_t
+create_cuda_prov_params(CUcontext context, CUdevice device,
+                        umf_usm_memory_type_t memory_type, unsigned int flags) {
+    umf_cuda_memory_provider_params_handle_t params = nullptr;
+
+    umf_result_t res = umfCUDAMemoryProviderParamsCreate(&params);
+    if (res != UMF_RESULT_SUCCESS) {
+        return nullptr;
+    }
+
+    res = umfCUDAMemoryProviderParamsSetContext(params, context);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfCUDAMemoryProviderParamsDestroy(params);
+        return nullptr;
+    }
+
+    res = umfCUDAMemoryProviderParamsSetDevice(params, device);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfCUDAMemoryProviderParamsDestroy(params);
+        return nullptr;
+    }
+
+    res = umfCUDAMemoryProviderParamsSetMemoryType(params, memory_type);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfCUDAMemoryProviderParamsDestroy(params);
+        return nullptr;
+    }
+
+    res = umfCUDAMemoryProviderParamsSetAllocFlags(params, flags);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfCUDAMemoryProviderParamsDestroy(params);
+        return nullptr;
+    }
+
+    return params;
+}
+
+umf_result_t destroyCuParams(void *params) {
+    return umfCUDAMemoryProviderParamsDestroy(
+        (umf_cuda_memory_provider_params_handle_t)params);
+}
+
+class CUDAMemoryAccessor : public MemoryAccessor {
+  public:
+    CUDAMemoryAccessor(CUcontext hContext, CUdevice hDevice)
+        : hDevice_(hDevice), hContext_(hContext) {}
+
+    void fill(void *ptr, size_t size, const void *pattern,
+              size_t pattern_size) {
+        ASSERT_NE(hContext_, nullptr);
+        ASSERT_GE(hDevice_, -1);
+        ASSERT_NE(ptr, nullptr);
+
+        int ret =
+            cuda_fill(hContext_, hDevice_, ptr, size, pattern, pattern_size);
+        ASSERT_EQ(ret, 0);
+    }
+
+    void copy(void *dst_ptr, void *src_ptr, size_t size) {
+        ASSERT_NE(hContext_, nullptr);
+        ASSERT_GE(hDevice_, -1);
+        ASSERT_NE(dst_ptr, nullptr);
+        ASSERT_NE(src_ptr, nullptr);
+
+        int ret = cuda_copy(hContext_, hDevice_, dst_ptr, src_ptr, size);
+        ASSERT_EQ(ret, 0);
+    }
+
+  private:
+    CUdevice hDevice_;
+    CUcontext hContext_;
+};
+
+struct umfCUDAProviderTest
+    : umf_test::test,
+      ::testing::WithParamInterface<umf_usm_memory_type_t> {
+
+    void SetUp() override {
+        test::SetUp();
+
+        umf_usm_memory_type_t memory_type = this->GetParam();
+
+        memAccessor = nullptr;
+        expected_context = cudaTestHelper.get_test_context();
+        expected_device = cudaTestHelper.get_test_device();
+        params = create_cuda_prov_params(cudaTestHelper.get_test_context(),
+                                         cudaTestHelper.get_test_device(),
+                                         memory_type, 0 /* alloc flags */);
+        ASSERT_NE(expected_context, nullptr);
+        ASSERT_GE(expected_device, 0);
+
+        switch (memory_type) {
+        case UMF_MEMORY_TYPE_DEVICE:
+            memAccessor = std::make_unique<CUDAMemoryAccessor>(
+                cudaTestHelper.get_test_context(),
+                cudaTestHelper.get_test_device());
+            break;
+        case UMF_MEMORY_TYPE_SHARED:
+        case UMF_MEMORY_TYPE_HOST:
+            memAccessor = std::make_unique<HostMemoryAccessor>();
+            break;
+        case UMF_MEMORY_TYPE_UNKNOWN:
+            break;
+        }
+
+        expected_memory_type = memory_type;
+    }
+
+    void TearDown() override {
+        if (params) {
+            destroyCuParams(params);
+        }
+
+        test::TearDown();
+    }
+
+    CUDATestHelper cudaTestHelper;
+    umf_cuda_memory_provider_params_handle_t params = nullptr;
+
+    std::unique_ptr<MemoryAccessor> memAccessor = nullptr;
+    CUcontext expected_context = nullptr;
+    int expected_device = -1;
+    umf_usm_memory_type_t expected_memory_type;
+};
+
+TEST_P(umfCUDAProviderTest, basic) {
+    const size_t size = 1024 * 8;
+    const uint32_t pattern = 0xAB;
+    CUcontext expected_current_context = get_current_context();
+
+    // create CUDA provider
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t umf_result =
+        umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    size_t pageSize = 0;
+    umf_result = umfMemoryProviderGetMinPageSize(provider, 0, &pageSize);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_GE(pageSize, 0);
+
+    umf_result =
+        umfMemoryProviderGetRecommendedPageSize(provider, 0, &pageSize);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_GE(pageSize, 0);
+
+    void *ptr = nullptr;
+    umf_result = umfMemoryProviderAlloc(provider, size, 128, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    // use the allocated memory - fill it with a 0xAB pattern
+    memAccessor->fill(ptr, size, &pattern, sizeof(pattern));
+
+    CUcontext actual_mem_context = get_mem_context(ptr);
+    ASSERT_EQ(actual_mem_context, expected_context);
+
+    CUcontext actual_current_context = get_current_context();
+    ASSERT_EQ(actual_current_context, expected_current_context);
+
+    umf_usm_memory_type_t memoryTypeActual =
+        get_mem_type(actual_current_context, ptr);
+    ASSERT_EQ(memoryTypeActual, expected_memory_type);
+
+    // check if the pattern was successfully applied
+    uint32_t *hostMemory = (uint32_t *)calloc(1, size);
+    memAccessor->copy(hostMemory, ptr, size);
+    for (size_t i = 0; i < size / sizeof(uint32_t); i++) {
+        ASSERT_EQ(hostMemory[i], pattern);
+    }
+    free(hostMemory);
+
+    umf_result = umfMemoryProviderFree(provider, ptr, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfMemoryProviderDestroy(provider);
+}
+
+TEST_P(umfCUDAProviderTest, getPageSize) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t umf_result =
+        umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    size_t recommendedPageSize = 0;
+    umf_result = umfMemoryProviderGetRecommendedPageSize(provider, 0,
+                                                         &recommendedPageSize);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_GE(recommendedPageSize, 0);
+
+    size_t minPageSize = 0;
+    umf_result =
+        umfMemoryProviderGetMinPageSize(provider, nullptr, &minPageSize);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_GE(minPageSize, 0);
+
+    ASSERT_GE(recommendedPageSize, minPageSize);
+
+    umfMemoryProviderDestroy(provider);
+}
+
+TEST_P(umfCUDAProviderTest, getName) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t umf_result =
+        umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    const char *name = umfMemoryProviderGetName(provider);
+    ASSERT_STREQ(name, "CUDA");
+
+    umfMemoryProviderDestroy(provider);
+}
+
+TEST_P(umfCUDAProviderTest, allocInvalidSize) {
+    CUcontext expected_current_context = get_current_context();
+    // create CUDA provider
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t umf_result =
+        umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    void *ptr = nullptr;
+
+    // NOTE: some scenarios are invalid only for the DEVICE allocations
+    if (expected_memory_type == UMF_MEMORY_TYPE_DEVICE) {
+        // try to alloc SIZE_MAX
+        umf_result = umfMemoryProviderAlloc(provider, SIZE_MAX, 0, &ptr);
+        ASSERT_EQ(ptr, nullptr);
+        ASSERT_EQ(umf_result, UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY);
+
+        // in case of size == 0 we should got INVALID_ARGUMENT error
+        umf_result = umfMemoryProviderAlloc(provider, 0, 0, &ptr);
+        ASSERT_EQ(ptr, nullptr);
+        ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    }
+
+    CUcontext actual_current_context = get_current_context();
+    ASSERT_EQ(actual_current_context, expected_current_context);
+
+    umfMemoryProviderDestroy(provider);
+}
+
+TEST_P(umfCUDAProviderTest, providerCreateInvalidArgs) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t umf_result =
+        umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), nullptr, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result = umfMemoryProviderCreate(nullptr, params, nullptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(umfCUDAProviderTest, getPageSizeInvalidArgs) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t umf_result =
+        umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    umf_result = umfMemoryProviderGetMinPageSize(provider, nullptr, nullptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result = umfMemoryProviderGetRecommendedPageSize(provider, 0, nullptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umfMemoryProviderDestroy(provider);
+}
+
+TEST_P(umfCUDAProviderTest, cudaProviderDefaultParams) {
+    umf_cuda_memory_provider_params_handle_t defaultParams = nullptr;
+    umf_result_t umf_result = umfCUDAMemoryProviderParamsCreate(&defaultParams);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfCUDAMemoryProviderParamsSetMemoryType(defaultParams,
+                                                          expected_memory_type);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // NOTE: we intentionally do not set any context and device params
+
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result = umfMemoryProviderCreate(umfCUDAMemoryProviderOps(),
+                                         defaultParams, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    // do single alloc and check if the context and device id of allocated
+    // memory are correct
+
+    void *ptr = nullptr;
+    umf_result = umfMemoryProviderAlloc(provider, 128, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    CUcontext actual_mem_context = get_mem_context(ptr);
+    ASSERT_EQ(actual_mem_context, expected_context);
+
+    int actual_device = get_mem_device(ptr);
+    ASSERT_EQ(actual_device, expected_device);
+
+    umf_result = umfMemoryProviderFree(provider, ptr, 128);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfMemoryProviderDestroy(provider);
+    umfCUDAMemoryProviderParamsDestroy(defaultParams);
+}
+
+TEST_P(umfCUDAProviderTest, cudaProviderNullParams) {
+    umf_result_t res = umfCUDAMemoryProviderParamsCreate(nullptr);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfCUDAMemoryProviderParamsSetContext(nullptr, expected_context);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfCUDAMemoryProviderParamsSetDevice(nullptr, 1);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res =
+        umfCUDAMemoryProviderParamsSetMemoryType(nullptr, expected_memory_type);
+    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);
+    ASSERT_EQ(ret, 0);
+
+    // create two CUDA contexts and two providers
+    CUcontext ctx1, ctx2;
+    ret = create_context(device, &ctx1);
+    ASSERT_EQ(ret, 0);
+    ret = create_context(device, &ctx2);
+    ASSERT_EQ(ret, 0);
+
+    umf_cuda_memory_provider_params_handle_t params1 =
+        create_cuda_prov_params(ctx1, device, UMF_MEMORY_TYPE_HOST, 0);
+    ASSERT_NE(params1, nullptr);
+    umf_memory_provider_handle_t provider1;
+    umf_result_t umf_result = umfMemoryProviderCreate(
+        umfCUDAMemoryProviderOps(), params1, &provider1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider1, nullptr);
+    umf_result = umfCUDAMemoryProviderParamsDestroy(params1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_cuda_memory_provider_params_handle_t params2 =
+        create_cuda_prov_params(ctx2, device, UMF_MEMORY_TYPE_HOST, 0);
+    ASSERT_NE(params2, nullptr);
+    umf_memory_provider_handle_t provider2;
+    umf_result = umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), params2,
+                                         &provider2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider2, nullptr);
+    umf_result = umfCUDAMemoryProviderParamsDestroy(params2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // use the providers
+    // allocate from 1, then from 2, then free 1, then free 2
+    void *ptr1, *ptr2;
+    const int size = 128;
+    // NOTE: we use ctx1 here
+    umf_result = umfMemoryProviderAlloc(provider1, size, 0, &ptr1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr1, nullptr);
+
+    // NOTE: we use ctx2 here
+    umf_result = umfMemoryProviderAlloc(provider2, size, 0, &ptr2);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr2, nullptr);
+
+    // even if we change the context, we should be able to free the memory
+    ret = set_context(ctx2, NULL);
+    ASSERT_EQ(ret, 0);
+    // free memory from ctx1
+    umf_result = umfMemoryProviderFree(provider1, ptr1, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    ret = set_context(ctx1, NULL);
+    ASSERT_EQ(ret, 0);
+    umf_result = umfMemoryProviderFree(provider2, ptr2, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    // cleanup
+    umfMemoryProviderDestroy(provider2);
+    umfMemoryProviderDestroy(provider1);
+    ret = destroy_context(ctx1);
+    ASSERT_EQ(ret, 0);
+    ret = destroy_context(ctx2);
+    ASSERT_EQ(ret, 0);
+}
+
+struct umfCUDAProviderAllocFlagsTest
+    : umf_test::test,
+      ::testing::WithParamInterface<
+          std::tuple<umf_usm_memory_type_t, unsigned int>> {
+
+    void SetUp() override {
+        test::SetUp();
+
+        get_cuda_device(&device);
+        create_context(device, &context);
+    }
+
+    void TearDown() override {
+        destroy_context(context);
+
+        test::TearDown();
+    }
+
+    CUdevice device;
+    CUcontext context;
+};
+
+TEST_P(umfCUDAProviderAllocFlagsTest, cudaAllocFlags) {
+    auto [memory_type, test_flags] = this->GetParam();
+
+    umf_cuda_memory_provider_params_handle_t test_params =
+        create_cuda_prov_params(context, device, memory_type, test_flags);
+
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t umf_result = umfMemoryProviderCreate(
+        umfCUDAMemoryProviderOps(), test_params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    void *ptr = nullptr;
+    umf_result = umfMemoryProviderAlloc(provider, 128, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    if (memory_type == UMF_MEMORY_TYPE_HOST) {
+        // check if the memory allocation flag is set correctly
+        unsigned int flags = get_mem_host_alloc_flags(ptr);
+        ASSERT_TRUE(flags & test_flags);
+    }
+
+    umf_result = umfMemoryProviderFree(provider, ptr, 128);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfMemoryProviderDestroy(provider);
+    umfCUDAMemoryProviderParamsDestroy(test_params);
+}
+
+TEST_P(umfCUDAProviderAllocFlagsTest, reuseParams) {
+    auto [memory_type, test_flags] = this->GetParam();
+
+    // first, create a provider for SHARED memory type with empty alloc flags,
+    // and the reuse the test_params to create a provider for test params
+    umf_cuda_memory_provider_params_handle_t test_params =
+        create_cuda_prov_params(context, device, UMF_MEMORY_TYPE_SHARED, 0);
+
+    umf_memory_provider_handle_t provider = nullptr;
+
+    umf_result_t umf_result = umfMemoryProviderCreate(
+        umfCUDAMemoryProviderOps(), test_params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    void *ptr = nullptr;
+    umf_result = umfMemoryProviderAlloc(provider, 128, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    umf_result = umfMemoryProviderFree(provider, ptr, 128);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfMemoryProviderDestroy(provider);
+
+    // reuse the test_params to create a provider for test params
+    umf_result =
+        umfCUDAMemoryProviderParamsSetMemoryType(test_params, memory_type);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result =
+        umfCUDAMemoryProviderParamsSetAllocFlags(test_params, test_flags);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umf_result = umfMemoryProviderCreate(umfCUDAMemoryProviderOps(),
+                                         test_params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    umf_result = umfMemoryProviderAlloc(provider, 128, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    if (memory_type == UMF_MEMORY_TYPE_HOST) {
+        // check if the memory allocation flag is set correctly
+        unsigned int flags = get_mem_host_alloc_flags(ptr);
+        ASSERT_TRUE(flags & test_flags);
+    }
+
+    umf_result = umfMemoryProviderFree(provider, ptr, 128);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfMemoryProviderDestroy(provider);
+
+    umfCUDAMemoryProviderParamsDestroy(test_params);
+}
+
+// TODO add tests that mixes CUDA Memory Provider and Disjoint Pool
+
+INSTANTIATE_TEST_SUITE_P(umfCUDAProviderTestSuite, umfCUDAProviderTest,
+                         ::testing::Values(UMF_MEMORY_TYPE_DEVICE,
+                                           UMF_MEMORY_TYPE_SHARED,
+                                           UMF_MEMORY_TYPE_HOST));
+
+INSTANTIATE_TEST_SUITE_P(
+    umfCUDAProviderAllocFlagsTestSuite, umfCUDAProviderAllocFlagsTest,
+    ::testing::Values(
+        std::make_tuple(UMF_MEMORY_TYPE_SHARED, CU_MEM_ATTACH_GLOBAL),
+        std::make_tuple(UMF_MEMORY_TYPE_SHARED, CU_MEM_ATTACH_HOST),
+        std::make_tuple(UMF_MEMORY_TYPE_HOST, CU_MEMHOSTALLOC_PORTABLE),
+        std::make_tuple(UMF_MEMORY_TYPE_HOST, CU_MEMHOSTALLOC_DEVICEMAP),
+        std::make_tuple(UMF_MEMORY_TYPE_HOST, CU_MEMHOSTALLOC_WRITECOMBINED)));
+
+// TODO: add IPC API
+GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest);
+/*
+INSTANTIATE_TEST_SUITE_P(umfCUDAProviderTestSuite, umfIpcTest,
+                         ::testing::Values(ipcTestParams{
+                             umfProxyPoolOps(), nullptr,
+                             umfCUDAMemoryProviderOps(),
+                             cuParams_device_memory.get(), &cuAccessor, false}));
+*/
diff --git a/test/providers/provider_cuda_not_impl.cpp b/test/providers/provider_cuda_not_impl.cpp
new file mode 100644
index 000000000..9ddea2048
--- /dev/null
+++ b/test/providers/provider_cuda_not_impl.cpp
@@ -0,0 +1,34 @@
+// Copyright (C) 2024-2025 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "base.hpp"
+
+#include <umf/providers/provider_cuda.h>
+
+using umf_test::test;
+
+TEST_F(test, cuda_provider_not_implemented) {
+    umf_cuda_memory_provider_params_handle_t hParams = nullptr;
+    umf_result_t result = umfCUDAMemoryProviderParamsCreate(&hParams);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    result = umfCUDAMemoryProviderParamsDestroy(hParams);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    result = umfCUDAMemoryProviderParamsSetContext(hParams, nullptr);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    result = umfCUDAMemoryProviderParamsSetDevice(hParams, 0);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    result = umfCUDAMemoryProviderParamsSetMemoryType(hParams,
+                                                      UMF_MEMORY_TYPE_DEVICE);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    result = umfCUDAMemoryProviderParamsSetAllocFlags(hParams, 0);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    const umf_memory_provider_ops_t *ops = umfCUDAMemoryProviderOps();
+    ASSERT_EQ(ops, nullptr);
+}
diff --git a/test/providers/provider_level_zero.cpp b/test/providers/provider_level_zero.cpp
index ae5ece59c..e30500d9d 100644
--- a/test/providers/provider_level_zero.cpp
+++ b/test/providers/provider_level_zero.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2024 Intel Corporation
+// Copyright (C) 2024-2025 Intel Corporation
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -12,13 +12,204 @@
 #include <umf/providers/provider_level_zero.h>
 
 #include "ipcFixtures.hpp"
-#include "level_zero_helpers.h"
 #include "pool.hpp"
+#include "utils_level_zero.h"
 #include "utils_load_library.h"
 
 using umf_test::test;
 using namespace umf_test;
 
+class LevelZeroTestHelper {
+  public:
+    LevelZeroTestHelper();
+
+    ~LevelZeroTestHelper() {
+        if (hContext_) {
+            utils_ze_destroy_context(hContext_);
+        }
+    }
+
+    ze_context_handle_t get_test_context() const { return hContext_; }
+
+    ze_device_handle_t get_test_device() const { return hDevice_; }
+
+  private:
+    ze_driver_handle_t hDriver_ = nullptr;
+    ze_context_handle_t hContext_ = nullptr;
+    ze_device_handle_t hDevice_ = nullptr;
+};
+
+LevelZeroTestHelper::LevelZeroTestHelper() {
+    uint32_t driver_idx = 0;
+
+    int ret = utils_ze_init_level_zero();
+    if (ret != 0) {
+        fprintf(stderr, "utils_ze_init_level_zero() failed!\n");
+        return;
+    }
+
+    ret = utils_ze_find_driver_with_gpu(&driver_idx, &hDriver_);
+    if (ret != 0 || hDriver_ == NULL) {
+        fprintf(stderr, "utils_ze_find_driver_with_gpu() failed!\n");
+        return;
+    }
+
+    ret = utils_ze_find_gpu_device(hDriver_, &hDevice_);
+    if (ret != 0 || hDevice_ == NULL) {
+        fprintf(stderr, "utils_ze_find_gpu_device() failed!\n");
+        return;
+    }
+
+    ret = utils_ze_create_context(hDriver_, &hContext_);
+    if (ret != 0) {
+        fprintf(stderr, "utils_ze_create_context() failed!\n");
+        return;
+    }
+}
+
+umf_level_zero_memory_provider_params_handle_t
+create_level_zero_prov_params(ze_context_handle_t context,
+                              ze_device_handle_t device,
+                              umf_usm_memory_type_t memory_type) {
+    umf_level_zero_memory_provider_params_handle_t params = nullptr;
+
+    umf_result_t res = umfLevelZeroMemoryProviderParamsCreate(&params);
+    if (res != UMF_RESULT_SUCCESS) {
+        return nullptr;
+    }
+
+    res = umfLevelZeroMemoryProviderParamsSetContext(params, context);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfLevelZeroMemoryProviderParamsDestroy(params);
+        return nullptr;
+    }
+
+    res = umfLevelZeroMemoryProviderParamsSetDevice(params, device);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfLevelZeroMemoryProviderParamsDestroy(params);
+        return nullptr;
+    }
+
+    res = umfLevelZeroMemoryProviderParamsSetMemoryType(params, memory_type);
+    if (res != UMF_RESULT_SUCCESS) {
+        umfLevelZeroMemoryProviderParamsDestroy(params);
+        return nullptr;
+    }
+
+    return params;
+}
+
+umf_result_t destroyL0Params(void *params) {
+    return umfLevelZeroMemoryProviderParamsDestroy(
+        static_cast<umf_level_zero_memory_provider_params_handle_t>(params));
+}
+
+struct LevelZeroProviderInit
+    : public test,
+      public ::testing::WithParamInterface<umf_usm_memory_type_t> {
+    LevelZeroTestHelper l0TestHelper;
+};
+
+INSTANTIATE_TEST_SUITE_P(, LevelZeroProviderInit,
+                         ::testing::Values(UMF_MEMORY_TYPE_HOST,
+                                           UMF_MEMORY_TYPE_DEVICE,
+                                           UMF_MEMORY_TYPE_SHARED));
+
+TEST_P(LevelZeroProviderInit, FailNullContext) {
+    const umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
+    ASSERT_NE(ops, nullptr);
+
+    auto memory_type = GetParam();
+
+    umf_level_zero_memory_provider_params_handle_t hParams = nullptr;
+    umf_result_t result = umfLevelZeroMemoryProviderParamsCreate(&hParams);
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    result =
+        umfLevelZeroMemoryProviderParamsSetMemoryType(hParams, memory_type);
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    result = umfLevelZeroMemoryProviderParamsSetDevice(
+        hParams, l0TestHelper.get_test_device());
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+
+    result = umfLevelZeroMemoryProviderParamsSetContext(hParams, nullptr);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_memory_provider_handle_t provider = nullptr;
+    result = umfMemoryProviderCreate(ops, hParams, &provider);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umfLevelZeroMemoryProviderParamsDestroy(hParams);
+}
+
+TEST_P(LevelZeroProviderInit, FailNullDevice) {
+    if (GetParam() == UMF_MEMORY_TYPE_HOST) {
+        GTEST_SKIP() << "Host memory does not require device handle";
+    }
+
+    const umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
+    ASSERT_NE(ops, nullptr);
+
+    auto memory_type = GetParam();
+    umf_level_zero_memory_provider_params_handle_t hParams = nullptr;
+    umf_result_t result = umfLevelZeroMemoryProviderParamsCreate(&hParams);
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    result =
+        umfLevelZeroMemoryProviderParamsSetMemoryType(hParams, memory_type);
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    result = umfLevelZeroMemoryProviderParamsSetContext(
+        hParams, l0TestHelper.get_test_context());
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+
+    umf_memory_provider_handle_t provider = nullptr;
+    result = umfMemoryProviderCreate(ops, hParams, &provider);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umfLevelZeroMemoryProviderParamsDestroy(hParams);
+}
+
+TEST_F(LevelZeroProviderInit, FailNonNullDevice) {
+    if (GetParam() != UMF_MEMORY_TYPE_HOST) {
+        GTEST_SKIP() << "Host memory does not require device handle";
+    }
+    const umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
+    ASSERT_NE(ops, nullptr);
+
+    auto memory_type = GetParam();
+    umf_level_zero_memory_provider_params_handle_t hParams = nullptr;
+    umf_result_t result = umfLevelZeroMemoryProviderParamsCreate(&hParams);
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    result =
+        umfLevelZeroMemoryProviderParamsSetMemoryType(hParams, memory_type);
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    result = umfLevelZeroMemoryProviderParamsSetContext(
+        hParams, l0TestHelper.get_test_context());
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+    result = umfLevelZeroMemoryProviderParamsSetDevice(
+        hParams, l0TestHelper.get_test_device());
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+
+    umf_memory_provider_handle_t provider = nullptr;
+    result = umfMemoryProviderCreate(ops, hParams, &provider);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umfLevelZeroMemoryProviderParamsDestroy(hParams);
+}
+
+TEST_F(test, FailMismatchedResidentHandlesCount) {
+    const umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
+    ASSERT_NE(ops, nullptr);
+
+    umf_level_zero_memory_provider_params_handle_t hParams = nullptr;
+    umf_result_t result = umfLevelZeroMemoryProviderParamsCreate(&hParams);
+    ASSERT_EQ(result, UMF_RESULT_SUCCESS);
+
+    result = umfLevelZeroMemoryProviderParamsSetResidentDevices(hParams,
+                                                                nullptr, 99);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umfLevelZeroMemoryProviderParamsDestroy(hParams);
+}
+
 class LevelZeroMemoryAccessor : public MemoryAccessor {
   public:
     LevelZeroMemoryAccessor(ze_context_handle_t hContext,
@@ -28,8 +219,8 @@ class LevelZeroMemoryAccessor : public MemoryAccessor {
               size_t pattern_size) {
         ASSERT_NE(ptr, nullptr);
 
-        int ret = level_zero_fill(hContext_, hDevice_, ptr, size, pattern,
-                                  pattern_size);
+        int ret = utils_ze_level_zero_fill(hContext_, hDevice_, ptr, size,
+                                           pattern, pattern_size);
         ASSERT_EQ(ret, 0);
     }
 
@@ -37,7 +228,8 @@ class LevelZeroMemoryAccessor : public MemoryAccessor {
         ASSERT_NE(dst_ptr, nullptr);
         ASSERT_NE(src_ptr, nullptr);
 
-        int ret = level_zero_copy(hContext_, hDevice_, dst_ptr, src_ptr, size);
+        int ret = utils_ze_level_zero_copy(hContext_, hDevice_, dst_ptr,
+                                           src_ptr, size);
         ASSERT_EQ(ret, 0);
     }
 
@@ -46,33 +238,43 @@ class LevelZeroMemoryAccessor : public MemoryAccessor {
     ze_context_handle_t hContext_;
 };
 
-using LevelZeroProviderTestParams =
-    std::tuple<level_zero_memory_provider_params_t, MemoryAccessor *>;
-
 struct umfLevelZeroProviderTest
     : umf_test::test,
-      ::testing::WithParamInterface<LevelZeroProviderTestParams> {
+      ::testing::WithParamInterface<umf_usm_memory_type_t> {
 
     void SetUp() override {
         test::SetUp();
 
-        auto [l0_params, accessor] = this->GetParam();
-        params = l0_params;
-        hDevice = (ze_device_handle_t)params.level_zero_device_handle;
-        hContext = (ze_context_handle_t)params.level_zero_context_handle;
+        umf_usm_memory_type_t memory_type = this->GetParam();
+
+        params = nullptr;
+        memAccessor = nullptr;
+        hContext = l0TestHelper.get_test_context();
 
-        ASSERT_NE(hDevice, nullptr);
         ASSERT_NE(hContext, nullptr);
 
-        switch (params.memory_type) {
+        switch (memory_type) {
         case UMF_MEMORY_TYPE_DEVICE:
             zeMemoryTypeExpected = ZE_MEMORY_TYPE_DEVICE;
+            params = create_level_zero_prov_params(
+                l0TestHelper.get_test_context(), l0TestHelper.get_test_device(),
+                memory_type);
+            memAccessor = std::make_unique<LevelZeroMemoryAccessor>(
+                l0TestHelper.get_test_context(),
+                l0TestHelper.get_test_device());
             break;
         case UMF_MEMORY_TYPE_SHARED:
             zeMemoryTypeExpected = ZE_MEMORY_TYPE_SHARED;
+            params = create_level_zero_prov_params(
+                l0TestHelper.get_test_context(), l0TestHelper.get_test_device(),
+                memory_type);
+            memAccessor = std::make_unique<HostMemoryAccessor>();
             break;
         case UMF_MEMORY_TYPE_HOST:
             zeMemoryTypeExpected = ZE_MEMORY_TYPE_HOST;
+            params = create_level_zero_prov_params(
+                l0TestHelper.get_test_context(), nullptr, memory_type);
+            memAccessor = std::make_unique<HostMemoryAccessor>();
             break;
         case UMF_MEMORY_TYPE_UNKNOWN:
             zeMemoryTypeExpected = ZE_MEMORY_TYPE_UNKNOWN;
@@ -80,21 +282,22 @@ struct umfLevelZeroProviderTest
         }
 
         ASSERT_NE(zeMemoryTypeExpected, ZE_MEMORY_TYPE_UNKNOWN);
-
-        memAccessor = accessor;
     }
 
     void TearDown() override {
-        int ret = destroy_context(hContext);
-        ASSERT_EQ(ret, 0);
+        if (params) {
+            destroyL0Params(params);
+        }
+
         test::TearDown();
     }
 
-    level_zero_memory_provider_params_t params;
-    ze_device_handle_t hDevice = nullptr;
+    LevelZeroTestHelper l0TestHelper;
+    umf_level_zero_memory_provider_params_handle_t params = nullptr;
+
+    std::unique_ptr<MemoryAccessor> memAccessor = nullptr;
     ze_context_handle_t hContext = nullptr;
     ze_memory_type_t zeMemoryTypeExpected = ZE_MEMORY_TYPE_UNKNOWN;
-    MemoryAccessor *memAccessor = nullptr;
 };
 
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfLevelZeroProviderTest);
@@ -106,7 +309,7 @@ TEST_P(umfLevelZeroProviderTest, basic) {
     // create Level Zero provider
     umf_memory_provider_handle_t provider = nullptr;
     umf_result_t umf_result = umfMemoryProviderCreate(
-        umfLevelZeroMemoryProviderOps(), &params, &provider);
+        umfLevelZeroMemoryProviderOps(), params, &provider);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_NE(provider, nullptr);
 
@@ -118,7 +321,7 @@ TEST_P(umfLevelZeroProviderTest, basic) {
     // use the allocated memory - fill it with a 0xAB pattern
     memAccessor->fill(ptr, size, &pattern, sizeof(pattern));
 
-    ze_memory_type_t zeMemoryTypeActual = get_mem_type(hContext, ptr);
+    ze_memory_type_t zeMemoryTypeActual = utils_ze_get_mem_type(hContext, ptr);
     ASSERT_EQ(zeMemoryTypeActual, zeMemoryTypeExpected);
 
     // check if the pattern was successfully applied
@@ -135,38 +338,175 @@ TEST_P(umfLevelZeroProviderTest, basic) {
     umfMemoryProviderDestroy(provider);
 }
 
-// TODO add Level Zero Memory Provider specyfic tests
-// TODO add negative test and check for Level Zero native errors
-// TODO add tests that mixes Level Zero Memory Provider and Disjoint Pool
+TEST_P(umfLevelZeroProviderTest, getPageSize) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t umf_result = umfMemoryProviderCreate(
+        umfLevelZeroMemoryProviderOps(), params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
 
-level_zero_memory_provider_params_t l0Params_device_memory =
-    create_level_zero_prov_params(UMF_MEMORY_TYPE_DEVICE);
-level_zero_memory_provider_params_t l0Params_shared_memory =
-    create_level_zero_prov_params(UMF_MEMORY_TYPE_SHARED);
-level_zero_memory_provider_params_t l0Params_host_memory =
-    create_level_zero_prov_params(UMF_MEMORY_TYPE_HOST);
+    size_t recommendedPageSize = 0;
+    umf_result = umfMemoryProviderGetRecommendedPageSize(provider, 0,
+                                                         &recommendedPageSize);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_GE(recommendedPageSize, 0);
 
-LevelZeroMemoryAccessor l0Accessor(
-    (ze_context_handle_t)l0Params_device_memory.level_zero_context_handle,
-    (ze_device_handle_t)l0Params_device_memory.level_zero_device_handle);
+    size_t minPageSize = 0;
+    umf_result =
+        umfMemoryProviderGetMinPageSize(provider, nullptr, &minPageSize);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_GE(minPageSize, 0);
 
-HostMemoryAccessor hostAccessor;
+    ASSERT_GE(recommendedPageSize, minPageSize);
 
-INSTANTIATE_TEST_SUITE_P(
-    umfLevelZeroProviderTestSuite, umfLevelZeroProviderTest,
-    ::testing::Values(
-        LevelZeroProviderTestParams{l0Params_device_memory, &l0Accessor},
-        LevelZeroProviderTestParams{l0Params_shared_memory, &hostAccessor},
-        LevelZeroProviderTestParams{l0Params_host_memory, &hostAccessor}));
+    void *ptr;
+    umf_result = umfMemoryProviderAlloc(provider, 1, 0, &ptr);
+
+    size_t actualPageSize = 0;
+    umf_result =
+        umfMemoryProviderGetMinPageSize(provider, ptr, &actualPageSize);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_GE(actualPageSize, minPageSize);
+
+    umf_result = umfMemoryProviderFree(provider, ptr, 1);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+
+    umfMemoryProviderDestroy(provider);
+}
+
+TEST_P(umfLevelZeroProviderTest, getName) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t umf_result = umfMemoryProviderCreate(
+        umfLevelZeroMemoryProviderOps(), params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    const char *name = umfMemoryProviderGetName(provider);
+    ASSERT_STREQ(name, "LEVEL_ZERO");
+
+    umfMemoryProviderDestroy(provider);
+}
+
+TEST_P(umfLevelZeroProviderTest, allocInvalidSize) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t umf_result = umfMemoryProviderCreate(
+        umfLevelZeroMemoryProviderOps(), params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    void *ptr = nullptr;
+    umf_result = umfMemoryProviderAlloc(
+        provider, std::numeric_limits<size_t>::max(), 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC);
+    const char *message;
+    int32_t error;
+    umfMemoryProviderGetLastNativeError(provider, &message, &error);
+    ASSERT_EQ(error, ZE_RESULT_ERROR_UNSUPPORTED_SIZE);
+
+    umfMemoryProviderDestroy(provider);
+}
 
+TEST_P(umfLevelZeroProviderTest, providerCreateInvalidArgs) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t umf_result = umfMemoryProviderCreate(
+        umfLevelZeroMemoryProviderOps(), nullptr, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result = umfMemoryProviderCreate(nullptr, params, nullptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(umfLevelZeroProviderTest, getPageSizeInvalidArgs) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t umf_result = umfMemoryProviderCreate(
+        umfLevelZeroMemoryProviderOps(), params, &provider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    umf_result = umfMemoryProviderGetMinPageSize(provider, nullptr, nullptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umf_result = umfMemoryProviderGetRecommendedPageSize(provider, 0, nullptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umfMemoryProviderDestroy(provider);
+}
+
+TEST_P(umfLevelZeroProviderTest, levelZeroProviderNullParams) {
+    umf_result_t res = umfLevelZeroMemoryProviderParamsCreate(nullptr);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfLevelZeroMemoryProviderParamsSetContext(nullptr, hContext);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfLevelZeroMemoryProviderParamsSetDevice(nullptr, nullptr);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfLevelZeroMemoryProviderParamsSetMemoryType(nullptr,
+                                                        UMF_MEMORY_TYPE_DEVICE);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    res = umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(nullptr, 0);
+    EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_P(umfLevelZeroProviderTest, setDeviceOrdinalValid) {
+    int64_t numProps =
+        utils_ze_get_num_memory_properties(l0TestHelper.get_test_device());
+    ASSERT_GE(numProps, 0);
+
+    for (uint32_t ordinal = 0; ordinal < static_cast<uint32_t>(numProps);
+         ordinal++) {
+        umf_memory_provider_handle_t provider = nullptr;
+        umf_result_t res =
+            umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(params, ordinal);
+        EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+
+        res = umfMemoryProviderCreate(umfLevelZeroMemoryProviderOps(), params,
+                                      &provider);
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+        ASSERT_NE(provider, nullptr);
+
+        size_t size = 1024;
+        void *ptr = nullptr;
+        res = umfMemoryProviderAlloc(provider, size, 0, &ptr);
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ptr, nullptr);
+
+        res = umfMemoryProviderFree(provider, ptr, size);
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+
+        umfMemoryProviderDestroy(provider);
+    }
+}
+
+// TODO add tests that mixes Level Zero Memory Provider and Disjoint Pool
+
+INSTANTIATE_TEST_SUITE_P(umfLevelZeroProviderTestSuite,
+                         umfLevelZeroProviderTest,
+                         ::testing::Values(UMF_MEMORY_TYPE_DEVICE,
+                                           UMF_MEMORY_TYPE_SHARED,
+                                           UMF_MEMORY_TYPE_HOST));
+
+LevelZeroTestHelper l0TestHelper;
+
+void *createL0ParamsDeviceMemory() {
+    return create_level_zero_prov_params(l0TestHelper.get_test_context(),
+                                         l0TestHelper.get_test_device(),
+                                         UMF_MEMORY_TYPE_DEVICE);
+}
+
+LevelZeroMemoryAccessor
+    l0Accessor((ze_context_handle_t)l0TestHelper.get_test_context(),
+               (ze_device_handle_t)l0TestHelper.get_test_device());
 // TODO: it looks like there is some problem with IPC implementation in Level
 // Zero on windows. Issue: #494
 #ifdef _WIN32
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest);
 #else
-INSTANTIATE_TEST_SUITE_P(umfLevelZeroProviderTestSuite, umfIpcTest,
-                         ::testing::Values(ipcTestParams{
-                             umfProxyPoolOps(), nullptr,
-                             umfLevelZeroMemoryProviderOps(),
-                             &l0Params_device_memory, &l0Accessor}));
+INSTANTIATE_TEST_SUITE_P(
+    umfLevelZeroProviderTestSuite, umfIpcTest,
+    ::testing::Values(ipcTestParams{
+        umfProxyPoolOps(), nullptr, nullptr, umfLevelZeroMemoryProviderOps(),
+        createL0ParamsDeviceMemory, destroyL0Params, &l0Accessor}));
 #endif
diff --git a/test/providers/provider_level_zero_not_impl.cpp b/test/providers/provider_level_zero_not_impl.cpp
new file mode 100644
index 000000000..dfbd4a2b2
--- /dev/null
+++ b/test/providers/provider_level_zero_not_impl.cpp
@@ -0,0 +1,43 @@
+// Copyright (C) 2024-2025 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "base.hpp"
+
+#include <umf/providers/provider_level_zero.h>
+
+using umf_test::test;
+
+TEST_F(test, level_zero_provider_not_implemented) {
+    umf_level_zero_memory_provider_params_handle_t hParams = nullptr;
+    umf_result_t result = umfLevelZeroMemoryProviderParamsCreate(&hParams);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    result = umfLevelZeroMemoryProviderParamsDestroy(hParams);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    result = umfLevelZeroMemoryProviderParamsSetContext(hParams, nullptr);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    result = umfLevelZeroMemoryProviderParamsSetDevice(hParams, nullptr);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    result = umfLevelZeroMemoryProviderParamsSetMemoryType(
+        hParams, UMF_MEMORY_TYPE_DEVICE);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    ze_device_handle_t hDevices[1];
+    result = umfLevelZeroMemoryProviderParamsSetResidentDevices(hParams,
+                                                                hDevices, 1);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    result = umfLevelZeroMemoryProviderParamsSetFreePolicy(
+        hParams, UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFAULT);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    result = umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(hParams, 0);
+    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    const umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
+    ASSERT_EQ(ops, nullptr);
+}
diff --git a/test/supp/drd-test_ipc.supp b/test/supp/drd-test_ipc.supp
new file mode 100644
index 000000000..e55b2ee8d
--- /dev/null
+++ b/test/supp/drd-test_ipc.supp
@@ -0,0 +1,28 @@
+{
+   Conditional variable destruction false-positive
+   drd:CondErr
+   ...
+   fun:pthread_cond_destroy@*
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
diff --git a/test/supp/drd-test_ipc_max_opened_limit.supp b/test/supp/drd-test_ipc_max_opened_limit.supp
new file mode 100644
index 000000000..e55b2ee8d
--- /dev/null
+++ b/test/supp/drd-test_ipc_max_opened_limit.supp
@@ -0,0 +1,28 @@
+{
+   Conditional variable destruction false-positive
+   drd:CondErr
+   ...
+   fun:pthread_cond_destroy@*
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
diff --git a/test/supp/drd-test_jemalloc_coarse_devdax.supp b/test/supp/drd-test_jemalloc_coarse_devdax.supp
new file mode 100644
index 000000000..cb6179f87
--- /dev/null
+++ b/test/supp/drd-test_jemalloc_coarse_devdax.supp
@@ -0,0 +1,7 @@
+{
+   False-positive ConflictingAccess in jemalloc
+   drd:ConflictingAccess
+   ...
+   fun:je_*
+   ...
+}
diff --git a/test/supp/drd-test_jemalloc_coarse_file.supp b/test/supp/drd-test_jemalloc_coarse_file.supp
new file mode 100644
index 000000000..cb6179f87
--- /dev/null
+++ b/test/supp/drd-test_jemalloc_coarse_file.supp
@@ -0,0 +1,7 @@
+{
+   False-positive ConflictingAccess in jemalloc
+   drd:ConflictingAccess
+   ...
+   fun:je_*
+   ...
+}
diff --git a/test/supp/drd-test_jemalloc_pool.supp b/test/supp/drd-test_jemalloc_pool.supp
new file mode 100644
index 000000000..cb6179f87
--- /dev/null
+++ b/test/supp/drd-test_jemalloc_pool.supp
@@ -0,0 +1,7 @@
+{
+   False-positive ConflictingAccess in jemalloc
+   drd:ConflictingAccess
+   ...
+   fun:je_*
+   ...
+}
diff --git a/test/supp/drd-test_provider_devdax_memory_ipc.supp b/test/supp/drd-test_provider_devdax_memory_ipc.supp
new file mode 100644
index 000000000..31608d30c
--- /dev/null
+++ b/test/supp/drd-test_provider_devdax_memory_ipc.supp
@@ -0,0 +1,37 @@
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   False-positive ConflictingAccess in jemalloc
+   drd:ConflictingAccess
+   fun:atomic_*
+   ...
+   fun:je_*
+   ...
+}
+
+{
+   False-positive ConflictingAccess in tbbmalloc
+   drd:ConflictingAccess
+   ...
+   fun:tbb_pool_finalize
+   ...
+}
diff --git a/test/supp/drd-test_provider_file_memory_ipc.supp b/test/supp/drd-test_provider_file_memory_ipc.supp
new file mode 100644
index 000000000..2252cb021
--- /dev/null
+++ b/test/supp/drd-test_provider_file_memory_ipc.supp
@@ -0,0 +1,45 @@
+{
+   Conditional variable destruction false-positive
+   drd:CondErr
+   ...
+   fun:pthread_cond_destroy@*
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   False-positive ConflictingAccess in jemalloc
+   drd:ConflictingAccess
+   fun:atomic_*
+   ...
+   fun:je_*
+   ...
+}
+
+{
+   False-positive ConflictingAccess in tbbmalloc
+   drd:ConflictingAccess
+   ...
+   fun:tbb_pool_finalize
+   ...
+}
diff --git a/test/supp/drd-test_provider_os_memory.supp b/test/supp/drd-test_provider_os_memory.supp
new file mode 100644
index 000000000..31608d30c
--- /dev/null
+++ b/test/supp/drd-test_provider_os_memory.supp
@@ -0,0 +1,37 @@
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   drd:ConflictingAccess
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   False-positive ConflictingAccess in jemalloc
+   drd:ConflictingAccess
+   fun:atomic_*
+   ...
+   fun:je_*
+   ...
+}
+
+{
+   False-positive ConflictingAccess in tbbmalloc
+   drd:ConflictingAccess
+   ...
+   fun:tbb_pool_finalize
+   ...
+}
diff --git a/test/supp/drd-test_scalable_coarse_devdax.supp b/test/supp/drd-test_scalable_coarse_devdax.supp
new file mode 100644
index 000000000..65640f6c3
--- /dev/null
+++ b/test/supp/drd-test_scalable_coarse_devdax.supp
@@ -0,0 +1,49 @@
+{
+   False-positive ConflictingAccess in libtbbmalloc.so
+   drd:ConflictingAccess
+   obj:*/libtbbmalloc.so*
+}
+
+{
+   False-positive ConflictingAccess in libtbbmalloc.so
+   drd:ConflictingAccess
+   obj:*/libtbbmalloc.so*
+   ...
+   fun:tbb_malloc
+   ...
+}
+
+{
+   False-positive ConflictingAccess in libtbbmalloc.so
+   drd:ConflictingAccess
+   obj:*/libtbbmalloc.so*
+   ...
+   fun:tbb_aligned_malloc
+   ...
+}
+
+{
+   False-positive ConflictingAccess in libtbbmalloc.so
+   drd:ConflictingAccess
+   obj:*/libtbbmalloc.so*
+   ...
+   fun:tbb_free
+   ...
+}
+
+{
+   False-positive ConflictingAccess in libtbbmalloc.so
+   drd:ConflictingAccess
+   obj:*/libtbbmalloc.so*
+   ...
+   fun:__nptl_deallocate_tsd
+   ...
+}
+
+{
+   False-positive ConflictingAccess in _Z22pow2AlignedAllocHelperP17umf_memory_pool_t
+   drd:ConflictingAccess
+   fun:memset
+   fun:_Z22pow2AlignedAllocHelperP17umf_memory_pool_t
+   ...
+}
diff --git a/test/supp/drd-test_scalable_coarse_file.supp b/test/supp/drd-test_scalable_coarse_file.supp
new file mode 100644
index 000000000..65640f6c3
--- /dev/null
+++ b/test/supp/drd-test_scalable_coarse_file.supp
@@ -0,0 +1,49 @@
+{
+   False-positive ConflictingAccess in libtbbmalloc.so
+   drd:ConflictingAccess
+   obj:*/libtbbmalloc.so*
+}
+
+{
+   False-positive ConflictingAccess in libtbbmalloc.so
+   drd:ConflictingAccess
+   obj:*/libtbbmalloc.so*
+   ...
+   fun:tbb_malloc
+   ...
+}
+
+{
+   False-positive ConflictingAccess in libtbbmalloc.so
+   drd:ConflictingAccess
+   obj:*/libtbbmalloc.so*
+   ...
+   fun:tbb_aligned_malloc
+   ...
+}
+
+{
+   False-positive ConflictingAccess in libtbbmalloc.so
+   drd:ConflictingAccess
+   obj:*/libtbbmalloc.so*
+   ...
+   fun:tbb_free
+   ...
+}
+
+{
+   False-positive ConflictingAccess in libtbbmalloc.so
+   drd:ConflictingAccess
+   obj:*/libtbbmalloc.so*
+   ...
+   fun:__nptl_deallocate_tsd
+   ...
+}
+
+{
+   False-positive ConflictingAccess in _Z22pow2AlignedAllocHelperP17umf_memory_pool_t
+   drd:ConflictingAccess
+   fun:memset
+   fun:_Z22pow2AlignedAllocHelperP17umf_memory_pool_t
+   ...
+}
diff --git a/test/supp/drd-umf_test-scalable_pool.supp b/test/supp/drd-test_scalable_pool.supp
similarity index 100%
rename from test/supp/drd-umf_test-scalable_pool.supp
rename to test/supp/drd-test_scalable_pool.supp
diff --git a/test/supp/drd-umf_test-ipc.supp b/test/supp/drd-umf_test-ipc.supp
deleted file mode 100644
index 76844585d..000000000
--- a/test/supp/drd-umf_test-ipc.supp
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-   Conditional variable destruction false-positive
-   drd:CondErr
-   ...
-   fun:pthread_cond_destroy@*
-   ...
-}
diff --git a/test/supp/drd-umf_test-jemalloc_pool.supp b/test/supp/drd-umf_test-jemalloc_pool.supp
deleted file mode 100644
index 965ef3884..000000000
--- a/test/supp/drd-umf_test-jemalloc_pool.supp
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-   Conflicting Access in libjemalloc.so - internal issue of libjemalloc
-   drd:ConflictingAccess
-   obj:*libjemalloc.so*
-   ...
-}
diff --git a/test/supp/helgrind-umf_test-disjointPool.supp b/test/supp/helgrind-test_disjoint_pool.supp
similarity index 100%
rename from test/supp/helgrind-umf_test-disjointPool.supp
rename to test/supp/helgrind-test_disjoint_pool.supp
diff --git a/test/supp/helgrind-test_ipc.supp b/test/supp/helgrind-test_ipc.supp
new file mode 100644
index 000000000..fb17fd7a0
--- /dev/null
+++ b/test/supp/helgrind-test_ipc.supp
@@ -0,0 +1,20 @@
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
diff --git a/test/supp/helgrind-test_ipc_max_opened_limit.supp b/test/supp/helgrind-test_ipc_max_opened_limit.supp
new file mode 100644
index 000000000..fb17fd7a0
--- /dev/null
+++ b/test/supp/helgrind-test_ipc_max_opened_limit.supp
@@ -0,0 +1,20 @@
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
diff --git a/test/supp/helgrind-test_jemalloc_coarse_devdax.supp b/test/supp/helgrind-test_jemalloc_coarse_devdax.supp
new file mode 100644
index 000000000..98d748fea
--- /dev/null
+++ b/test/supp/helgrind-test_jemalloc_coarse_devdax.supp
@@ -0,0 +1,7 @@
+{
+   False-positive Race in jemalloc
+   Helgrind:Race
+   ...
+   fun:je_*
+   ...
+}
diff --git a/test/supp/helgrind-test_jemalloc_coarse_file.supp b/test/supp/helgrind-test_jemalloc_coarse_file.supp
new file mode 100644
index 000000000..98d748fea
--- /dev/null
+++ b/test/supp/helgrind-test_jemalloc_coarse_file.supp
@@ -0,0 +1,7 @@
+{
+   False-positive Race in jemalloc
+   Helgrind:Race
+   ...
+   fun:je_*
+   ...
+}
diff --git a/test/supp/helgrind-test_jemalloc_pool.supp b/test/supp/helgrind-test_jemalloc_pool.supp
new file mode 100644
index 000000000..98d748fea
--- /dev/null
+++ b/test/supp/helgrind-test_jemalloc_pool.supp
@@ -0,0 +1,7 @@
+{
+   False-positive Race in jemalloc
+   Helgrind:Race
+   ...
+   fun:je_*
+   ...
+}
diff --git a/test/supp/helgrind-test_provider_devdax_memory_ipc.supp b/test/supp/helgrind-test_provider_devdax_memory_ipc.supp
new file mode 100644
index 000000000..63e7d626c
--- /dev/null
+++ b/test/supp/helgrind-test_provider_devdax_memory_ipc.supp
@@ -0,0 +1,37 @@
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   False-positive ConflictingAccess in jemalloc
+   Helgrind:Race
+   fun:atomic_*
+   ...
+   fun:je_*
+   ...
+}
+
+{
+   False-positive ConflictingAccess in tbbmalloc
+   Helgrind:Race
+   ...
+   fun:tbb_pool_finalize
+   ...
+}
diff --git a/test/supp/helgrind-test_provider_file_memory_ipc.supp b/test/supp/helgrind-test_provider_file_memory_ipc.supp
new file mode 100644
index 000000000..63e7d626c
--- /dev/null
+++ b/test/supp/helgrind-test_provider_file_memory_ipc.supp
@@ -0,0 +1,37 @@
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   False-positive ConflictingAccess in jemalloc
+   Helgrind:Race
+   fun:atomic_*
+   ...
+   fun:je_*
+   ...
+}
+
+{
+   False-positive ConflictingAccess in tbbmalloc
+   Helgrind:Race
+   ...
+   fun:tbb_pool_finalize
+   ...
+}
diff --git a/test/supp/helgrind-test_provider_os_memory.supp b/test/supp/helgrind-test_provider_os_memory.supp
new file mode 100644
index 000000000..63e7d626c
--- /dev/null
+++ b/test/supp/helgrind-test_provider_os_memory.supp
@@ -0,0 +1,37 @@
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_store_release_ptr
+   fun:upstreamOpenIPCHandle
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   [false-positive] Double check locking pattern in trackingOpenIpcHandle
+   Helgrind:Race
+   fun:utils_atomic_load_acquire_ptr
+   fun:trackingOpenIpcHandle
+   fun:umfMemoryProviderOpenIPCHandle
+   fun:umfOpenIPCHandle
+   ...
+}
+
+{
+   False-positive ConflictingAccess in jemalloc
+   Helgrind:Race
+   fun:atomic_*
+   ...
+   fun:je_*
+   ...
+}
+
+{
+   False-positive ConflictingAccess in tbbmalloc
+   Helgrind:Race
+   ...
+   fun:tbb_pool_finalize
+   ...
+}
diff --git a/test/supp/helgrind-test_scalable_coarse_devdax.supp b/test/supp/helgrind-test_scalable_coarse_devdax.supp
new file mode 100644
index 000000000..650edf514
--- /dev/null
+++ b/test/supp/helgrind-test_scalable_coarse_devdax.supp
@@ -0,0 +1,49 @@
+{
+   False-positive Race in libtbbmalloc.so
+   Helgrind:Race
+   obj:*/libtbbmalloc.so*
+}
+
+{
+   False-positive Race in libtbbmalloc.so
+   Helgrind:Race
+   obj:*/libtbbmalloc.so*
+   ...
+   fun:tbb_malloc
+   ...
+}
+
+{
+   False-positive Race in libtbbmalloc.so
+   Helgrind:Race
+   obj:*/libtbbmalloc.so*
+   ...
+   fun:tbb_aligned_malloc
+   ...
+}
+
+{
+   False-positive Race in libtbbmalloc.so
+   Helgrind:Race
+   obj:*/libtbbmalloc.so*
+   ...
+   fun:tbb_free
+   ...
+}
+
+{
+   False-positive Race in libtbbmalloc.so
+   Helgrind:Race
+   obj:*/libtbbmalloc.so*
+   ...
+   fun:__nptl_deallocate_tsd
+   ...
+}
+
+{
+   False-positive Race in _Z22pow2AlignedAllocHelperP17umf_memory_pool_t
+   Helgrind:Race
+   fun:memset
+   fun:_Z22pow2AlignedAllocHelperP17umf_memory_pool_t
+   ...
+}
diff --git a/test/supp/helgrind-test_scalable_coarse_file.supp b/test/supp/helgrind-test_scalable_coarse_file.supp
new file mode 100644
index 000000000..650edf514
--- /dev/null
+++ b/test/supp/helgrind-test_scalable_coarse_file.supp
@@ -0,0 +1,49 @@
+{
+   False-positive Race in libtbbmalloc.so
+   Helgrind:Race
+   obj:*/libtbbmalloc.so*
+}
+
+{
+   False-positive Race in libtbbmalloc.so
+   Helgrind:Race
+   obj:*/libtbbmalloc.so*
+   ...
+   fun:tbb_malloc
+   ...
+}
+
+{
+   False-positive Race in libtbbmalloc.so
+   Helgrind:Race
+   obj:*/libtbbmalloc.so*
+   ...
+   fun:tbb_aligned_malloc
+   ...
+}
+
+{
+   False-positive Race in libtbbmalloc.so
+   Helgrind:Race
+   obj:*/libtbbmalloc.so*
+   ...
+   fun:tbb_free
+   ...
+}
+
+{
+   False-positive Race in libtbbmalloc.so
+   Helgrind:Race
+   obj:*/libtbbmalloc.so*
+   ...
+   fun:__nptl_deallocate_tsd
+   ...
+}
+
+{
+   False-positive Race in _Z22pow2AlignedAllocHelperP17umf_memory_pool_t
+   Helgrind:Race
+   fun:memset
+   fun:_Z22pow2AlignedAllocHelperP17umf_memory_pool_t
+   ...
+}
diff --git a/test/supp/helgrind-umf_test-scalable_pool.supp b/test/supp/helgrind-test_scalable_pool.supp
similarity index 100%
rename from test/supp/helgrind-umf_test-scalable_pool.supp
rename to test/supp/helgrind-test_scalable_pool.supp
diff --git a/test/supp/helgrind-umf_test-jemalloc_pool.supp b/test/supp/helgrind-umf_test-jemalloc_pool.supp
deleted file mode 100644
index 8068b023d..000000000
--- a/test/supp/helgrind-umf_test-jemalloc_pool.supp
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-   Race in libjemalloc.so  - internal issue of libjemalloc
-   Helgrind:Race
-   obj:*libjemalloc.so*
-   ...
-}
diff --git a/test/supp/memcheck-test_jemalloc_coarse_devdax.supp b/test/supp/memcheck-test_jemalloc_coarse_devdax.supp
new file mode 100644
index 000000000..f71903277
--- /dev/null
+++ b/test/supp/memcheck-test_jemalloc_coarse_devdax.supp
@@ -0,0 +1,7 @@
+{
+   False-positive invalid write of size 8
+   Memcheck:Addr8
+   ...
+   fun:je_*
+   ...
+}
diff --git a/test/supp/memcheck-test_jemalloc_coarse_file.supp b/test/supp/memcheck-test_jemalloc_coarse_file.supp
new file mode 100644
index 000000000..f71903277
--- /dev/null
+++ b/test/supp/memcheck-test_jemalloc_coarse_file.supp
@@ -0,0 +1,7 @@
+{
+   False-positive invalid write of size 8
+   Memcheck:Addr8
+   ...
+   fun:je_*
+   ...
+}
diff --git a/test/supp/memcheck-umf_test-jemalloc_pool.supp b/test/supp/memcheck-test_jemalloc_pool.supp
similarity index 100%
rename from test/supp/memcheck-umf_test-jemalloc_pool.supp
rename to test/supp/memcheck-test_jemalloc_pool.supp
diff --git a/test/supp/memcheck-test_scalable_pool.supp b/test/supp/memcheck-test_scalable_pool.supp
new file mode 100644
index 000000000..114dfb236
--- /dev/null
+++ b/test/supp/memcheck-test_scalable_pool.supp
@@ -0,0 +1,18 @@
+{
+   Conditional jump or move depends on uninitialised value(s) - internal issue of libtbbmalloc.so
+   Memcheck:Cond
+   fun:_ZN3rml9pool_freeEPNS_10MemoryPoolEPv
+   fun:tbb_free
+   fun:umfPoolFree
+   ...
+}
+
+{
+   Conditional jump or move depends on uninitialised value(s) - internal issue of libtbbmalloc.so
+   Memcheck:Cond
+   obj:*libtbbmalloc.so*
+   fun:_ZN3rml9pool_freeEPNS_10MemoryPoolEPv
+   fun:tbb_free
+   fun:umfPoolFree
+   ...
+}
diff --git a/test/test_base_alloc.cpp b/test/test_base_alloc.cpp
index 497a22a69..80bc67541 100644
--- a/test/test_base_alloc.cpp
+++ b/test/test_base_alloc.cpp
@@ -37,7 +37,7 @@ TEST_F(test, baseAllocMultiThreadedAllocMemset) {
 
         for (int i = 0; i < ITERATIONS; i++) {
             for (int k = 0; k < ALLOCATION_SIZE; k++) {
-                UT_ASSERTeq(*(ptrs[i].get() + k), ((i + TID) & 0xFF));
+                ASSERT_EQ(*(ptrs[i].get() + k), ((i + TID) & 0xFF));
             }
         }
     };
diff --git a/test/test_base_alloc_linear.cpp b/test/test_base_alloc_linear.cpp
index a361244fc..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
@@ -24,7 +24,7 @@ TEST_F(test, baseAllocLinearAllocMoreThanPoolSize) {
 
     size_t new_size = 20 * 1024 * 1024; // = 20 MB
     void *ptr = umf_ba_linear_alloc(pool.get(), new_size);
-    UT_ASSERTne(ptr, NULL);
+    ASSERT_NE(ptr, nullptr);
     memset(ptr, 0, new_size);
 
     umf_ba_linear_free(pool.get(), ptr);
@@ -37,15 +37,14 @@ TEST_F(test, baseAllocLinearPoolContainsPointer) {
 
     size_t size = 16;
     void *ptr = umf_ba_linear_alloc(pool.get(), size);
-    UT_ASSERTne(ptr, NULL);
+    ASSERT_NE(ptr, nullptr);
     memset(ptr, 0, size);
-
     // assert pool contains pointer ptr
-    UT_ASSERTne(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
-    UT_ASSERTeq(umf_ba_linear_pool_contains_pointer(pool.get(), (void *)0x0123),
-                0);
+    ASSERT_EQ(umf_ba_linear_pool_contains_pointer(pool.get(), (void *)0x0123),
+              (size_t)0);
 
     umf_ba_linear_free(pool.get(), ptr);
 }
@@ -61,7 +60,7 @@ TEST_F(test, baseAllocLinearMultiThreadedAllocMemset) {
     // but not big enough to hold all allocations,
     // so that there were more pools allocated.
     // This is needed to test freeing the first pool.
-    size_t pool_size = 2 * util_get_page_size();
+    size_t pool_size = 2 * utils_get_page_size();
 
     auto pool = std::shared_ptr<umf_ba_linear_pool_t>(
         umf_ba_linear_create(pool_size), umf_ba_linear_destroy);
@@ -78,14 +77,14 @@ TEST_F(test, baseAllocLinearMultiThreadedAllocMemset) {
                                            (rand() / (double)RAND_MAX));
             buffer[i].size = size;
             buffer[i].ptr = (unsigned char *)umf_ba_linear_alloc(pool, size);
-            UT_ASSERTne(buffer[i].ptr, NULL);
+            ASSERT_NE(buffer[i].ptr, nullptr);
             memset(buffer[i].ptr, (i + TID) & 0xFF, buffer[i].size);
         }
 
         for (int i = 0; i < ITERATIONS; i++) {
-            UT_ASSERTne(buffer[i].ptr, NULL);
+            ASSERT_NE(buffer[i].ptr, nullptr);
             for (size_t k = 0; k < buffer[i].size; k++) {
-                UT_ASSERTeq(*(buffer[i].ptr + k), (i + TID) & 0xFF);
+                ASSERT_EQ(*(buffer[i].ptr + k), (i + TID) & 0xFF);
             }
         }
 
diff --git a/test/test_examples.sh b/test/test_examples.sh
index 9331b1d06..efc86bcf9 100755
--- a/test/test_examples.sh
+++ b/test/test_examples.sh
@@ -5,40 +5,44 @@
 
 set -e
 
-WORKSPACE=$1
+SOURCE_DIR=$1
 BUILD_DIR=$2
 INSTALL_DIR=$3
+CMAKE_INSTALL_PREFIX=$4
+STANDALONE_CMAKE_OPTIONS=$5
 
 echo "Running: $0 $*"
 
 function print_usage() {
 	echo "$(basename $0) - test all examples standalone"
-	echo "Usage: $(basename $0) <workspace_dir> <build_dir> <install_dir> <list-of-examples-to-run>"
+	echo "Usage: $(basename $0) <source_dir> <build_dir> <install_dir> <CMAKE_INSTALL_PREFIX> <standalone_cmake_options> <list-of-examples-to-run>"
 }
 
-if [ "$3" == "" ]; then
+if [ "$6" = "" ]; then
 	print_usage
 	echo -e "Error: too few arguments\n"
 	exit 1
 fi
 
-if [ "$4" == "" ]; then
-	print_usage
-	echo "No examples to run!"
-	exit 0
-fi
-
-if [ ! -f $WORKSPACE/README.md ]; then
-	echo -e "error: incorrect <workspace_dir>: $WORKSPACE\n"
+if [ ! -f $SOURCE_DIR/README.md ]; then
+	echo -e "error: incorrect <source_dir>: $SOURCE_DIR\n"
 	print_usage
 	exit 1
 fi
 
-WORKSPACE=$(realpath $WORKSPACE)
+mkdir -p ${INSTALL_DIR}/${CMAKE_INSTALL_PREFIX}
+
+SOURCE_DIR=$(realpath $SOURCE_DIR)
 BUILD_DIR=$(realpath $BUILD_DIR)
 INSTALL_DIR=$(realpath $INSTALL_DIR)
 
-shift 3
+echo "SOURCE_DIR=$SOURCE_DIR"
+echo "BUILD_DIR=$BUILD_DIR"
+echo "CMAKE_INSTALL_PREFIX=$CMAKE_INSTALL_PREFIX"
+echo "INSTALL_DIR=$INSTALL_DIR"
+echo "STANDALONE_CMAKE_OPTIONS=$STANDALONE_CMAKE_OPTIONS"
+
+shift 5
 EXAMPLES="$*"
 echo "Examples to run: $EXAMPLES"
 echo
@@ -46,12 +50,13 @@ echo
 cd ${BUILD_DIR}
 echo "DIR=$(pwd)"
 
+echo "Installing UMF into the directory: ${INSTALL_DIR}/${CMAKE_INSTALL_PREFIX}"
 set -x
-make -j$(nproc) install
+make DESTDIR=$INSTALL_DIR -j$(nproc) install
 set +x
 
 for ex in $EXAMPLES; do
-	SRC_DIR="${WORKSPACE}/examples/$ex"
+	SRC_DIR="${SOURCE_DIR}/examples/$ex"
 	BLD_DIR="${BUILD_DIR}/examples-standalone/$ex"
 
 	if [ ! -d $SRC_DIR ]; then
@@ -67,7 +72,7 @@ for ex in $EXAMPLES; do
 	rm -rf $BLD_DIR
 	mkdir -p $BLD_DIR
 	cd $BLD_DIR
-	CMAKE_PREFIX_PATH="$INSTALL_DIR" cmake $SRC_DIR
+	CMAKE_PREFIX_PATH="${INSTALL_DIR}/${CMAKE_INSTALL_PREFIX}" cmake $SRC_DIR $STANDALONE_CMAKE_OPTIONS
 	make -j$(nproc)
 	ctest --output-on-failure
 	set +x
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 49a382969..cba8a4fb3 100644
--- a/test/test_installation.py
+++ b/test/test_installation.py
@@ -1,4 +1,4 @@
-#  Copyright (C) 2024 Intel Corporation
+#  Copyright (C) 2024-2025 Intel Corporation
 #
 #  Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -28,7 +28,8 @@ class UmfInstaller:
     proxy (bool): Determines whether the proxy library should be built together with the UMF library
     pools (List[str]): A list of enabled pools during the UMF compilation
     umf_version (Version): UMF version currently being built and installed
-    match_list (List[str]): A list of relative paths of files that should be installed
+    umfd_lib (bool): Determines if the UMF was built with the umfd library
+    hwloc (bool): Determines if hwloc is installed and should be checked
     """
 
     def __init__(
@@ -41,6 +42,8 @@ def __init__(
         proxy: bool,
         pools: List[str],
         umf_version: Version,
+        umfd_lib: bool,
+        hwloc: bool,
     ):
         self.workspace_dir = workspace_dir
         self.build_dir = build_dir
@@ -50,6 +53,8 @@ def __init__(
         self.proxy = proxy
         self.pools = pools
         self.umf_version = umf_version
+        self.umfd_lib = umfd_lib
+        self.hwloc = hwloc
         self.match_list = self._create_match_list()
 
     def _create_match_list(self) -> List[str]:
@@ -78,6 +83,8 @@ def _create_match_list(self) -> List[str]:
             bin.append("bin")
             if self.shared_library:
                 bin.append("bin/umf.dll")
+                if self.umfd_lib:
+                    bin.append("bin/umfd.dll")
             if self.proxy:
                 bin.append("bin/umf_proxy.dll")
 
@@ -97,10 +104,15 @@ def _create_match_list(self) -> List[str]:
             f"lib/cmake/umf/umf-targets-{self.build_type}.cmake",
             "lib/cmake/umf/umf-targets.cmake",
         ]
+
         for pool in self.pools:
             lib.append(f"lib/{lib_prefix}{pool}.{lib_ext_static}")
+        if platform.system() == "Windows" and self.hwloc:
+            lib.append(f"lib/{lib_prefix}hwloc.{lib_ext_static}")
         if self.shared_library:
             lib.append(f"lib/{lib_prefix}umf.{lib_ext_shared}")
+            if platform.system() == "Windows" and self.umfd_lib:
+                lib.append(f"lib/{lib_prefix}umfd.{lib_ext_shared}")
 
             if platform.system() == "Linux":
                 lib.append(
@@ -113,7 +125,12 @@ def _create_match_list(self) -> List[str]:
                 )
                 lib.append(f"lib/{lib_prefix}umf.{self.umf_version}.{lib_ext_shared}")
         else:
+            lib.append(f"lib/{lib_prefix}umf_ba.{lib_ext_static}")
+            lib.append(f"lib/{lib_prefix}umf_coarse.{lib_ext_static}")
+            lib.append(f"lib/{lib_prefix}umf_utils.{lib_ext_static}")
             lib.append(f"lib/{lib_prefix}umf.{lib_ext_static}")
+            if self.umfd_lib and platform.system() == "Windows":
+                lib.append(f"lib/{lib_prefix}umfd.{lib_ext_static}")
 
         if self.proxy:
             lib.append(f"lib/{lib_prefix}umf_proxy.{lib_ext_shared}")
@@ -127,7 +144,6 @@ def _create_match_list(self) -> List[str]:
                     f"lib/{lib_prefix}umf_proxy.{self.umf_version.major}.{lib_ext_shared}"
                 )
 
-        share = []
         share = [
             "share",
             "share/doc",
@@ -168,8 +184,27 @@ def install_umf(self) -> None:
                     f"Error: Installation directory '{self.install_dir}' is not empty"
                 )
 
-        install_cmd = f"cmake --install {self.build_dir} --config {self.build_type.title()} --prefix {self.install_dir}"
+        # cmake <= 3.14 does not support --prefix option
         try:
+            cmake_ver_cmd = "cmake --version"
+            cmake_ver = subprocess.run(
+                cmake_ver_cmd.split(), capture_output=True, text=True
+            )  # nosec B603
+            cmake_ver = cmake_ver.stdout.splitlines()[0].split(" ")[2]
+            cmake_ver = Version(cmake_ver)
+            print(f"CMake version: {cmake_ver}", flush=True)
+        except subprocess.CalledProcessError:
+            sys.exit(f"Error: CMake check version command '{cmake_ver_cmd}' failed")
+
+        if cmake_ver <= Version("3.14"):  # both Linux and Windows
+            install_cmd = f"cmake --build {self.build_dir} --config {self.build_type.title()} --target install"
+        elif platform.system() == "Windows":
+            install_cmd = f"cmake --install {self.build_dir} --config {self.build_type.title()} --prefix {self.install_dir}"
+        else:
+            install_cmd = f"cmake --build {self.build_dir} --config {self.build_type.title()} --target install"
+
+        try:
+            print(f"Running command: {install_cmd}", flush=True)
             subprocess.run(install_cmd.split()).check_returncode()  # nosec B603
         except subprocess.CalledProcessError:
             sys.exit(f"Error: UMF installation command '{install_cmd}' failed")
@@ -279,19 +314,19 @@ def parse_arguments(self) -> argparse.Namespace:
             help="Add this argument if the proxy library should be built together with the UMF library",
         )
         self.parser.add_argument(
-            "--disjoint-pool",
-            action="store_true",
-            help="Add this argument if the UMF was built with Disjoint Pool enabled",
+            "--umf-version",
+            action="store",
+            help="Current version of the UMF, e.g. 1.0.0",
         )
         self.parser.add_argument(
-            "--jemalloc-pool",
+            "--umfd-lib",
             action="store_true",
-            help="Add this argument if the UMF was built with Jemalloc Pool enabled",
+            help="Add this argument if the UMF was built with the umfd library",
         )
         self.parser.add_argument(
-            "--umf-version",
-            action="store",
-            help="Current version of the UMF, e.g. 1.0.0",
+            "--hwloc",
+            action="store_true",
+            help="Add this argument if hwloc is installed and should be checked",
         )
         return self.parser.parse_args()
 
@@ -304,10 +339,6 @@ def run(self) -> None:
         build_dir = Path(workspace_dir, self.args.build_dir)
         install_dir = Path(workspace_dir, self.args.install_dir)
         pools = []
-        if self.args.disjoint_pool:
-            pools.append("disjoint_pool")
-        if self.args.jemalloc_pool:
-            pools.append("jemalloc_pool")
 
         umf_version = Version(self.args.umf_version)
 
@@ -320,6 +351,8 @@ def run(self) -> None:
             self.args.proxy,
             pools,
             umf_version,
+            self.args.umfd_lib,
+            self.args.hwloc,
         )
 
         print("Installation test - BEGIN", flush=True)
diff --git a/test/test_proxy_lib.cpp b/test/test_proxy_lib.cpp
index 4cdb6568b..85afc65be 100644
--- a/test/test_proxy_lib.cpp
+++ b/test/test_proxy_lib.cpp
@@ -15,15 +15,47 @@
 
 #include "base.hpp"
 #include "test_helpers.h"
+#include "utils_common.h"
 
 using umf_test::test;
 
-TEST_F(test, proxyLibBasic) {
+#define SIZE_64 64
+#define ALIGN_1024 1024
 
-    ::free(::malloc(64));
+TEST_F(test, proxyLib_basic) {
+
+    ::free(::malloc(SIZE_64));
 
     // a check to verify we are running the proxy library
     void *ptr = (void *)0x01;
+
+#ifdef _WIN32
+    size_t size = _msize(ptr);
+#elif __APPLE__
+    size_t size = ::malloc_size(ptr);
+#else
+    size_t size = ::malloc_usable_size(ptr);
+#endif
+
+    ASSERT_EQ(size, 0xDEADBEEF);
+}
+
+TEST_F(test, proxyLib_realloc_size0) {
+    // realloc(ptr, 0) == free (ptr)
+    // realloc(ptr, 0) returns NULL
+    ASSERT_EQ(::realloc(::malloc(SIZE_64), 0), nullptr);
+}
+
+TEST_F(test, proxyLib_malloc_usable_size) {
+
+    void *ptr = ::malloc(SIZE_64);
+    ASSERT_NE(ptr, nullptr);
+    if (ptr == nullptr) {
+        // Fix for the following CodeQL's warning on Windows:
+        // 'ptr' could be '0': this does not adhere to the specification for the function '_msize'.
+        return;
+    }
+
 #ifdef _WIN32
     size_t size = _msize(ptr);
 #elif __APPLE__
@@ -31,5 +63,24 @@ TEST_F(test, proxyLibBasic) {
 #else
     size_t size = ::malloc_usable_size(ptr);
 #endif
-    UT_ASSERTeq(size, 0xDEADBEEF);
+
+    ASSERT_EQ((int)(size == 0 || size >= SIZE_64), 1);
+
+    ::free(ptr);
+}
+
+TEST_F(test, proxyLib_aligned_alloc) {
+#ifdef _WIN32
+    void *ptr = _aligned_malloc(SIZE_64, ALIGN_1024);
+#else
+    void *ptr = ::aligned_alloc(ALIGN_1024, SIZE_64);
+#endif
+
+    ASSERT_EQ((int)(IS_ALIGNED((uintptr_t)ptr, ALIGN_1024)), 1);
+
+#ifdef _WIN32
+    _aligned_free(ptr);
+#else
+    ::free(ptr);
+#endif
 }
diff --git a/test/test_proxy_lib_size_threshold.cpp b/test/test_proxy_lib_size_threshold.cpp
new file mode 100644
index 000000000..fac1c516b
--- /dev/null
+++ b/test/test_proxy_lib_size_threshold.cpp
@@ -0,0 +1,183 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#if defined(__APPLE__)
+#include <malloc/malloc.h>
+#else
+#include <malloc.h>
+#endif
+
+#include <umf/proxy_lib_new_delete.h>
+
+#include "base.hpp"
+#include "test_helpers.h"
+#include "utils_common.h"
+
+using umf_test::test;
+
+// size threshold defined by the env variable UMF_PROXY="size.threshold=64"
+#define SIZE_THRESHOLD 64
+#define SIZE_EQ (SIZE_THRESHOLD)
+#define SIZE_LT (SIZE_THRESHOLD - 1)
+
+#define ALIGN_1024 1024
+
+TEST_F(test, proxyLib_basic) {
+    // a check to verify we are running the proxy library
+    void *ptr = (void *)0x01;
+
+#ifdef _WIN32
+    size_t size = _msize(ptr);
+#elif __APPLE__
+    size_t size = ::malloc_size(ptr);
+#else
+    size_t size = ::malloc_usable_size(ptr);
+#endif
+
+    ASSERT_EQ(size, 0xDEADBEEF);
+}
+
+TEST_F(test, proxyLib_realloc_size0) {
+    // realloc(ptr, 0) == free(ptr)
+    // realloc(ptr, 0) returns NULL
+    ASSERT_EQ(::realloc(::malloc(SIZE_EQ), 0), nullptr);
+}
+
+// The proxyLib_size_threshold_* tests test the size threshold of the proxy library.
+// The size threshold is set to SIZE_THRESHOLD bytes in this test, so all allocations of:
+// 1) size <  SIZE_THRESHOLD go through the default system allocator
+//    (umfPoolByPtr(ptr_size < SIZE_THRESHOLD) == nullptr)
+// 2) size >= SIZE_THRESHOLD go through the proxy library allocator
+//    (umfPoolByPtr(ptr_size >= SIZE_THRESHOLD) != nullptr)
+
+TEST_F(test, proxyLib_size_threshold_aligned_alloc) {
+#ifdef _WIN32
+    void *ptr_LT = _aligned_malloc(SIZE_LT, ALIGN_1024);
+    void *ptr_EQ = _aligned_malloc(SIZE_EQ, ALIGN_1024);
+#else
+    void *ptr_LT = ::aligned_alloc(ALIGN_1024, SIZE_LT);
+    void *ptr_EQ = ::aligned_alloc(ALIGN_1024, SIZE_EQ);
+#endif
+
+    ASSERT_NE(ptr_LT, nullptr);
+    ASSERT_NE(ptr_EQ, nullptr);
+
+    // verify alignment
+    ASSERT_EQ((int)(IS_ALIGNED((uintptr_t)ptr_LT, ALIGN_1024)), 1);
+    ASSERT_EQ((int)(IS_ALIGNED((uintptr_t)ptr_EQ, ALIGN_1024)), 1);
+
+    ASSERT_EQ(umfPoolByPtr(ptr_LT), nullptr);
+    ASSERT_NE(umfPoolByPtr(ptr_EQ), nullptr);
+
+#ifdef _WIN32
+    _aligned_free(ptr_LT);
+    _aligned_free(ptr_EQ);
+#else
+    ::free(ptr_LT);
+    ::free(ptr_EQ);
+#endif
+}
+
+TEST_F(test, proxyLib_size_threshold_malloc) {
+    void *ptr_LT = malloc(SIZE_LT);
+    void *ptr_EQ = malloc(SIZE_EQ);
+
+    ASSERT_NE(ptr_LT, nullptr);
+    ASSERT_NE(ptr_EQ, nullptr);
+
+    ASSERT_EQ(umfPoolByPtr(ptr_LT), nullptr);
+    ASSERT_NE(umfPoolByPtr(ptr_EQ), nullptr);
+
+    ::free(ptr_LT);
+    ::free(ptr_EQ);
+}
+
+TEST_F(test, proxyLib_size_threshold_calloc) {
+    void *ptr_LT = calloc(SIZE_LT, 1);
+    void *ptr_EQ = calloc(SIZE_EQ, 1);
+
+    ASSERT_NE(ptr_LT, nullptr);
+    ASSERT_NE(ptr_EQ, nullptr);
+
+    ASSERT_EQ(umfPoolByPtr(ptr_LT), nullptr);
+    ASSERT_NE(umfPoolByPtr(ptr_EQ), nullptr);
+
+    ::free(ptr_LT);
+    ::free(ptr_EQ);
+}
+
+TEST_F(test, proxyLib_size_threshold_realloc_up) {
+    void *ptr_LT = malloc(SIZE_LT);
+    void *ptr_EQ = malloc(SIZE_EQ);
+
+    ASSERT_NE(ptr_LT, nullptr);
+    ASSERT_NE(ptr_EQ, nullptr);
+
+    void *ptr_LT_r = realloc(ptr_LT, 2 * SIZE_LT);
+    void *ptr_EQ_r = realloc(ptr_EQ, 2 * SIZE_EQ);
+
+    ASSERT_NE(ptr_LT_r, nullptr);
+    ASSERT_NE(ptr_EQ_r, nullptr);
+
+    ASSERT_EQ(umfPoolByPtr(ptr_LT_r), nullptr);
+    ASSERT_NE(umfPoolByPtr(ptr_EQ_r), nullptr);
+
+    ::free(ptr_LT_r);
+    ::free(ptr_EQ_r);
+}
+
+TEST_F(test, proxyLib_size_threshold_realloc_down) {
+    void *ptr_LT = malloc(SIZE_LT);
+    void *ptr_EQ = malloc(SIZE_EQ);
+
+    ASSERT_NE(ptr_LT, nullptr);
+    ASSERT_NE(ptr_EQ, nullptr);
+
+    void *ptr_LT_r = realloc(ptr_LT, SIZE_LT / 2);
+    void *ptr_EQ_r = realloc(ptr_EQ, SIZE_EQ / 2);
+
+    ASSERT_NE(ptr_LT_r, nullptr);
+    ASSERT_NE(ptr_EQ_r, nullptr);
+
+    ASSERT_EQ(umfPoolByPtr(ptr_LT_r), nullptr);
+    ASSERT_NE(umfPoolByPtr(ptr_EQ_r), nullptr);
+
+    ::free(ptr_LT_r);
+    ::free(ptr_EQ_r);
+}
+
+TEST_F(test, proxyLib_size_threshold_malloc_usable_size) {
+
+    void *ptr_LT = ::malloc(SIZE_LT);
+    void *ptr_EQ = ::malloc(SIZE_EQ);
+
+    ASSERT_NE(ptr_LT, nullptr);
+    ASSERT_NE(ptr_EQ, nullptr);
+
+    if (ptr_LT == nullptr || ptr_EQ == nullptr) {
+        // Fix for the following CodeQL's warning on Windows:
+        // 'ptr' could be '0': this does not adhere to the specification for the function '_msize'.
+        return;
+    }
+
+#ifdef _WIN32
+    size_t size_LT = _msize(ptr_LT);
+    size_t size_EQ = _msize(ptr_EQ);
+#elif __APPLE__
+    size_t size_LT = ::malloc_size(ptr_LT);
+    size_t size_EQ = ::malloc_size(ptr_EQ);
+#else
+    size_t size_LT = ::malloc_usable_size(ptr_LT);
+    size_t size_EQ = ::malloc_usable_size(ptr_EQ);
+#endif
+
+    ASSERT_EQ((int)(size_LT == 0 || size_LT >= SIZE_LT), 1);
+    ASSERT_EQ((int)(size_EQ == 0 || size_EQ >= SIZE_EQ), 1);
+
+    ::free(ptr_LT);
+    ::free(ptr_EQ);
+}
diff --git a/test/test_valgrind.sh b/test/test_valgrind.sh
index ed30e9ad6..cff45bdec 100755
--- a/test/test_valgrind.sh
+++ b/test/test_valgrind.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
-# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024-2025 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -8,11 +8,17 @@ set -e
 WORKSPACE=$1
 BUILD_DIR=$2
 TOOL=$3
+TESTS=$4
 
 function print_usage() {
-	echo "$(basename $0) - run all UMF tests under a valgrind tool (memcheck, drd or helgrind)"
-	echo "This script looks for './test/umf_test-*' test executables in the UMF build directory."
-	echo "Usage: $(basename $0) <workspace_dir> <build_dir> <memcheck|drd|helgrind>"
+	echo "$(basename $0) - run UMF tests and examples under a valgrind tool (memcheck, drd, drdshort or helgrind)"
+	echo "                 drdshort - same as drd, but the longest lasting tests are excluded"
+	echo "Usage: $(basename $0) <workspace_dir> <build_dir> <memcheck|drd|drdshort|helgrind> [tests_examples]"
+	echo "Where:"
+	echo
+	echo "tests_examples - (optional) list of tests or examples to be run (paths relative to the <build_dir> build directory)."
+	echo "                 If it is empty, all tests (./test/test_*) and examples (./examples/umf_example_*)"
+	echo "                 found in <build_dir> will be run."
 }
 
 if ! valgrind --version > /dev/null; then
@@ -20,7 +26,7 @@ if ! valgrind --version > /dev/null; then
 	exit 1
 fi
 
-if [ "$3" == "" ]; then
+if [ "$3" = "" ]; then
 	echo -e "error: too few arguments\n"
 	print_usage
 	exit 1
@@ -32,12 +38,14 @@ if [ ! -f $WORKSPACE/README.md ]; then
 	exit 1
 fi
 
-if [ $(ls -1 ${BUILD_DIR}/test/umf_test-* 2>/dev/null | wc -l) -eq 0 ]; then
-	echo -e "error: UMF tests ./test/umf_test-* not found in the build directory: ${BUILD_DIR}\n"
+if [ $(ls -1 ${BUILD_DIR}/test/test_* 2>/dev/null | wc -l) -eq 0 ]; then
+	echo -e "error: UMF tests ./test/test_* not found in the build directory: ${BUILD_DIR}\n"
 	print_usage
 	exit 1
 fi
 
+EXCLUDE_LONGEST_TESTS=0
+
 case $TOOL in
 memcheck)
 	OPTION="--leak-check=full"
@@ -45,6 +53,11 @@ memcheck)
 drd)
 	OPTION="--tool=drd"
 	;;
+drdshort)
+	OPTION="--tool=drd"
+	TOOL="drd"
+	EXCLUDE_LONGEST_TESTS=1
+	;;
 helgrind)
 	OPTION="--tool=helgrind"
 	;;
@@ -58,62 +71,116 @@ esac
 WORKSPACE=$(realpath $WORKSPACE)
 BUILD_DIR=$(realpath $BUILD_DIR)
 
-cd ${BUILD_DIR}/test/
+cd ${BUILD_DIR}
 mkdir -p cpuid
 
 echo "Gathering data for hwloc so it can be run under valgrind:"
-hwloc-gather-cpuid ./cpuid
+hwloc-gather-cpuid ./cpuid >/dev/null
 
 echo
 echo "Working directory: $(pwd)"
 echo "Running: \"valgrind $OPTION\" for the following tests:"
 
-FAIL=0
-rm -f umf_test-*.log umf_test-*.err
+ANY_TEST_FAILED=0
+PATH_TESTS="./test/test_*"
+PATH_EXAMPLES="./examples/umf_example_*"
 
-for test in $(ls -1 umf_test-*); do
+rm -f ${PATH_TESTS}.log ${PATH_TESTS}.err ${PATH_EXAMPLES}.log ${PATH_EXAMPLES}.err
+
+[ "$TESTS" = "" ] && TESTS=$(ls -1 ${PATH_TESTS} ${PATH_EXAMPLES})
+
+for test in $TESTS; do
+	if [ ! -f $test ]; then
+		echo
+		echo "error: the $test (${BUILD_DIR}/$test) file does not exist"
+		exit 1
+	fi
 	[ ! -x $test ] && continue
 	echo "$test - starting ..."
 	echo -n "$test "
 	LOG=${test}.log
 	ERR=${test}.err
-	SUP="${WORKSPACE}/test/supp/${TOOL}-${test}.supp"
+	NAME=$(basename $test)
+	SUP="${WORKSPACE}/test/supp/${TOOL}-${NAME}.supp"
 	OPT_SUP=""
-	[ -f ${SUP} ] && OPT_SUP="--suppressions=${SUP}" && echo -n "(${TOOL}-${test}.supp) "
+	[ -f ${SUP} ] && OPT_SUP="--suppressions=${SUP}" && echo -n "($(basename ${SUP})) "
 
 	# skip tests incompatible with valgrind
 	FILTER=""
 	case $test in
-	umf_test-ipc_os_prov_*)
+	./test/test_disjointPool)
+		if [ "$TOOL" = "helgrind" ]; then
+			# skip because of the assert in helgrind:
+			# Helgrind: hg_main.c:308 (lockN_acquire_reader): Assertion 'lk->kind == LK_rdwr' failed.
+			echo "- SKIPPED (helgrind only)"
+			continue;
+		fi
+		;;
+	./test/test_ipc_os_prov_*)
 		echo "- SKIPPED"
-		continue; # skip it - this is a 2 processes test run using the ipc_os_prov_anon_fd.sh script
+		continue; # skip testing helper binaries used by the ipc_os_prov_* tests
 		;;
-	umf_test-memspace_host_all)
+	./test/test_ipc_devdax_prov_*)
+		echo "- SKIPPED"
+		continue; # skip testing helper binaries used by the ipc_devdax_prov_* tests
+		;;
+	./test/test_ipc_file_prov_*)
+		echo "- SKIPPED"
+		continue; # skip testing helper binaries used by the ipc_file_prov_* tests
+		;;
+	./test/test_memspace_host_all)
 		FILTER='--gtest_filter="-*allocsSpreadAcrossAllNumaNodes"'
 		;;
-	umf_test-provider_os_memory_config)
+	./test/test_provider_os_memory)
+		FILTER='--gtest_filter="-osProviderTest/umfIpcTest*"'
+		;;
+	./test/test_provider_os_memory_config)
 		FILTER='--gtest_filter="-*protection_flag_none:*protection_flag_read:*providerConfigTestNumaMode*"'
 		;;
-	umf_test-memspace_highest_capacity)
+	./test/test_memspace_highest_capacity)
 		FILTER='--gtest_filter="-*highestCapacityVerify*"'
 		;;
-	umf_test-provider_os_memory_multiple_numa_nodes)
+	./test/test_provider_os_memory_multiple_numa_nodes)
 		FILTER='--gtest_filter="-testNuma.checkModeInterleave*:testNumaNodesAllocations/testNumaOnEachNode.checkNumaNodesAllocations*:testNumaNodesAllocations/testNumaOnEachNode.checkModePreferred*:testNumaNodesAllocations/testNumaOnEachNode.checkModeInterleaveSingleNode*:testNumaNodesAllocationsAllCpus/testNumaOnEachCpu.checkModePreferredEmptyNodeset*:testNumaNodesAllocationsAllCpus/testNumaOnEachCpu.checkModeLocal*"'
 		;;
-	umf_test-memspace_highest_bandwidth)
+	./test/test_memspace_highest_bandwidth)
 		FILTER='--gtest_filter="-*allocLocalMt*"'
 		;;
-	umf_test-memspace_lowest_latency)
+	./test/test_memspace_lowest_latency)
 		FILTER='--gtest_filter="-*allocLocalMt*"'
 		;;
+	./test/test_memoryPool)
+		FILTER='--gtest_filter="-*allocMaxSize*"'
+		;;
+	./examples/umf_example_ipc_ipcapi_*)
+		echo "- SKIPPED"
+		continue; # skip testing helper binaries used by the umf_example_ipc_ipcapi_* examples
+		;;
 	esac
 
+	if [ $EXCLUDE_LONGEST_TESTS -eq 1 ]; then
+		# skip the longest tests
+		case $test in
+		./test/test_jemalloc_pool|./test/test_jemalloc_coarse_file|./test/test_scalable_pool|./test/test_ipc_max_opened_limit)
+			echo "- SKIPPED (VERY LONG TEST)"
+			continue;
+			;;
+		esac
+	fi
+
 	[ "$FILTER" != "" ] && echo -n "($FILTER) "
 
-	if ! HWLOC_CPUID_PATH=./cpuid valgrind $OPTION $OPT_SUP --gen-suppressions=all ./$test $FILTER >$LOG 2>&1; then
-		FAIL=1
-		echo "(valgrind FAILED) "
-		echo "Command: HWLOC_CPUID_PATH=./cpuid valgrind $OPTION $OPT_SUP --gen-suppressions=all ./$test $FILTER >$LOG 2>&1"
+	LAST_TEST_FAILED=0
+	set +e
+	HWLOC_CPUID_PATH=./cpuid valgrind $OPTION $OPT_SUP --gen-suppressions=all $test $FILTER >$LOG 2>&1
+	RET=$?
+	set -e
+	# 125 is the return code when the test is skipped
+	if [ $RET -ne 0 -a $RET -ne 125 ]; then
+		LAST_TEST_FAILED=1
+		ANY_TEST_FAILED=1
+		echo "(valgrind FAILED RV=$RET) "
+		echo "Command: HWLOC_CPUID_PATH=./cpuid valgrind $OPTION $OPT_SUP --gen-suppressions=all $test $FILTER >$LOG 2>&1"
 		echo "Output:"
 		cat $LOG
 		echo "====================="
@@ -121,27 +188,51 @@ for test in $(ls -1 umf_test-*); do
 	fi || true
 	# grep for "ERROR SUMMARY" with errors (there can be many lines with "ERROR SUMMARY")
 	grep -e "ERROR SUMMARY:" $LOG | grep -v -e "ERROR SUMMARY: 0 errors from 0 contexts" > $ERR || true
-	if [ $(cat $ERR | wc -l) -eq 0 ]; then
-		echo "- OK"
+	if [ $LAST_TEST_FAILED -eq 0 -a $(cat $ERR | wc -l) -eq 0 ]; then
+		[ $RET -eq 0 ] && echo "- OK" || echo "- SKIPPED"
 		rm -f $LOG $ERR
 	else
 		echo "- FAILED!"
 		cat $ERR | cut -d' ' -f2-
-		FAIL=1
+		ANY_TEST_FAILED=1
 	fi || true
 done
 
-[ $FAIL -eq 0 ] && echo PASSED && exit 0
+rm -rf ${BUILD_DIR}/test/cpuid
+
+[ $ANY_TEST_FAILED -eq 0 ] && echo PASSED && exit 0
 
 echo
 echo "======================================================================"
 echo
 
-for log in $(ls -1 umf_test-*.log); do
+LOG_FILES=""
+NT=$(ls -1 ${PATH_TESTS}.log 2>/dev/null | wc -l)
+if [ $NT -gt 0 ]; then
+	LOG_FILES="$LOG_FILES $(ls -1 ${PATH_TESTS}.log | xargs)"
+fi
+NE=$(ls -1 ${PATH_EXAMPLES}.log 2>/dev/null | wc -l)
+if [ $NE -gt 0 ]; then
+	LOG_FILES="$LOG_FILES $(ls -1 ${PATH_EXAMPLES}.log | xargs)"
+fi
+if [ $(($NT + $NE)) -eq 0 ]; then
+	echo
+	echo "FATAL ERROR: no log files found, but number of failed tests equals $ANY_TEST_FAILED!"
+	echo
+	exit 1
+fi
+
+for log in $LOG_FILES; do
 	echo ">>>>>>> LOG $log"
 	cat $log
 	echo
 	echo
 done
 
+if [ $(($NT + $NE)) -ne $ANY_TEST_FAILED ]; then
+	echo
+	echo "ERROR: incorrect number of log files: ANY_TEST_FAILED=$ANY_TEST_FAILED != ($NT + $NE)"
+	echo
+fi
+
 exit 1
diff --git a/src/cpp_helpers.hpp b/test/utils/cpp_helpers.hpp
similarity index 76%
rename from src/cpp_helpers.hpp
rename to test/utils/cpp_helpers.hpp
index 86204a20e..ae18d7b1b 100644
--- a/src/cpp_helpers.hpp
+++ b/test/utils/cpp_helpers.hpp
@@ -1,14 +1,14 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  */
 
-#ifndef UMF_HELPERS_HPP
-#define UMF_HELPERS_HPP 1
+#ifndef UMF_TEST_HELPERS_HPP
+#define UMF_TEST_HELPERS_HPP 1
 
 #include <umf/memory_pool.h>
 #include <umf/memory_pool_ops.h>
@@ -22,7 +22,7 @@
 #include <tuple>
 #include <utility>
 
-namespace umf {
+namespace umf_test {
 
 using pool_unique_handle_t =
     std::unique_ptr<umf_memory_pool_t,
@@ -67,8 +67,11 @@ umf_result_t initialize(T *obj, ArgsTuple &&args) {
 
 template <typename T> umf_memory_pool_ops_t poolOpsBase() {
     umf_memory_pool_ops_t ops{};
-    ops.version = UMF_VERSION_CURRENT;
-    ops.finalize = [](void *obj) { delete reinterpret_cast<T *>(obj); };
+    ops.version = UMF_POOL_OPS_VERSION_CURRENT;
+    ops.finalize = [](void *obj) {
+        delete reinterpret_cast<T *>(obj);
+        return UMF_RESULT_SUCCESS;
+    };
     UMF_ASSIGN_OP(ops, T, malloc, ((void *)nullptr));
     UMF_ASSIGN_OP(ops, T, calloc, ((void *)nullptr));
     UMF_ASSIGN_OP(ops, T, aligned_malloc, ((void *)nullptr));
@@ -79,25 +82,28 @@ template <typename T> umf_memory_pool_ops_t poolOpsBase() {
     return ops;
 }
 
-template <typename T> umf_memory_provider_ops_t providerOpsBase() {
+template <typename T> constexpr umf_memory_provider_ops_t providerOpsBase() {
     umf_memory_provider_ops_t ops{};
-    ops.version = UMF_VERSION_CURRENT;
-    ops.finalize = [](void *obj) { delete reinterpret_cast<T *>(obj); };
+    ops.version = UMF_PROVIDER_OPS_VERSION_CURRENT;
+    ops.finalize = [](void *obj) {
+        delete reinterpret_cast<T *>(obj);
+        return UMF_RESULT_SUCCESS;
+    };
     UMF_ASSIGN_OP(ops, T, alloc, UMF_RESULT_ERROR_UNKNOWN);
     UMF_ASSIGN_OP(ops, 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)));
         }
     };
 
@@ -134,10 +140,10 @@ template <typename T, typename ParamType> umf_memory_pool_ops_t poolMakeCOps() {
 // C API. 'params' from ops.initialize will be casted to 'ParamType*'
 // and passed to T::initialize() function.
 template <typename T, typename ParamType>
-umf_memory_provider_ops_t providerMakeCOps() {
+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 @@ umf_memory_provider_ops_t providerMakeCOps() {
         } else {
             return detail::initialize<T>(
                 reinterpret_cast<T *>(*obj),
-                std::make_tuple(reinterpret_cast<ParamType *>(params)));
+                std::make_tuple(reinterpret_cast<const ParamType *>(params)));
         }
     };
 
@@ -162,6 +168,6 @@ template <typename Type> umf_result_t &getPoolLastStatusRef() {
     return last_status;
 }
 
-} // namespace umf
+} // namespace umf_test
 
-#endif /* UMF_HELPERS_HPP */
+#endif /* UMF_TEST_HELPERS_HPP */
diff --git a/test/utils/utils.cpp b/test/utils/utils.cpp
index de4a71d65..302971f7e 100644
--- a/test/utils/utils.cpp
+++ b/test/utils/utils.cpp
@@ -8,52 +8,52 @@
 
 using umf_test::test;
 
-TEST_F(test, util_parse_var) {
-    EXPECT_FALSE(util_parse_var("", "test1", 0));
+TEST_F(test, utils_parse_var) {
+    EXPECT_FALSE(utils_parse_var("", "test1", 0));
 
-    EXPECT_TRUE(util_parse_var("test1;test2;test3;test4", "test1", 0));
-    EXPECT_TRUE(util_parse_var("test1;test2;test3;test4", "test2", 0));
-    EXPECT_TRUE(util_parse_var("test1;test2;test3;test4", "test3", 0));
-    EXPECT_TRUE(util_parse_var("test1;test2;test3;test4", "test4", 0));
+    EXPECT_TRUE(utils_parse_var("test1;test2;test3;test4", "test1", 0));
+    EXPECT_TRUE(utils_parse_var("test1;test2;test3;test4", "test2", 0));
+    EXPECT_TRUE(utils_parse_var("test1;test2;test3;test4", "test3", 0));
+    EXPECT_TRUE(utils_parse_var("test1;test2;test3;test4", "test4", 0));
 
-    EXPECT_TRUE(util_parse_var(";test1;test2;test3;test4;", "test1", 0));
-    EXPECT_TRUE(util_parse_var(";test1;test2;test3;test4;", "test2", 0));
-    EXPECT_TRUE(util_parse_var(";test1;test2;test3;test4;", "test3", 0));
-    EXPECT_TRUE(util_parse_var(";test1;test2;test3;test4;", "test4", 0));
+    EXPECT_TRUE(utils_parse_var(";test1;test2;test3;test4;", "test1", 0));
+    EXPECT_TRUE(utils_parse_var(";test1;test2;test3;test4;", "test2", 0));
+    EXPECT_TRUE(utils_parse_var(";test1;test2;test3;test4;", "test3", 0));
+    EXPECT_TRUE(utils_parse_var(";test1;test2;test3;test4;", "test4", 0));
 
-    EXPECT_FALSE(util_parse_var("test1;test2;test3;test4", "test5", 0));
+    EXPECT_FALSE(utils_parse_var("test1;test2;test3;test4", "test5", 0));
 
-    EXPECT_FALSE(util_parse_var("test1test2test3test4", "test1", 0));
-    EXPECT_FALSE(util_parse_var("test1test2test3test4", "test2", 0));
-    EXPECT_FALSE(util_parse_var("test1test2test3test4", "test3", 0));
-    EXPECT_FALSE(util_parse_var("test1test2test3test4", "test4", 0));
+    EXPECT_FALSE(utils_parse_var("test1test2test3test4", "test1", 0));
+    EXPECT_FALSE(utils_parse_var("test1test2test3test4", "test2", 0));
+    EXPECT_FALSE(utils_parse_var("test1test2test3test4", "test3", 0));
+    EXPECT_FALSE(utils_parse_var("test1test2test3test4", "test4", 0));
 
-    EXPECT_FALSE(util_parse_var("test1:test2;test3:test4", "test1", 0));
-    EXPECT_FALSE(util_parse_var("test1:test2;test3:test4", "test2", 0));
-    EXPECT_FALSE(util_parse_var("test1:test2;test3:test4", "test3", 0));
-    EXPECT_FALSE(util_parse_var("test1:test2;test3:test4", "test4", 0));
+    EXPECT_FALSE(utils_parse_var("test1:test2;test3:test4", "test1", 0));
+    EXPECT_FALSE(utils_parse_var("test1:test2;test3:test4", "test2", 0));
+    EXPECT_FALSE(utils_parse_var("test1:test2;test3:test4", "test3", 0));
+    EXPECT_FALSE(utils_parse_var("test1:test2;test3:test4", "test4", 0));
 
-    EXPECT_TRUE(util_parse_var("test1:test2;test3:test4", "test1:test2", 0));
-    EXPECT_TRUE(util_parse_var("test1:test2;test3:test4", "test3:test4", 0));
-    EXPECT_FALSE(util_parse_var("test1:test2;test3:test4", "test2:test3'", 0));
+    EXPECT_TRUE(utils_parse_var("test1:test2;test3:test4", "test1:test2", 0));
+    EXPECT_TRUE(utils_parse_var("test1:test2;test3:test4", "test3:test4", 0));
+    EXPECT_FALSE(utils_parse_var("test1:test2;test3:test4", "test2:test3'", 0));
 
     EXPECT_TRUE(
-        util_parse_var("test1;;test2;invalid;test3;;;test4", "test1", 0));
+        utils_parse_var("test1;;test2;invalid;test3;;;test4", "test1", 0));
     EXPECT_TRUE(
-        util_parse_var("test1;;test2;invalid;test3;;;test4", "test2", 0));
+        utils_parse_var("test1;;test2;invalid;test3;;;test4", "test2", 0));
     EXPECT_TRUE(
-        util_parse_var("test1;;test2;invalid;test3;;;test4", "test3", 0));
+        utils_parse_var("test1;;test2;invalid;test3;;;test4", "test3", 0));
     EXPECT_TRUE(
-        util_parse_var("test1;;test2;invalid;test3;;;test4", "test4", 0));
+        utils_parse_var("test1;;test2;invalid;test3;;;test4", "test4", 0));
 
     const char *arg;
-    EXPECT_FALSE(util_parse_var("test1;test2;test3;test4", "test1", &arg));
-    EXPECT_FALSE(util_parse_var("test1;test2;test3;test4", "test2", &arg));
-    EXPECT_FALSE(util_parse_var("test1;test2;test3;test4", "test3", &arg));
-    EXPECT_FALSE(util_parse_var("test1;test2;test3;test4", "test4", &arg));
-
-    EXPECT_TRUE(util_parse_var("test1,abc;test2;test3;test4", "test1", &arg));
-    EXPECT_TRUE(util_parse_var("test1;test2,abc;test3;test4", "test2", &arg));
-    EXPECT_TRUE(util_parse_var("test1;test2;test3,abc;test4", "test3", &arg));
-    EXPECT_TRUE(util_parse_var("test1;test2;test3;test4,abc", "test4", &arg));
+    EXPECT_FALSE(utils_parse_var("test1;test2;test3;test4", "test1", &arg));
+    EXPECT_FALSE(utils_parse_var("test1;test2;test3;test4", "test2", &arg));
+    EXPECT_FALSE(utils_parse_var("test1;test2;test3;test4", "test3", &arg));
+    EXPECT_FALSE(utils_parse_var("test1;test2;test3;test4", "test4", &arg));
+
+    EXPECT_TRUE(utils_parse_var("test1,abc;test2;test3;test4", "test1", &arg));
+    EXPECT_TRUE(utils_parse_var("test1;test2,abc;test3;test4", "test2", &arg));
+    EXPECT_TRUE(utils_parse_var("test1;test2;test3,abc;test4", "test3", &arg));
+    EXPECT_TRUE(utils_parse_var("test1;test2;test3;test4,abc", "test4", &arg));
 }
diff --git a/test/utils/utils_linux.cpp b/test/utils/utils_linux.cpp
new file mode 100644
index 000000000..1815a1a78
--- /dev/null
+++ b/test/utils/utils_linux.cpp
@@ -0,0 +1,188 @@
+// Copyright (C) 2024 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cstdint>
+#include <sys/mman.h>
+
+#include "base.hpp"
+#include "utils/utils_common.h"
+
+using umf_test::test;
+TEST_F(test, utils_translate_mem_visibility_flag) {
+    umf_memory_visibility_t in_flag = static_cast<umf_memory_visibility_t>(0);
+    unsigned out_flag;
+    auto ret = utils_translate_mem_visibility_flag(in_flag, &out_flag);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(test, utils_shm_open_invalid_args) {
+    auto ret = utils_shm_open(NULL);
+    EXPECT_EQ(ret, -1);
+
+    ret = utils_shm_open("invalid_path");
+    EXPECT_EQ(ret, -1);
+}
+
+TEST_F(test, utils_get_file_size_invalid_args) {
+    size_t size;
+    auto ret = utils_get_file_size(0xffffff, &size);
+    EXPECT_EQ(ret, -1);
+
+    int fd = utils_create_anonymous_fd();
+    ASSERT_GE(fd, 0);
+
+    // Explicit condition for coverity
+    if (fd >= 0) {
+        ret = utils_get_file_size(fd, &size);
+        EXPECT_EQ(ret, 0);
+        EXPECT_EQ(size, 0);
+    }
+}
+
+TEST_F(test, utils_set_file_size_invalid_args) {
+    auto ret = utils_set_file_size(0xffffff, 256);
+    EXPECT_EQ(ret, -1);
+}
+
+TEST_F(test, utils_shm_create_invalid_args) {
+    auto ret = utils_shm_create(NULL, 0);
+    EXPECT_EQ(ret, -1);
+
+    ret = utils_shm_create("", 256);
+    EXPECT_EQ(ret, -1);
+
+    // Ensure that a valid size results in a success
+    ret = utils_shm_create("/abc", 256);
+    EXPECT_GE(ret, 0);
+
+    ret = utils_shm_create("/abc", -1);
+    EXPECT_EQ(ret, -1);
+}
+
+TEST_F(test, utils_get_size_threshold) {
+    // Expected input to utils_get_size_threshold():
+    // char *str_threshold = utils_env_var_get_str("UMF_PROXY", "size.threshold=");
+
+    // positive tests
+    EXPECT_EQ(utils_get_size_threshold((char *)"size.threshold=111"), 111);
+    EXPECT_EQ(utils_get_size_threshold((char *)"size.threshold=222;abcd"), 222);
+    EXPECT_EQ(utils_get_size_threshold((char *)"size.threshold=333;var=value"),
+              333);
+    // LONG_MAX = 9223372036854775807
+    EXPECT_EQ(utils_get_size_threshold(
+                  (char *)"size.threshold=9223372036854775807;var=value"),
+              9223372036854775807);
+
+    // negative tests
+    EXPECT_EQ(utils_get_size_threshold(NULL), 0);
+    EXPECT_EQ(utils_get_size_threshold((char *)"size.threshold="), -1);
+    EXPECT_EQ(utils_get_size_threshold((char *)"size.threshold=abc"), -1);
+    EXPECT_EQ(utils_get_size_threshold((char *)"size.threshold=-111"), -1);
+}
+
+TEST_F(test, utils_errno_to_umf_result) {
+    EXPECT_EQ(utils_errno_to_umf_result(EBADF),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(utils_errno_to_umf_result(EINVAL),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(utils_errno_to_umf_result(ESRCH),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(utils_errno_to_umf_result(EPERM),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    EXPECT_EQ(utils_errno_to_umf_result(EMFILE),
+              UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY);
+    EXPECT_EQ(utils_errno_to_umf_result(ENOMEM),
+              UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY);
+
+    EXPECT_EQ(utils_errno_to_umf_result(ENODEV),
+              UMF_RESULT_ERROR_NOT_SUPPORTED);
+    EXPECT_EQ(utils_errno_to_umf_result(ENOSYS),
+              UMF_RESULT_ERROR_NOT_SUPPORTED);
+    EXPECT_EQ(utils_errno_to_umf_result(ENOTSUP),
+              UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    EXPECT_EQ(utils_errno_to_umf_result(E2BIG), UMF_RESULT_ERROR_UNKNOWN);
+}
+
+TEST_F(test, utils_translate_mem_protection_flags) {
+    umf_result_t umf_result;
+    unsigned out_protection;
+
+    umf_result = utils_translate_mem_protection_flags(UMF_PROTECTION_NONE,
+                                                      &out_protection);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    EXPECT_EQ(out_protection, PROT_NONE);
+
+    umf_result = utils_translate_mem_protection_flags(UMF_PROTECTION_READ,
+                                                      &out_protection);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    EXPECT_EQ(out_protection, PROT_READ);
+
+    umf_result = utils_translate_mem_protection_flags(UMF_PROTECTION_WRITE,
+                                                      &out_protection);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    EXPECT_EQ(out_protection, PROT_WRITE);
+
+    umf_result = utils_translate_mem_protection_flags(UMF_PROTECTION_EXEC,
+                                                      &out_protection);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    EXPECT_EQ(out_protection, PROT_EXEC);
+
+    umf_result = utils_translate_mem_protection_flags(
+        UMF_PROTECTION_READ | UMF_PROTECTION_WRITE, &out_protection);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    EXPECT_EQ(out_protection, PROT_READ | PROT_WRITE);
+
+    umf_result = utils_translate_mem_protection_flags(
+        UMF_PROTECTION_READ | UMF_PROTECTION_WRITE | UMF_PROTECTION_EXEC,
+        &out_protection);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    EXPECT_EQ(out_protection, PROT_READ | PROT_WRITE | PROT_EXEC);
+
+    umf_result = utils_translate_mem_protection_flags(
+        UMF_PROTECTION_READ | UMF_PROTECTION_EXEC, &out_protection);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    EXPECT_EQ(out_protection, PROT_READ | PROT_EXEC);
+
+    umf_result = utils_translate_mem_protection_flags(
+        UMF_PROTECTION_WRITE | UMF_PROTECTION_EXEC, &out_protection);
+    EXPECT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    EXPECT_EQ(out_protection, PROT_WRITE | PROT_EXEC);
+
+    // see https://github.com/oneapi-src/unified-memory-framework/issues/923
+    out_protection = 0;
+    umf_result = utils_translate_mem_protection_flags(
+        0xFFFF & ~(((UMF_PROTECTION_MAX - 1) << 1) - 1), &out_protection);
+    EXPECT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(out_protection, 0);
+}
+
+TEST_F(test, utils_translate_purge_advise) {
+    EXPECT_EQ(utils_translate_purge_advise(UMF_PURGE_LAZY), MADV_FREE);
+    EXPECT_EQ(utils_translate_purge_advise(UMF_PURGE_FORCE), MADV_DONTNEED);
+    EXPECT_EQ(utils_translate_purge_advise(UMF_PURGE_MAX), -1);
+}
+
+TEST_F(test, utils_open) {
+    EXPECT_EQ(utils_devdax_open(NULL), -1);
+    EXPECT_EQ(utils_file_open(NULL), -1);
+    EXPECT_EQ(utils_file_open_or_create(NULL), -1);
+}
+
+TEST_F(test, utils_align_ptr_up_size_down) {
+    uintptr_t ptr = 0x4000;
+    size_t size = 0x8000;
+    size_t alignment = 0x4000;
+    utils_align_ptr_up_size_down((void **)&ptr, &size, alignment);
+    EXPECT_EQ(ptr, 0x4000);
+    EXPECT_EQ(size, 0x8000);
+
+    ptr = 0x4001;
+    size = 0x8000;
+    alignment = 0x4000;
+    utils_align_ptr_up_size_down((void **)&ptr, &size, alignment);
+    EXPECT_EQ(ptr, 0x8000);
+    EXPECT_EQ(size, 0x4001);
+}
diff --git a/test/utils/utils_log.cpp b/test/utils/utils_log.cpp
index 3e899e685..cce61db58 100644
--- a/test/utils/utils_log.cpp
+++ b/test/utils/utils_log.cpp
@@ -19,7 +19,7 @@ FILE *mock_fopen(const char *filename, const char *mode) {
 }
 
 const std::string MOCK_FN_NAME = "MOCK_FUNCTION_NAME";
-std::string expected_message = "[ERROR UMF] util_log_init: Logging output not "
+std::string expected_message = "[ERROR UMF] utils_log_init: Logging output not "
                                "set - logging disabled (UMF_LOG = \"\")\n";
 // The expected_message (above) is printed to stderr.
 FILE *expected_stream = stderr;
@@ -98,7 +98,7 @@ const char *env_variable = "";
 #define fopen(A, B) mock_fopen(A, B)
 #define fputs(A, B) mock_fputs(A, B)
 #define fflush(A) mock_fflush(A)
-#define util_env_var(A, B, C) mock_util_env_var(A, B, C)
+#define utils_env_var(A, B, C) mock_utils_env_var(A, B, C)
 #if defined(__APPLE__)
 #define strerror_r(A, B, C) mock_strerror_posix(A, B, C)
 #else
@@ -107,9 +107,14 @@ const char *env_variable = "";
 #define strerror_s(A, B, C) mock_strerror_windows(A, B, C)
 //getenv returns 'char *' not 'const char *' so we need explicit cast to drop const
 #define getenv(X) strstr(X, "UMF_LOG") ? (char *)env_variable : getenv(X)
+#ifndef UMF_VERSION
 #define UMF_VERSION "test version"
+#endif
+#ifndef UMF_ALL_CMAKE_VARIABLES
+#define UMF_ALL_CMAKE_VARIABLES "test UMF_ALL_CMAKE_VARIABLES"
+#endif
 #include "utils/utils_log.c"
-#undef util_env_var
+#undef utils_env_var
 #undef fopen
 #undef fputs
 #undef fflush
@@ -120,13 +125,13 @@ void helper_log_init(const char *var) {
     env_variable = var;
     fopen_count = 0;
     fput_count = 0;
-    util_log_init();
+    utils_log_init();
     env_variable = NULL;
     EXPECT_EQ(fopen_count, expect_fopen_count);
     EXPECT_EQ(fput_count, expect_fput_count);
 }
 
-void helper_checkConfig(util_log_config_t *expected, util_log_config_t *is) {
+void helper_checkConfig(utils_log_config_t *expected, utils_log_config_t *is) {
     EXPECT_EQ(expected->level, is->level);
     EXPECT_EQ(expected->flushLevel, is->flushLevel);
     EXPECT_EQ(expected->output, is->output);
@@ -140,7 +145,7 @@ TEST_F(test, parseEnv_errors) {
 
     expect_fput_count = 0;
     expected_stream = stderr;
-    util_log_config_t b = loggerConfig;
+    utils_log_config_t b = loggerConfig;
     helper_log_init(NULL);
     helper_checkConfig(&b, &loggerConfig);
 
@@ -154,13 +159,13 @@ TEST_F(test, parseEnv_errors) {
     helper_log_init("_level:debug");
     helper_checkConfig(&b, &loggerConfig);
     expected_message =
-        "[ERROR UMF] util_log_init: Cannot open output file - path too long\n";
+        "[ERROR UMF] utils_log_init: Cannot open output file - path too long\n";
     std::string test_env = "output:file," + std::string(300, 'x');
     helper_log_init(test_env.c_str());
 }
 
 TEST_F(test, parseEnv) {
-    util_log_config_t b = loggerConfig;
+    utils_log_config_t b = loggerConfig;
     expected_message = "";
 
     std::vector<std::pair<std::string, int>> logLevels = {
@@ -226,9 +231,9 @@ TEST_F(test, parseEnv) {
                             expected_stream = output.second;
                             b.timestamp = timestamp.second;
                             b.pid = pid.second;
-                            b.flushLevel = (util_log_level_t)flushLevel.second;
+                            b.flushLevel = (utils_log_level_t)flushLevel.second;
 
-                            b.level = (util_log_level_t)logLevel.second;
+                            b.level = (utils_log_level_t)logLevel.second;
                             if (logLevel.second <= LOG_INFO) {
                                 expect_fput_count = 1;
                             }
@@ -236,7 +241,7 @@ TEST_F(test, parseEnv) {
                             expect_fput_count = 1;
                             if (expected_filename.size() > MAX_FILE_PATH) {
                                 expected_message =
-                                    "[ERROR UMF] util_log_init: Cannot open "
+                                    "[ERROR UMF] utils_log_init: Cannot open "
                                     "output file - path too long\n";
                             }
                         }
@@ -252,7 +257,7 @@ TEST_F(test, parseEnv) {
 template <typename... Args> void helper_test_log(Args... args) {
     fput_count = 0;
     fflush_count = 0;
-    util_log(args...);
+    utils_log(args...);
     EXPECT_EQ(fput_count, expect_fput_count);
     EXPECT_EQ(fflush_count, expect_fflush_count);
 }
@@ -279,7 +284,7 @@ TEST_F(test, log_levels) {
     expected_stream = stderr;
     for (int i = LOG_DEBUG; i <= LOG_ERROR; i++) {
         for (int j = LOG_DEBUG; j <= LOG_ERROR; j++) {
-            loggerConfig = {0, 0, (util_log_level_t)i, LOG_DEBUG, stderr};
+            loggerConfig = {0, 0, (utils_log_level_t)i, LOG_DEBUG, stderr};
             if (i > j) {
                 expect_fput_count = 0;
                 expect_fflush_count = 0;
@@ -290,7 +295,7 @@ TEST_F(test, log_levels) {
             }
             expected_message = "[" + helper_log_str(j) + " UMF] " +
                                MOCK_FN_NAME + ": example log\n";
-            helper_test_log((util_log_level_t)j, MOCK_FN_NAME.c_str(), "%s",
+            helper_test_log((utils_log_level_t)j, MOCK_FN_NAME.c_str(), "%s",
                             "example log");
         }
     }
@@ -313,7 +318,7 @@ TEST_F(test, flush_levels) {
     expect_fput_count = 1;
     for (int i = LOG_DEBUG; i <= LOG_ERROR; i++) {
         for (int j = LOG_DEBUG; j <= LOG_ERROR; j++) {
-            loggerConfig = {0, 0, LOG_DEBUG, (util_log_level_t)i, stderr};
+            loggerConfig = {0, 0, LOG_DEBUG, (utils_log_level_t)i, stderr};
             if (i > j) {
                 expect_fflush_count = 0;
             } else {
@@ -321,7 +326,7 @@ TEST_F(test, flush_levels) {
             }
             expected_message = "[" + helper_log_str(j) + " UMF] " +
                                MOCK_FN_NAME + ": example log\n";
-            helper_test_log((util_log_level_t)j, MOCK_FN_NAME.c_str(), "%s",
+            helper_test_log((utils_log_level_t)j, MOCK_FN_NAME.c_str(), "%s",
                             "example log");
         }
     }
@@ -418,7 +423,7 @@ TEST_F(test, log_macros) {
 template <typename... Args> void helper_test_plog(Args... args) {
     fput_count = 0;
     fflush_count = 0;
-    util_plog(args...);
+    utils_plog(args...);
     EXPECT_EQ(fput_count, expect_fput_count);
     EXPECT_EQ(fflush_count, expect_fflush_count);
 }
diff --git a/third_party/requirements.txt b/third_party/requirements.txt
index 8a5f6c4cf..1893e962d 100644
--- a/third_party/requirements.txt
+++ b/third_party/requirements.txt
@@ -1,17 +1,22 @@
 # 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.0
+packaging==25.0
 # Generating HTML documentation
-pygments==2.15.1
-sphinxcontrib_applehelp==1.0.4
-sphinxcontrib_devhelp==1.0.2
-sphinxcontrib_htmlhelp==2.0.1
-sphinxcontrib_serializinghtml==1.1.5
-sphinxcontrib_qthelp==1.0.3
-breathe==4.35.0
-sphinx==4.5.0
-sphinx_book_theme==0.3.3
+pygments==2.19.1
+sphinxcontrib_applehelp==2.0.0
+sphinxcontrib_devhelp==2.0.0
+sphinxcontrib_htmlhelp==2.1.0
+sphinxcontrib_serializinghtml==2.0.0
+sphinxcontrib_qthelp==2.0.0
+breathe==4.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